diff --git a/setup/extensions.py b/setup/extensions.py index 52a917e542..aec17e1d4d 100644 --- a/setup/extensions.py +++ b/setup/extensions.py @@ -75,7 +75,7 @@ extensions = [ Extension('dukpy', ['duktape/%s.c' % x for x in 'errors context conversions proxy module duktape/duktape'.split()], - headers=['duktape/dukpy.h', 'duktape/duktape/duktape.h'], + headers=['duktape/dukpy.h', 'duktape/duktape/duk_config.h', 'duktape/duktape/duktape.h'], optimize_level=2, ), diff --git a/src/duktape/duktape/duk_config.h b/src/duktape/duktape/duk_config.h new file mode 100644 index 0000000000..64c10ea79f --- /dev/null +++ b/src/duktape/duktape/duk_config.h @@ -0,0 +1,3643 @@ +/* + * duk_config.h configuration header generated by genconfig.py. + * + * Git commit: cad6f595382a0cc1a7e4207794ade5be11b3e397 + * Git describe: v1.4.0 + * Git branch: master + * + * Supported platforms: + * - Mac OSX, iPhone, Darwin + * - OpenBSD + * - Generic BSD + * - Atari ST TOS + * - AmigaOS + * - Windows + * - Flashplayer (Crossbridge) + * - QNX + * - TI-Nspire + * - Emscripten + * - Linux + * - Solaris + * - Generic POSIX + * - Cygwin + * - Generic UNIX + * - Generic fallback + * + * Supported architectures: + * - x86 + * - x64 + * - x32 + * - ARM 32-bit + * - ARM 64-bit + * - MIPS 32-bit + * - MIPS 64-bit + * - PowerPC 32-bit + * - PowerPC 64-bit + * - SPARC 32-bit + * - SPARC 64-bit + * - SuperH + * - Motorola 68k + * - Emscripten + * - Generic + * + * Supported compilers: + * - Clang + * - GCC + * - MSVC + * - Emscripten + * - TinyC + * - VBCC + * - Bruce's C compiler + * - Generic + * + */ + +#if !defined(DUK_CONFIG_H_INCLUDED) +#define DUK_CONFIG_H_INCLUDED + +/* + * Intermediate helper defines + */ + +/* DLL build detection */ +#if defined(DUK_OPT_DLL_BUILD) +#define DUK_F_DLL_BUILD +#elif defined(DUK_OPT_NO_DLL_BUILD) +#undef DUK_F_DLL_BUILD +#else +/* not configured for DLL build */ +#undef DUK_F_DLL_BUILD +#endif + +/* Apple OSX, iOS */ +#if defined(__APPLE__) +#define DUK_F_APPLE +#endif + +/* OpenBSD */ +#if defined(__OpenBSD__) || defined(__OpenBSD) +#define DUK_F_OPENBSD +#endif + +/* NetBSD */ +#if defined(__NetBSD__) || defined(__NetBSD) +#define DUK_F_NETBSD +#endif + +/* FreeBSD */ +#if defined(__FreeBSD__) || defined(__FreeBSD) +#define DUK_F_FREEBSD +#endif + +/* BSD variant */ +#if defined(DUK_F_FREEBSD) || defined(DUK_F_NETBSD) || defined(DUK_F_OPENBSD) || \ + defined(__bsdi__) || defined(__DragonFly__) +#define DUK_F_BSD +#endif + +/* Atari ST TOS. __TOS__ defined by PureC. No platform define in VBCC + * apparently, so to use with VBCC user must define __TOS__ manually. + */ +#if defined(__TOS__) +#define DUK_F_TOS +#endif + +/* Motorola 68K. Not defined by VBCC, so user must define one of these + * manually when using VBCC. + */ +#if defined(__m68k__) || defined(M68000) || defined(__MC68K__) +#define DUK_F_M68K +#endif + +/* AmigaOS. Neither AMIGA nor __amigaos__ is defined on VBCC, so user must + * define 'AMIGA' manually when using VBCC. + */ +#if defined(AMIGA) || defined(__amigaos__) +#define DUK_F_AMIGAOS +#endif + +/* PowerPC */ +#if defined(__powerpc) || defined(__powerpc__) || defined(__PPC__) +#define DUK_F_PPC +#if defined(__PPC64__) || defined(__LP64__) || defined(_LP64) +#define DUK_F_PPC64 +#else +#define DUK_F_PPC32 +#endif +#endif + +/* Windows, both 32-bit and 64-bit */ +#if defined(_WIN32) || defined(WIN32) || defined(_WIN64) || defined(WIN64) || \ + defined(__WIN32__) || defined(__TOS_WIN__) || defined(__WINDOWS__) +#define DUK_F_WINDOWS +#if defined(_WIN64) || defined(WIN64) +#define DUK_F_WIN64 +#else +#define DUK_F_WIN32 +#endif +#endif + +/* Flash player (e.g. Crossbridge) */ +#if defined(__FLASHPLAYER__) +#define DUK_F_FLASHPLAYER +#endif + +/* QNX */ +#if defined(__QNX__) +#define DUK_F_QNX +#endif + +/* TI-Nspire (using Ndless) */ +#if defined(_TINSPIRE) +#define DUK_F_TINSPIRE +#endif + +/* Emscripten (provided explicitly by user), improve if possible */ +#if defined(EMSCRIPTEN) +#define DUK_F_EMSCRIPTEN +#endif + +/* BCC (Bruce's C compiler): this is a "torture target" for compilation */ +#if defined(__BCC__) || defined(__BCC_VERSION__) +#define DUK_F_BCC +#endif + +/* Linux */ +#if defined(__linux) || defined(__linux__) || defined(linux) +#define DUK_F_LINUX +#endif + +/* illumos / Solaris */ +#if defined(__sun) && defined(__SVR4) +#define DUK_F_SUN +#endif + +/* POSIX */ +#if defined(__posix) +#define DUK_F_POSIX +#endif + +/* Cygwin */ +#if defined(__CYGWIN__) +#define DUK_F_CYGWIN +#endif + +/* Generic Unix (includes Cygwin) */ +#if defined(__unix) || defined(__unix__) || defined(unix) || \ + defined(DUK_F_LINUX) || defined(DUK_F_BSD) +#define DUK_F_UNIX +#endif + +/* stdint.h not available */ +#if defined(DUK_F_WINDOWS) && defined(_MSC_VER) +#if (_MSC_VER < 1700) +/* VS2012+ has stdint.h, < VS2012 does not (but it's available for download). */ +#define DUK_F_NO_STDINT_H +#endif +#endif +#if !defined(DUK_F_NO_STDINT_H) && (defined(DUK_F_TOS) || defined(DUK_F_BCC)) +#define DUK_F_NO_STDINT_H +#endif + +/* C++ */ +#undef DUK_F_CPP +#if defined(__cplusplus) +#define DUK_F_CPP +#endif + +/* Intel x86 (32-bit), x64 (64-bit) or x32 (64-bit but 32-bit pointers), + * define only one of DUK_F_X86, DUK_F_X64, DUK_F_X32. + * https://sites.google.com/site/x32abi/ + */ +#if defined(__amd64__) || defined(__amd64) || \ + defined(__x86_64__) || defined(__x86_64) || \ + defined(_M_X64) || defined(_M_AMD64) +#if defined(__ILP32__) || defined(_ILP32) +#define DUK_F_X32 +#else +#define DUK_F_X64 +#endif +#elif defined(i386) || defined(__i386) || defined(__i386__) || \ + defined(__i486__) || defined(__i586__) || defined(__i686__) || \ + defined(__IA32__) || defined(_M_IX86) || defined(__X86__) || \ + defined(_X86_) || defined(__THW_INTEL__) || defined(__I86__) +#if defined(__LP64__) || defined(_LP64) +/* This should not really happen, but would indicate x64. */ +#define DUK_F_X64 +#else +#define DUK_F_X86 +#endif +#endif + +/* ARM */ +#if defined(__arm__) || defined(__thumb__) || defined(_ARM) || defined(_M_ARM) +#define DUK_F_ARM +#if defined(__LP64__) || defined(_LP64) || defined(__arm64) || defined(__arm64__) +#define DUK_F_ARM64 +#else +#define DUK_F_ARM32 +#endif +#endif + +/* MIPS. Related defines: __MIPSEB__, __MIPSEL__, __mips_isa_rev, __LP64__ */ +#if defined(__mips__) || defined(mips) || defined(_MIPS_ISA) || \ + defined(_R3000) || defined(_R4000) || defined(_R5900) || \ + defined(_MIPS_ISA_MIPS1) || defined(_MIPS_ISA_MIPS2) || \ + defined(_MIPS_ISA_MIPS3) || defined(_MIPS_ISA_MIPS4) || \ + defined(__mips) || defined(__MIPS__) +#define DUK_F_MIPS +#if defined(__LP64__) || defined(_LP64) || defined(__mips64) || \ + defined(__mips64__) || defined(__mips_n64) +#define DUK_F_MIPS64 +#else +#define DUK_F_MIPS32 +#endif +#endif + +/* SPARC */ +#if defined(sparc) || defined(__sparc) || defined(__sparc__) +#define DUK_F_SPARC +#if defined(__LP64__) || defined(_LP64) +#define DUK_F_SPARC64 +#else +#define DUK_F_SPARC32 +#endif +#endif + +/* SuperH */ +#if defined(__sh__) || \ + defined(__sh1__) || defined(__SH1__) || \ + defined(__sh2__) || defined(__SH2__) || \ + defined(__sh3__) || defined(__SH3__) || \ + defined(__sh4__) || defined(__SH4__) || \ + defined(__sh5__) || defined(__SH5__) +#define DUK_F_SUPERH +#endif + +/* Clang */ +#if defined(__clang__) +#define DUK_F_CLANG +#endif + +/* C99 or above */ +#undef DUK_F_C99 +#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) +#define DUK_F_C99 +#endif + +/* C++11 or above */ +#undef DUK_F_CPP11 +#if defined(__cplusplus) && (__cplusplus >= 201103L) +#define DUK_F_CPP11 +#endif + +/* GCC. Clang also defines __GNUC__ so don't detect GCC if using Clang. */ +#if defined(__GNUC__) && !defined(__clang__) && !defined(DUK_F_CLANG) +#define DUK_F_GCC +#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) +/* Convenience, e.g. gcc 4.5.1 == 40501; http://stackoverflow.com/questions/6031819/emulating-gccs-builtin-unreachable */ +#define DUK_F_GCC_VERSION (__GNUC__ * 10000L + __GNUC_MINOR__ * 100L + __GNUC_PATCHLEVEL__) +#else +#error cannot figure out gcc version +#endif +#endif + +/* MinGW. Also GCC flags (DUK_F_GCC) are enabled now. */ +#if defined(__MINGW32__) || defined(__MINGW64__) +#define DUK_F_MINGW +#endif + +/* MSVC */ +#if defined(_MSC_VER) +/* MSVC preprocessor defines: http://msdn.microsoft.com/en-us/library/b0084kay.aspx + * _MSC_FULL_VER includes the build number, but it has at least two formats, see e.g. + * BOOST_MSVC_FULL_VER in http://www.boost.org/doc/libs/1_52_0/boost/config/compiler/visualc.hpp + */ +#define DUK_F_MSVC +#if defined(_MSC_FULL_VER) +#if (_MSC_FULL_VER > 100000000) +#define DUK_F_MSVC_FULL_VER _MSC_FULL_VER +#else +#define DUK_F_MSCV_FULL_VER (_MSC_FULL_VER * 10) +#endif +#endif +#endif /* _MSC_VER */ + +/* TinyC */ +#if defined(__TINYC__) +/* http://bellard.org/tcc/tcc-doc.html#SEC9 */ +#define DUK_F_TINYC +#endif + +/* VBCC */ +#if defined(__VBCC__) +#define DUK_F_VBCC +#endif + +/* + * Platform autodetection + */ + +/* Workaround for older C++ compilers before including , + * see e.g.: https://sourceware.org/bugzilla/show_bug.cgi?id=15366 + */ +#if defined(__cplusplus) && !defined(__STDC_LIMIT_MACROS) +#define __STDC_LIMIT_MACROS +#endif +#if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS) +#define __STDC_CONSTANT_MACROS +#endif + +#if defined(DUK_F_APPLE) +/* --- Mac OSX, iPhone, Darwin --- */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include +#include +#include + +/* http://stackoverflow.com/questions/5919996/how-to-detect-reliably-mac-os-x-ios-linux-windows-in-c-preprocessor */ +#if TARGET_IPHONE_SIMULATOR +#define DUK_USE_OS_STRING "iphone-sim" +#elif TARGET_OS_IPHONE +#define DUK_USE_OS_STRING "iphone" +#elif TARGET_OS_MAC +#define DUK_USE_OS_STRING "ios" +#else +#define DUK_USE_OS_STRING "ios-unknown" +#endif + +/* Use _setjmp() on Apple by default, see GH-55. */ +#define DUK_USE_UNDERSCORE_SETJMP +#define DUK_SETJMP(jb) _setjmp((jb)) +#define DUK_LONGJMP(jb) _longjmp((jb), 1) +#elif defined(DUK_F_OPENBSD) +/* --- OpenBSD --- */ +/* http://www.monkey.org/openbsd/archive/ports/0401/msg00089.html */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include +#include +#include + +#define DUK_USE_OS_STRING "openbsd" +#elif defined(DUK_F_BSD) +/* --- Generic BSD --- */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include +#include +#include + +#define DUK_USE_OS_STRING "bsd" +#elif defined(DUK_F_TOS) +/* --- Atari ST TOS --- */ +#define DUK_USE_DATE_NOW_TIME +#define DUK_USE_DATE_TZO_GMTIME +/* no parsing (not an error) */ +#define DUK_USE_DATE_FMT_STRFTIME +#include + +#define DUK_USE_OS_STRING "tos" + +/* TOS on M68K is always big endian. */ +#if !defined(DUK_USE_BYTEORDER) && defined(DUK_F_M68K) +#define DUK_USE_BYTEORDER 3 +#endif +#elif defined(DUK_F_AMIGAOS) +/* --- AmigaOS --- */ +#if defined(DUK_F_M68K) +/* AmigaOS on M68k */ +#define DUK_USE_DATE_NOW_TIME +#define DUK_USE_DATE_TZO_GMTIME +/* no parsing (not an error) */ +#define DUK_USE_DATE_FMT_STRFTIME +#include +#elif defined(DUK_F_PPC) +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#ifndef UINTPTR_MAX +#define UINTPTR_MAX UINT_MAX +#endif +#else +#error AmigaOS but not M68K/PPC, not supported now +#endif + +#define DUK_USE_OS_STRING "amigaos" + +/* AmigaOS on M68K or PPC is always big endian. */ +#if !defined(DUK_USE_BYTEORDER) && (defined(DUK_F_M68K) || defined(DUK_F_PPC)) +#define DUK_USE_BYTEORDER 3 +#endif +#elif defined(DUK_F_WINDOWS) +/* --- Windows --- */ +/* Initial fix: disable secure CRT related warnings when compiling Duktape + * itself (must be defined before including Windows headers). Don't define + * for user code including duktape.h. + */ +#if defined(DUK_COMPILING_DUKTAPE) && !defined(_CRT_SECURE_NO_WARNINGS) +#define _CRT_SECURE_NO_WARNINGS +#endif + +/* Windows 32-bit and 64-bit are currently the same. */ +/* MSVC does not have sys/param.h */ +#define DUK_USE_DATE_NOW_WINDOWS +#define DUK_USE_DATE_TZO_WINDOWS +/* Note: PRS and FMT are intentionally left undefined for now. This means + * there is no platform specific date parsing/formatting but there is still + * the ISO 8601 standard format. + */ +#if defined(DUK_COMPILING_DUKTAPE) +/* Only include when compiling Duktape to avoid polluting application build + * with a lot of unnecessary defines. + */ +#include +#endif + +#define DUK_USE_OS_STRING "windows" + +/* On Windows, assume we're little endian. Even Itanium which has a + * configurable endianness runs little endian in Windows. + */ +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 1 +#endif +#elif defined(DUK_F_FLASHPLAYER) +/* --- Flashplayer (Crossbridge) --- */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include +#include + +#define DUK_USE_OS_STRING "flashplayer" + +#if !defined(DUK_USE_BYTEORDER) && defined(DUK_F_FLASHPLAYER) +#define DUK_USE_BYTEORDER 1 +#endif +#elif defined(DUK_F_QNX) +/* --- QNX --- */ +#if defined(DUK_F_QNX) && defined(DUK_COMPILING_DUKTAPE) +/* See: /opt/qnx650/target/qnx6/usr/include/sys/platform.h */ +#define _XOPEN_SOURCE 600 +#define _POSIX_C_SOURCE 200112L +#endif + +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include +#include + +#define DUK_USE_OS_STRING "qnx" +#elif defined(DUK_F_TINSPIRE) +/* --- TI-Nspire --- */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include +#include + +#define DUK_USE_OS_STRING "tinspire" +#elif defined(DUK_F_EMSCRIPTEN) +/* --- Emscripten --- */ +#if defined(DUK_COMPILING_DUKTAPE) +#ifndef _POSIX_C_SOURCE +#define _POSIX_C_SOURCE 200809L +#endif +#ifndef _GNU_SOURCE +#define _GNU_SOURCE /* e.g. getdate_r */ +#endif +#ifndef _XOPEN_SOURCE +#define _XOPEN_SOURCE /* e.g. strptime */ +#endif +#endif /* DUK_COMPILING_DUKTAPE */ + +#include +#if defined(DUK_F_BCC) +/* no endian.h */ +#else +#include +#endif /* DUK_F_BCC */ +#include +#include +#include +#include + +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME + +#define DUK_USE_OS_STRING "emscripten" +#elif defined(DUK_F_LINUX) +/* --- Linux --- */ +#if defined(DUK_COMPILING_DUKTAPE) +#ifndef _POSIX_C_SOURCE +#define _POSIX_C_SOURCE 200809L +#endif +#ifndef _GNU_SOURCE +#define _GNU_SOURCE /* e.g. getdate_r */ +#endif +#ifndef _XOPEN_SOURCE +#define _XOPEN_SOURCE /* e.g. strptime */ +#endif +#endif /* DUK_COMPILING_DUKTAPE */ + +#include +#if defined(DUK_F_BCC) +/* no endian.h or stdint.h */ +#else +#include +#include +#endif /* DUK_F_BCC */ +#include +#include +#include + +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME + +#define DUK_USE_OS_STRING "linux" +#elif defined(DUK_F_SUN) +/* --- Solaris --- */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME + +#include +#include +#include +#include +#include + +#define DUK_USE_OS_STRING "solaris" +#elif defined(DUK_F_POSIX) +/* --- Generic POSIX --- */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include +#include +#include + +#define DUK_USE_OS_STRING "posix" +#elif defined(DUK_F_CYGWIN) +/* --- Cygwin --- */ +/* don't use strptime() for now */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include +#include +#include + +#define DUK_USE_UNDERSCORE_SETJMP +#define DUK_SETJMP(jb) _setjmp((jb)) +#define DUK_LONGJMP(jb) _longjmp((jb), 1) + +#define DUK_USE_OS_STRING "windows" +#elif defined(DUK_F_UNIX) +/* --- Generic UNIX --- */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#define DUK_USE_OS_STRING "unknown" +#else +/* --- Generic fallback --- */ +/* The most portable current time provider is time(), but it only has a + * one second resolution. + */ +#define DUK_USE_DATE_NOW_TIME + +/* The most portable way to figure out local time offset is gmtime(), + * but it's not thread safe so use with caution. + */ +#define DUK_USE_DATE_TZO_GMTIME + +/* Avoid custom date parsing and formatting for portability. */ +#undef DUK_USE_DATE_PRS_STRPTIME +#undef DUK_USE_DATE_FMT_STRFTIME + +/* Rely on C89 headers only; time.h must be here. */ +#include + +#define DUK_USE_OS_STRING "unknown" +#endif /* autodetect platform */ + +/* Shared includes: C89 */ +#include +#include +#include +#include /* varargs */ +#include +#include /* e.g. ptrdiff_t */ +#include +#include + +/* date.h is omitted, and included per platform */ + +/* Shared includes: stdint.h is C99 */ +#if defined(DUK_F_NO_STDINT_H) +/* stdint.h not available */ +#else +/* Technically C99 (C++11) but found in many systems. On some systems + * __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS must be defined before + * including stdint.h (see above). + */ +#include +#endif + +#if defined(DUK_F_CPP) +#include /* std::exception */ +#endif + +/* + * Architecture autodetection + */ + +#if defined(DUK_F_X86) +/* --- x86 --- */ +#define DUK_USE_ARCH_STRING "x86" +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 1 +#endif +/* XXX: This is technically not guaranteed because it's possible to configure + * an x86 to require aligned accesses with Alignment Check (AC) flag. + */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 1 +#endif +#define DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_X64) +/* --- x64 --- */ +#define DUK_USE_ARCH_STRING "x64" +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 1 +#endif +/* XXX: This is technically not guaranteed because it's possible to configure + * an x86 to require aligned accesses with Alignment Check (AC) flag. + */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 1 +#endif +#undef DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_X32) +/* --- x32 --- */ +#define DUK_USE_ARCH_STRING "x32" +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 1 +#endif +/* XXX: This is technically not guaranteed because it's possible to configure + * an x86 to require aligned accesses with Alignment Check (AC) flag. + */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 1 +#endif +#define DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_ARM32) +/* --- ARM 32-bit --- */ +#define DUK_USE_ARCH_STRING "arm32" +/* Byte order varies, so rely on autodetect. */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 4 +#endif +#define DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_ARM64) +/* --- ARM 64-bit --- */ +#define DUK_USE_ARCH_STRING "arm64" +/* Byte order varies, so rely on autodetect. */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 8 +#endif +#undef DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_MIPS32) +/* --- MIPS 32-bit --- */ +#define DUK_USE_ARCH_STRING "mips32" +/* MIPS byte order varies so rely on autodetection. */ +/* Based on 'make checkalign' there are no alignment requirements on + * Linux MIPS except for doubles, which need align by 4. Alignment + * requirements vary based on target though. + */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 4 +#endif +#define DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_MIPS64) +/* --- MIPS 64-bit --- */ +#define DUK_USE_ARCH_STRING "mips64" +/* MIPS byte order varies so rely on autodetection. */ +/* Good default is a bit arbitrary because alignment requirements + * depend on target. See https://github.com/svaarala/duktape/issues/102. + */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 8 +#endif +#undef DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_PPC32) +/* --- PowerPC 32-bit --- */ +#define DUK_USE_ARCH_STRING "ppc32" +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 3 +#endif +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 8 +#endif +#define DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_PPC64) +/* --- PowerPC 64-bit --- */ +#define DUK_USE_ARCH_STRING "ppc64" +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 3 +#endif +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 8 +#endif +#undef DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_SPARC32) +/* --- SPARC 32-bit --- */ +#define DUK_USE_ARCH_STRING "sparc32" +/* SPARC byte order varies so rely on autodetection. */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 8 +#endif +#define DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_SPARC64) +/* --- SPARC 64-bit --- */ +#define DUK_USE_ARCH_STRING "sparc64" +/* SPARC byte order varies so rely on autodetection. */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 8 +#endif +#undef DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_SUPERH) +/* --- SuperH --- */ +#define DUK_USE_ARCH_STRING "sh" +/* Byte order varies, rely on autodetection. */ +/* Based on 'make checkalign' there are no alignment requirements on + * Linux SH4, but align by 4 is probably a good basic default. + */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 4 +#endif +#define DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_M68K) +/* --- Motorola 68k --- */ +#define DUK_USE_ARCH_STRING "m68k" +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 3 +#endif +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 8 +#endif +#define DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_EMSCRIPTEN) +/* --- Emscripten --- */ +#define DUK_USE_ARCH_STRING "emscripten" +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 1 +#endif +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 8 +#endif +#undef DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#else +/* --- Generic --- */ +/* These are necessary wild guesses. */ +#define DUK_USE_ARCH_STRING "generic" +/* Rely on autodetection for byte order, alignment, and packed tval. */ +#endif /* autodetect architecture */ + +/* + * Compiler autodetection + */ + +#if defined(DUK_F_CLANG) +/* --- Clang --- */ +#if defined(DUK_F_C99) || defined(DUK_F_CPP11) +/* C99 / C++11 and above: rely on va_copy() which is required. */ +#define DUK_VA_COPY(dest,src) va_copy(dest,src) +#else +/* Clang: assume we have __va_copy() in non-C99 mode. */ +#define DUK_VA_COPY(dest,src) __va_copy(dest,src) +#endif + +#define DUK_NORETURN(decl) decl __attribute__((noreturn)) + +#if defined(__clang__) && defined(__has_builtin) +#if __has_builtin(__builtin_unreachable) +#define DUK_UNREACHABLE() do { __builtin_unreachable(); } while (0) +#endif +#endif + +#define DUK_USE_BRANCH_HINTS +#define DUK_LIKELY(x) __builtin_expect((x), 1) +#define DUK_UNLIKELY(x) __builtin_expect((x), 0) + +#if defined(DUK_F_C99) || defined(DUK_F_CPP11) +#define DUK_NOINLINE __attribute__((noinline)) +#define DUK_INLINE inline +#define DUK_ALWAYS_INLINE inline __attribute__((always_inline)) +#endif + +#if defined(DUK_F_DLL_BUILD) && defined(DUK_F_WINDOWS) +/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're + * compiling Duktape or the application. + */ +#if defined(DUK_COMPILING_DUKTAPE) +#define DUK_EXTERNAL_DECL extern __declspec(dllexport) +#define DUK_EXTERNAL __declspec(dllexport) +#else +#define DUK_EXTERNAL_DECL extern __declspec(dllimport) +#define DUK_EXTERNAL should_not_happen +#endif +#if defined(DUK_SINGLE_FILE) +#define DUK_INTERNAL_DECL static +#define DUK_INTERNAL static +#else +#define DUK_INTERNAL_DECL extern +#define DUK_INTERNAL /*empty*/ +#endif +#define DUK_LOCAL_DECL static +#define DUK_LOCAL static + +#else +#define DUK_EXTERNAL_DECL __attribute__ ((visibility("default"))) extern +#define DUK_EXTERNAL __attribute__ ((visibility("default"))) +#if defined(DUK_SINGLE_FILE) +#define DUK_INTERNAL_DECL static +#define DUK_INTERNAL static +#else +#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) extern +#define DUK_INTERNAL __attribute__ ((visibility("hidden"))) +#endif +#define DUK_LOCAL_DECL static +#define DUK_LOCAL static +#endif + +#if defined(DUK_F_CPP) +#define DUK_USE_COMPILER_STRING "clang" +#else +#define DUK_USE_COMPILER_STRING "clang" +#endif + +#undef DUK_USE_VARIADIC_MACROS +#if defined(DUK_F_C99) || defined(DUK_F_CPP11) +#define DUK_USE_VARIADIC_MACROS +#endif + +#undef DUK_USE_FLEX_C99 +#undef DUK_USE_FLEX_ZEROSIZE +#undef DUK_USE_FLEX_ONESIZE +#if defined(DUK_F_C99) +#define DUK_USE_FLEX_C99 +#else +#define DUK_USE_FLEX_ZEROSIZE +#endif + +#undef DUK_USE_GCC_PRAGMAS +#define DUK_USE_PACK_CLANG_ATTR +#define DUK_F_VARIADIC_MACROS_PROVIDED +#elif defined(DUK_F_GCC) +/* --- GCC --- */ +#if defined(DUK_F_C99) || defined(DUK_F_CPP11) +/* C99 / C++11 and above: rely on va_copy() which is required. */ +#define DUK_VA_COPY(dest,src) va_copy(dest,src) +#else +/* GCC: assume we have __va_copy() in non-C99 mode. */ +#define DUK_VA_COPY(dest,src) __va_copy(dest,src) +#endif + +#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 20500L) +/* since gcc-2.5 */ +#define DUK_NORETURN(decl) decl __attribute__((noreturn)) +#endif + +#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40500L) +/* since gcc-4.5 */ +#define DUK_UNREACHABLE() do { __builtin_unreachable(); } while (0) +#endif + +#define DUK_USE_BRANCH_HINTS +#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40500L) +/* GCC: test not very accurate; enable only in relatively recent builds + * because of bugs in gcc-4.4 (http://lists.debian.org/debian-gcc/2010/04/msg00000.html) + */ +#define DUK_LIKELY(x) __builtin_expect((x), 1) +#define DUK_UNLIKELY(x) __builtin_expect((x), 0) +#endif + +#if (defined(DUK_F_C99) || defined(DUK_F_CPP11)) && \ + defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 30101) +#define DUK_NOINLINE __attribute__((noinline)) +#define DUK_INLINE inline +#define DUK_ALWAYS_INLINE inline __attribute__((always_inline)) +#endif + +#if defined(DUK_F_DLL_BUILD) && defined(DUK_F_WINDOWS) +/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're + * compiling Duktape or the application. + */ +#if defined(DUK_COMPILING_DUKTAPE) +#define DUK_EXTERNAL_DECL extern __declspec(dllexport) +#define DUK_EXTERNAL __declspec(dllexport) +#else +#define DUK_EXTERNAL_DECL extern __declspec(dllimport) +#define DUK_EXTERNAL should_not_happen +#endif +#if defined(DUK_SINGLE_FILE) +#define DUK_INTERNAL_DECL static +#define DUK_INTERNAL static +#else +#define DUK_INTERNAL_DECL extern +#define DUK_INTERNAL /*empty*/ +#endif +#define DUK_LOCAL_DECL static +#define DUK_LOCAL static + +#elif defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40000) +#define DUK_EXTERNAL_DECL __attribute__ ((visibility("default"))) extern +#define DUK_EXTERNAL __attribute__ ((visibility("default"))) +#if defined(DUK_SINGLE_FILE) +#define DUK_INTERNAL_DECL static +#define DUK_INTERNAL static +#else +#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) extern +#define DUK_INTERNAL __attribute__ ((visibility("hidden"))) +#endif +#define DUK_LOCAL_DECL static +#define DUK_LOCAL static +#endif + +#if defined(DUK_F_MINGW) +#if defined(DUK_F_CPP) +#define DUK_USE_COMPILER_STRING "mingw++" +#else +#define DUK_USE_COMPILER_STRING "mingw" +#endif +#else +#if defined(DUK_F_CPP) +#define DUK_USE_COMPILER_STRING "g++" +#else +#define DUK_USE_COMPILER_STRING "gcc" +#endif +#endif + +#undef DUK_USE_VARIADIC_MACROS +#if defined(DUK_F_C99) || (defined(DUK_F_CPP11) && defined(__GNUC__)) +#define DUK_USE_VARIADIC_MACROS +#endif + +#undef DUK_USE_FLEX_C99 +#undef DUK_USE_FLEX_ZEROSIZE +#undef DUK_USE_FLEX_ONESIZE +#if defined(DUK_F_C99) +#define DUK_USE_FLEX_C99 +#else +#define DUK_USE_FLEX_ZEROSIZE +#endif + +#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40600) +#define DUK_USE_GCC_PRAGMAS +#else +#undef DUK_USE_GCC_PRAGMAS +#endif + +#define DUK_USE_PACK_GCC_ATTR +#define DUK_F_VARIADIC_MACROS_PROVIDED +#elif defined(DUK_F_MSVC) +/* --- MSVC --- */ +/* http://msdn.microsoft.com/en-us/library/aa235362(VS.60).aspx */ +#define DUK_NORETURN(decl) __declspec(noreturn) decl + +/* XXX: DUK_UNREACHABLE for msvc? */ + +#undef DUK_USE_BRANCH_HINTS + +/* XXX: DUK_LIKELY, DUK_UNLIKELY for msvc? */ +/* XXX: DUK_NOINLINE, DUK_INLINE, DUK_ALWAYS_INLINE for msvc? */ + +#if defined(DUK_F_DLL_BUILD) && defined(DUK_F_WINDOWS) +/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're + * compiling Duktape or the application. + */ +#if defined(DUK_COMPILING_DUKTAPE) +#define DUK_EXTERNAL_DECL extern __declspec(dllexport) +#define DUK_EXTERNAL __declspec(dllexport) +#else +#define DUK_EXTERNAL_DECL extern __declspec(dllimport) +#define DUK_EXTERNAL should_not_happen +#endif +#if defined(DUK_SINGLE_FILE) +#define DUK_INTERNAL_DECL static +#define DUK_INTERNAL static +#else +#define DUK_INTERNAL_DECL extern +#define DUK_INTERNAL /*empty*/ +#endif +#define DUK_LOCAL_DECL static +#define DUK_LOCAL static + +#endif + +#if defined(DUK_F_CPP) +#define DUK_USE_COMPILER_STRING "msvc++" +#else +#define DUK_USE_COMPILER_STRING "msvc" +#endif + +#undef DUK_USE_VARIADIC_MACROS +#if defined(DUK_F_C99) +#define DUK_USE_VARIADIC_MACROS +#elif defined(_MSC_VER) && (_MSC_VER >= 1400) +/* VS2005+ should have variadic macros even when they're not C99. */ +#define DUK_USE_VARIADIC_MACROS +#endif + +#undef DUK_USE_FLEX_C99 +#undef DUK_USE_FLEX_ZEROSIZE +#undef DUK_USE_FLEX_ONESIZE +#if defined(DUK_F_C99) +#define DUK_USE_FLEX_C99 +#else +#define DUK_USE_FLEX_ZEROSIZE +#endif + +#undef DUK_USE_GCC_PRAGMAS + +#define DUK_USE_PACK_MSVC_PRAGMA + +#if defined(_MSC_VER) && (_MSC_VER >= 1900) +#define DUK_SNPRINTF snprintf +#define DUK_VSNPRINTF vsnprintf +#else +/* (v)snprintf() is missing before MSVC 2015. Note that _(v)snprintf() does + * NOT NUL terminate on truncation, but Duktape code never assumes that. + * http://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010 + */ +#define DUK_SNPRINTF _snprintf +#define DUK_VSNPRINTF _vsnprintf +#endif +#define DUK_F_VARIADIC_MACROS_PROVIDED +#elif defined(DUK_F_EMSCRIPTEN) +/* --- Emscripten --- */ +#define DUK_NORETURN(decl) decl __attribute__((noreturn)) + +#if defined(__clang__) && defined(__has_builtin) +#if __has_builtin(__builtin_unreachable) +#define DUK_UNREACHABLE() do { __builtin_unreachable(); } while (0) +#endif +#endif + +#define DUK_USE_BRANCH_HINTS +#define DUK_LIKELY(x) __builtin_expect((x), 1) +#define DUK_UNLIKELY(x) __builtin_expect((x), 0) + +#if defined(DUK_F_C99) || defined(DUK_F_CPP11) +#define DUK_NOINLINE __attribute__((noinline)) +#define DUK_INLINE inline +#define DUK_ALWAYS_INLINE inline __attribute__((always_inline)) +#endif + +#define DUK_EXTERNAL_DECL __attribute__ ((visibility("default"))) extern +#define DUK_EXTERNAL __attribute__ ((visibility("default"))) +#if defined(DUK_SINGLE_FILE) +#define DUK_INTERNAL_DECL static +#define DUK_INTERNAL static +#else +#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) extern +#define DUK_INTERNAL __attribute__ ((visibility("hidden"))) +#endif +#define DUK_LOCAL_DECL static +#define DUK_LOCAL static + +#define DUK_USE_COMPILER_STRING "emscripten" + +#undef DUK_USE_VARIADIC_MACROS +#if defined(DUK_F_C99) || defined(DUK_F_CPP11) +#define DUK_USE_VARIADIC_MACROS +#endif + +#undef DUK_USE_FLEX_C99 +#undef DUK_USE_FLEX_ZEROSIZE +#undef DUK_USE_FLEX_ONESIZE +#if defined(DUK_F_C99) +#define DUK_USE_FLEX_C99 +#else +#define DUK_USE_FLEX_ZEROSIZE +#endif + +#undef DUK_USE_GCC_PRAGMAS +#define DUK_USE_PACK_CLANG_ATTR +#define DUK_F_VARIADIC_MACROS_PROVIDED +#elif defined(DUK_F_TINYC) +/* --- TinyC --- */ +#undef DUK_USE_BRANCH_HINTS + +#if defined(DUK_F_CPP) +#define DUK_USE_COMPILER_STRING "tinyc++" +#else +#define DUK_USE_COMPILER_STRING "tinyc" +#endif + +/* http://bellard.org/tcc/tcc-doc.html#SEC7 */ +#define DUK_USE_VARIADIC_MACROS + +/* Most portable, wastes space */ +#define DUK_USE_FLEX_ONESIZE + +/* Most portable, potentially wastes space */ +#define DUK_USE_PACK_DUMMY_MEMBER +#define DUK_F_VARIADIC_MACROS_PROVIDED +#elif defined(DUK_F_VBCC) +/* --- VBCC --- */ +#undef DUK_USE_BRANCH_HINTS + +#if defined(DUK_F_CPP) +#define DUK_USE_COMPILER_STRING "vbcc-c++" +#else +#define DUK_USE_COMPILER_STRING "vbcc" +#endif + +#undef DUK_USE_VARIADIC_MACROS +#if defined(DUK_F_C99) || defined(DUK_F_CPP11) +#define DUK_USE_VARIADIC_MACROS +#endif + +#define DUK_USE_FLEX_ZEROSIZE +#define DUK_USE_PACK_DUMMY_MEMBER +#define DUK_F_VARIADIC_MACROS_PROVIDED +#elif defined(DUK_F_BCC) +/* --- Bruce's C compiler --- */ +#undef DUK_USE_BRANCH_HINTS + +#if defined(DUK_F_CPP) +#define DUK_USE_COMPILER_STRING "bcc++" +#else +#define DUK_USE_COMPILER_STRING "bcc" +#endif + +/* XXX */ +#undef DUK_USE_VARIADIC_MACROS + +/* Most portable, wastes space */ +#define DUK_USE_FLEX_ONESIZE + +/* Most portable, potentially wastes space */ +#define DUK_USE_PACK_DUMMY_MEMBER + +/* BCC, assume we're on x86. */ +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 1 +#endif +#define DUK_F_VARIADIC_MACROS_PROVIDED +#else +/* --- Generic --- */ +#undef DUK_USE_BRANCH_HINTS + +#if defined(DUK_F_CPP) +#define DUK_USE_COMPILER_STRING "generic-c++" +#else +#define DUK_USE_COMPILER_STRING "generic" +#endif + +#undef DUK_USE_VARIADIC_MACROS +#if defined(DUK_F_C99) || defined(DUK_F_CPP11) +#define DUK_USE_VARIADIC_MACROS +#endif + +/* Most portable, wastes space */ +#define DUK_USE_FLEX_ONESIZE + +/* Most portable, potentially wastes space */ +#define DUK_USE_PACK_DUMMY_MEMBER +#define DUK_F_VARIADIC_MACROS_PROVIDED +#endif /* autodetect compiler */ + +/* uclibc */ +#if defined(__UCLIBC__) +#define DUK_F_UCLIBC +#endif + +/* + * Wrapper typedefs and constants for integer types, also sanity check types. + * + * C99 typedefs are quite good but not always available, and we want to avoid + * forcibly redefining the C99 typedefs. So, there are Duktape wrappers for + * all C99 typedefs and Duktape code should only use these typedefs. Type + * detection when C99 is not supported is best effort and may end up detecting + * some types incorrectly. + * + * Pointer sizes are a portability problem: pointers to different types may + * have a different size and function pointers are very difficult to manage + * portably. + * + * http://en.wikipedia.org/wiki/C_data_types#Fixed-width_integer_types + * + * Note: there's an interesting corner case when trying to define minimum + * signed integer value constants which leads to the current workaround of + * defining e.g. -0x80000000 as (-0x7fffffffL - 1L). See doc/code-issues.txt + * for a longer discussion. + * + * Note: avoid typecasts and computations in macro integer constants as they + * can then no longer be used in macro relational expressions (such as + * #if DUK_SIZE_MAX < 0xffffffffUL). There is internal code which relies on + * being able to compare DUK_SIZE_MAX against a limit. + */ + +/* XXX: add feature options to force basic types from outside? */ + +#if !defined(INT_MAX) +#error INT_MAX not defined +#endif + +/* Check that architecture is two's complement, standard C allows e.g. + * INT_MIN to be -2**31+1 (instead of -2**31). + */ +#if defined(INT_MAX) && defined(INT_MIN) +#if INT_MAX != -(INT_MIN + 1) +#error platform does not seem complement of two +#endif +#else +#error cannot check complement of two +#endif + +/* Pointer size determination based on __WORDSIZE or architecture when + * that's not available. + */ +#if defined(DUK_F_X86) || defined(DUK_F_X32) || \ + defined(DUK_F_M68K) || defined(DUK_F_PPC32) || \ + defined(DUK_F_BCC) || \ + (defined(__WORDSIZE) && (__WORDSIZE == 32)) +#define DUK_F_32BIT_PTRS +#elif defined(DUK_F_X64) || \ + (defined(__WORDSIZE) && (__WORDSIZE == 64)) +#define DUK_F_64BIT_PTRS +#else +/* not sure, not needed with C99 anyway */ +#endif + +/* Intermediate define for 'have inttypes.h' */ +#undef DUK_F_HAVE_INTTYPES +#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ + !(defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC)) +/* vbcc + AmigaOS has C99 but no inttypes.h */ +#define DUK_F_HAVE_INTTYPES +#elif defined(__cplusplus) && (__cplusplus >= 201103L) +/* C++11 apparently ratified stdint.h */ +#define DUK_F_HAVE_INTTYPES +#endif + +/* Basic integer typedefs and limits, preferably from inttypes.h, otherwise + * through automatic detection. + */ +#if defined(DUK_F_HAVE_INTTYPES) +/* C99 or compatible */ + +#define DUK_F_HAVE_64BIT +#include + +typedef uint8_t duk_uint8_t; +typedef int8_t duk_int8_t; +typedef uint16_t duk_uint16_t; +typedef int16_t duk_int16_t; +typedef uint32_t duk_uint32_t; +typedef int32_t duk_int32_t; +typedef uint64_t duk_uint64_t; +typedef int64_t duk_int64_t; +typedef uint_least8_t duk_uint_least8_t; +typedef int_least8_t duk_int_least8_t; +typedef uint_least16_t duk_uint_least16_t; +typedef int_least16_t duk_int_least16_t; +typedef uint_least32_t duk_uint_least32_t; +typedef int_least32_t duk_int_least32_t; +typedef uint_least64_t duk_uint_least64_t; +typedef int_least64_t duk_int_least64_t; +typedef uint_fast8_t duk_uint_fast8_t; +typedef int_fast8_t duk_int_fast8_t; +typedef uint_fast16_t duk_uint_fast16_t; +typedef int_fast16_t duk_int_fast16_t; +typedef uint_fast32_t duk_uint_fast32_t; +typedef int_fast32_t duk_int_fast32_t; +typedef uint_fast64_t duk_uint_fast64_t; +typedef int_fast64_t duk_int_fast64_t; +typedef uintptr_t duk_uintptr_t; +typedef intptr_t duk_intptr_t; +typedef uintmax_t duk_uintmax_t; +typedef intmax_t duk_intmax_t; + +#define DUK_UINT8_MIN 0 +#define DUK_UINT8_MAX UINT8_MAX +#define DUK_INT8_MIN INT8_MIN +#define DUK_INT8_MAX INT8_MAX +#define DUK_UINT_LEAST8_MIN 0 +#define DUK_UINT_LEAST8_MAX UINT_LEAST8_MAX +#define DUK_INT_LEAST8_MIN INT_LEAST8_MIN +#define DUK_INT_LEAST8_MAX INT_LEAST8_MAX +#define DUK_UINT_FAST8_MIN 0 +#define DUK_UINT_FAST8_MAX UINT_FAST8_MAX +#define DUK_INT_FAST8_MIN INT_FAST8_MIN +#define DUK_INT_FAST8_MAX INT_FAST8_MAX +#define DUK_UINT16_MIN 0 +#define DUK_UINT16_MAX UINT16_MAX +#define DUK_INT16_MIN INT16_MIN +#define DUK_INT16_MAX INT16_MAX +#define DUK_UINT_LEAST16_MIN 0 +#define DUK_UINT_LEAST16_MAX UINT_LEAST16_MAX +#define DUK_INT_LEAST16_MIN INT_LEAST16_MIN +#define DUK_INT_LEAST16_MAX INT_LEAST16_MAX +#define DUK_UINT_FAST16_MIN 0 +#define DUK_UINT_FAST16_MAX UINT_FAST16_MAX +#define DUK_INT_FAST16_MIN INT_FAST16_MIN +#define DUK_INT_FAST16_MAX INT_FAST16_MAX +#define DUK_UINT32_MIN 0 +#define DUK_UINT32_MAX UINT32_MAX +#define DUK_INT32_MIN INT32_MIN +#define DUK_INT32_MAX INT32_MAX +#define DUK_UINT_LEAST32_MIN 0 +#define DUK_UINT_LEAST32_MAX UINT_LEAST32_MAX +#define DUK_INT_LEAST32_MIN INT_LEAST32_MIN +#define DUK_INT_LEAST32_MAX INT_LEAST32_MAX +#define DUK_UINT_FAST32_MIN 0 +#define DUK_UINT_FAST32_MAX UINT_FAST32_MAX +#define DUK_INT_FAST32_MIN INT_FAST32_MIN +#define DUK_INT_FAST32_MAX INT_FAST32_MAX +#define DUK_UINT64_MIN 0 +#define DUK_UINT64_MAX UINT64_MAX +#define DUK_INT64_MIN INT64_MIN +#define DUK_INT64_MAX INT64_MAX +#define DUK_UINT_LEAST64_MIN 0 +#define DUK_UINT_LEAST64_MAX UINT_LEAST64_MAX +#define DUK_INT_LEAST64_MIN INT_LEAST64_MIN +#define DUK_INT_LEAST64_MAX INT_LEAST64_MAX +#define DUK_UINT_FAST64_MIN 0 +#define DUK_UINT_FAST64_MAX UINT_FAST64_MAX +#define DUK_INT_FAST64_MIN INT_FAST64_MIN +#define DUK_INT_FAST64_MAX INT_FAST64_MAX + +#define DUK_UINTPTR_MIN 0 +#define DUK_UINTPTR_MAX UINTPTR_MAX +#define DUK_INTPTR_MIN INTPTR_MIN +#define DUK_INTPTR_MAX INTPTR_MAX + +#define DUK_UINTMAX_MIN 0 +#define DUK_UINTMAX_MAX UINTMAX_MAX +#define DUK_INTMAX_MIN INTMAX_MIN +#define DUK_INTMAX_MAX INTMAX_MAX + +#define DUK_SIZE_MIN 0 +#define DUK_SIZE_MAX SIZE_MAX +#undef DUK_SIZE_MAX_COMPUTED + +#else /* C99 types */ + +/* When C99 types are not available, we use heuristic detection to get + * the basic 8, 16, 32, and (possibly) 64 bit types. The fast/least + * types are then assumed to be exactly the same for now: these could + * be improved per platform but C99 types are very often now available. + * 64-bit types are not available on all platforms; this is OK at least + * on 32-bit platforms. + * + * This detection code is necessarily a bit hacky and can provide typedefs + * and defines that won't work correctly on some exotic platform. + */ + +#if (defined(CHAR_BIT) && (CHAR_BIT == 8)) || \ + (defined(UCHAR_MAX) && (UCHAR_MAX == 255)) +typedef unsigned char duk_uint8_t; +typedef signed char duk_int8_t; +#else +#error cannot detect 8-bit type +#endif + +#if defined(USHRT_MAX) && (USHRT_MAX == 65535UL) +typedef unsigned short duk_uint16_t; +typedef signed short duk_int16_t; +#elif defined(UINT_MAX) && (UINT_MAX == 65535UL) +/* On some platforms int is 16-bit but long is 32-bit (e.g. PureC) */ +typedef unsigned int duk_uint16_t; +typedef signed int duk_int16_t; +#else +#error cannot detect 16-bit type +#endif + +#if defined(UINT_MAX) && (UINT_MAX == 4294967295UL) +typedef unsigned int duk_uint32_t; +typedef signed int duk_int32_t; +#elif defined(ULONG_MAX) && (ULONG_MAX == 4294967295UL) +/* On some platforms int is 16-bit but long is 32-bit (e.g. PureC) */ +typedef unsigned long duk_uint32_t; +typedef signed long duk_int32_t; +#else +#error cannot detect 32-bit type +#endif + +/* 64-bit type detection is a bit tricky. + * + * ULLONG_MAX is a standard define. __LONG_LONG_MAX__ and __ULONG_LONG_MAX__ + * are used by at least GCC (even if system headers don't provide ULLONG_MAX). + * Some GCC variants may provide __LONG_LONG_MAX__ but not __ULONG_LONG_MAX__. + * + * ULL / LL constants are rejected / warned about by some compilers, even if + * the compiler has a 64-bit type and the compiler/system headers provide an + * unsupported constant (ULL/LL)! Try to avoid using ULL / LL constants. + * As a side effect we can only check that e.g. ULONG_MAX is larger than 32 + * bits but can't be sure it is exactly 64 bits. Self tests will catch such + * cases. + */ +#undef DUK_F_HAVE_64BIT +#if !defined(DUK_F_HAVE_64BIT) && defined(ULONG_MAX) +#if (ULONG_MAX > 4294967295UL) +#define DUK_F_HAVE_64BIT +typedef unsigned long duk_uint64_t; +typedef signed long duk_int64_t; +#endif +#endif +#if !defined(DUK_F_HAVE_64BIT) && defined(ULLONG_MAX) +#if (ULLONG_MAX > 4294967295UL) +#define DUK_F_HAVE_64BIT +typedef unsigned long long duk_uint64_t; +typedef signed long long duk_int64_t; +#endif +#endif +#if !defined(DUK_F_HAVE_64BIT) && defined(__ULONG_LONG_MAX__) +#if (__ULONG_LONG_MAX__ > 4294967295UL) +#define DUK_F_HAVE_64BIT +typedef unsigned long long duk_uint64_t; +typedef signed long long duk_int64_t; +#endif +#endif +#if !defined(DUK_F_HAVE_64BIT) && defined(__LONG_LONG_MAX__) +#if (__LONG_LONG_MAX__ > 2147483647L) +#define DUK_F_HAVE_64BIT +typedef unsigned long long duk_uint64_t; +typedef signed long long duk_int64_t; +#endif +#endif +#if !defined(DUK_F_HAVE_64BIT) && \ + (defined(DUK_F_MINGW) || defined(DUK_F_MSVC)) +/* Both MinGW and MSVC have a 64-bit type. */ +#define DUK_F_HAVE_64BIT +typedef unsigned long duk_uint64_t; +typedef signed long duk_int64_t; +#endif +#if !defined(DUK_F_HAVE_64BIT) +/* cannot detect 64-bit type, not always needed so don't error */ +#endif + +typedef duk_uint8_t duk_uint_least8_t; +typedef duk_int8_t duk_int_least8_t; +typedef duk_uint16_t duk_uint_least16_t; +typedef duk_int16_t duk_int_least16_t; +typedef duk_uint32_t duk_uint_least32_t; +typedef duk_int32_t duk_int_least32_t; +typedef duk_uint8_t duk_uint_fast8_t; +typedef duk_int8_t duk_int_fast8_t; +typedef duk_uint16_t duk_uint_fast16_t; +typedef duk_int16_t duk_int_fast16_t; +typedef duk_uint32_t duk_uint_fast32_t; +typedef duk_int32_t duk_int_fast32_t; +#if defined(DUK_F_HAVE_64BIT) +typedef duk_uint64_t duk_uint_least64_t; +typedef duk_int64_t duk_int_least64_t; +typedef duk_uint64_t duk_uint_fast64_t; +typedef duk_int64_t duk_int_fast64_t; +#endif +#if defined(DUK_F_HAVE_64BIT) +typedef duk_uint64_t duk_uintmax_t; +typedef duk_int64_t duk_intmax_t; +#else +typedef duk_uint32_t duk_uintmax_t; +typedef duk_int32_t duk_intmax_t; +#endif + +/* Note: the funny looking computations for signed minimum 16-bit, 32-bit, and + * 64-bit values are intentional as the obvious forms (e.g. -0x80000000L) are + * -not- portable. See code-issues.txt for a detailed discussion. + */ +#define DUK_UINT8_MIN 0UL +#define DUK_UINT8_MAX 0xffUL +#define DUK_INT8_MIN (-0x80L) +#define DUK_INT8_MAX 0x7fL +#define DUK_UINT_LEAST8_MIN 0UL +#define DUK_UINT_LEAST8_MAX 0xffUL +#define DUK_INT_LEAST8_MIN (-0x80L) +#define DUK_INT_LEAST8_MAX 0x7fL +#define DUK_UINT_FAST8_MIN 0UL +#define DUK_UINT_FAST8_MAX 0xffUL +#define DUK_INT_FAST8_MIN (-0x80L) +#define DUK_INT_FAST8_MAX 0x7fL +#define DUK_UINT16_MIN 0UL +#define DUK_UINT16_MAX 0xffffUL +#define DUK_INT16_MIN (-0x7fffL - 1L) +#define DUK_INT16_MAX 0x7fffL +#define DUK_UINT_LEAST16_MIN 0UL +#define DUK_UINT_LEAST16_MAX 0xffffUL +#define DUK_INT_LEAST16_MIN (-0x7fffL - 1L) +#define DUK_INT_LEAST16_MAX 0x7fffL +#define DUK_UINT_FAST16_MIN 0UL +#define DUK_UINT_FAST16_MAX 0xffffUL +#define DUK_INT_FAST16_MIN (-0x7fffL - 1L) +#define DUK_INT_FAST16_MAX 0x7fffL +#define DUK_UINT32_MIN 0UL +#define DUK_UINT32_MAX 0xffffffffUL +#define DUK_INT32_MIN (-0x7fffffffL - 1L) +#define DUK_INT32_MAX 0x7fffffffL +#define DUK_UINT_LEAST32_MIN 0UL +#define DUK_UINT_LEAST32_MAX 0xffffffffUL +#define DUK_INT_LEAST32_MIN (-0x7fffffffL - 1L) +#define DUK_INT_LEAST32_MAX 0x7fffffffL +#define DUK_UINT_FAST32_MIN 0UL +#define DUK_UINT_FAST32_MAX 0xffffffffUL +#define DUK_INT_FAST32_MIN (-0x7fffffffL - 1L) +#define DUK_INT_FAST32_MAX 0x7fffffffL + +/* 64-bit constants. Since LL / ULL constants are not always available, + * use computed values. These values can't be used in preprocessor + * comparisons; flag them as such. + */ +#if defined(DUK_F_HAVE_64BIT) +#define DUK_UINT64_MIN ((duk_uint64_t) 0) +#define DUK_UINT64_MAX ((duk_uint64_t) -1) +#define DUK_INT64_MIN ((duk_int64_t) (~(DUK_UINT64_MAX >> 1))) +#define DUK_INT64_MAX ((duk_int64_t) (DUK_UINT64_MAX >> 1)) +#define DUK_UINT_LEAST64_MIN DUK_UINT64_MIN +#define DUK_UINT_LEAST64_MAX DUK_UINT64_MAX +#define DUK_INT_LEAST64_MIN DUK_INT64_MIN +#define DUK_INT_LEAST64_MAX DUK_INT64_MAX +#define DUK_UINT_FAST64_MIN DUK_UINT64_MIN +#define DUK_UINT_FAST64_MAX DUK_UINT64_MAX +#define DUK_INT_FAST64_MIN DUK_INT64_MIN +#define DUK_INT_FAST64_MAX DUK_INT64_MAX +#define DUK_UINT64_MIN_COMPUTED +#define DUK_UINT64_MAX_COMPUTED +#define DUK_INT64_MIN_COMPUTED +#define DUK_INT64_MAX_COMPUTED +#define DUK_UINT_LEAST64_MIN_COMPUTED +#define DUK_UINT_LEAST64_MAX_COMPUTED +#define DUK_INT_LEAST64_MIN_COMPUTED +#define DUK_INT_LEAST64_MAX_COMPUTED +#define DUK_UINT_FAST64_MIN_COMPUTED +#define DUK_UINT_FAST64_MAX_COMPUTED +#define DUK_INT_FAST64_MIN_COMPUTED +#define DUK_INT_FAST64_MAX_COMPUTED +#endif + +#if defined(DUK_F_HAVE_64BIT) +#define DUK_UINTMAX_MIN DUK_UINT64_MIN +#define DUK_UINTMAX_MAX DUK_UINT64_MAX +#define DUK_INTMAX_MIN DUK_INT64_MIN +#define DUK_INTMAX_MAX DUK_INT64_MAX +#define DUK_UINTMAX_MIN_COMPUTED +#define DUK_UINTMAX_MAX_COMPUTED +#define DUK_INTMAX_MIN_COMPUTED +#define DUK_INTMAX_MAX_COMPUTED +#else +#define DUK_UINTMAX_MIN 0UL +#define DUK_UINTMAX_MAX 0xffffffffUL +#define DUK_INTMAX_MIN (-0x7fffffffL - 1L) +#define DUK_INTMAX_MAX 0x7fffffffL +#endif + +/* This detection is not very reliable. */ +#if defined(DUK_F_32BIT_PTRS) +typedef duk_int32_t duk_intptr_t; +typedef duk_uint32_t duk_uintptr_t; +#define DUK_UINTPTR_MIN DUK_UINT32_MIN +#define DUK_UINTPTR_MAX DUK_UINT32_MAX +#define DUK_INTPTR_MIN DUK_INT32_MIN +#define DUK_INTPTR_MAX DUK_INT32_MAX +#elif defined(DUK_F_64BIT_PTRS) && defined(DUK_F_HAVE_64BIT) +typedef duk_int64_t duk_intptr_t; +typedef duk_uint64_t duk_uintptr_t; +#define DUK_UINTPTR_MIN DUK_UINT64_MIN +#define DUK_UINTPTR_MAX DUK_UINT64_MAX +#define DUK_INTPTR_MIN DUK_INT64_MIN +#define DUK_INTPTR_MAX DUK_INT64_MAX +#define DUK_UINTPTR_MIN_COMPUTED +#define DUK_UINTPTR_MAX_COMPUTED +#define DUK_INTPTR_MIN_COMPUTED +#define DUK_INTPTR_MAX_COMPUTED +#else +#error cannot determine intptr type +#endif + +/* SIZE_MAX may be missing so use an approximate value for it. */ +#undef DUK_SIZE_MAX_COMPUTED +#if !defined(SIZE_MAX) +#define DUK_SIZE_MAX_COMPUTED +#define SIZE_MAX ((size_t) (-1)) +#endif +#define DUK_SIZE_MIN 0 +#define DUK_SIZE_MAX SIZE_MAX + +#endif /* C99 types */ + +/* A few types are assumed to always exist. */ +typedef size_t duk_size_t; +typedef ptrdiff_t duk_ptrdiff_t; + +/* The best type for an "all around int" in Duktape internals is "at least + * 32 bit signed integer" which is most convenient. Same for unsigned type. + * Prefer 'int' when large enough, as it is almost always a convenient type. + */ +#if defined(UINT_MAX) && (UINT_MAX >= 0xffffffffUL) +typedef int duk_int_t; +typedef unsigned int duk_uint_t; +#define DUK_INT_MIN INT_MIN +#define DUK_INT_MAX INT_MAX +#define DUK_UINT_MIN 0 +#define DUK_UINT_MAX UINT_MAX +#else +typedef duk_int_fast32_t duk_int_t; +typedef duk_uint_fast32_t duk_uint_t; +#define DUK_INT_MIN DUK_INT_FAST32_MIN +#define DUK_INT_MAX DUK_INT_FAST32_MAX +#define DUK_UINT_MIN DUK_UINT_FAST32_MIN +#define DUK_UINT_MAX DUK_UINT_FAST32_MAX +#endif + +/* Same as 'duk_int_t' but guaranteed to be a 'fast' variant if this + * distinction matters for the CPU. These types are used mainly in the + * executor where it might really matter. + */ +typedef duk_int_fast32_t duk_int_fast_t; +typedef duk_uint_fast32_t duk_uint_fast_t; +#define DUK_INT_FAST_MIN DUK_INT_FAST32_MIN +#define DUK_INT_FAST_MAX DUK_INT_FAST32_MAX +#define DUK_UINT_FAST_MIN DUK_UINT_FAST32_MIN +#define DUK_UINT_FAST_MAX DUK_UINT_FAST32_MAX + +/* Small integers (16 bits or more) can fall back to the 'int' type, but + * have a typedef so they are marked "small" explicitly. + */ +typedef int duk_small_int_t; +typedef unsigned int duk_small_uint_t; +#define DUK_SMALL_INT_MIN INT_MIN +#define DUK_SMALL_INT_MAX INT_MAX +#define DUK_SMALL_UINT_MIN 0 +#define DUK_SMALL_UINT_MAX UINT_MAX + +/* Fast variants of small integers, again for really fast paths like the + * executor. + */ +typedef duk_int_fast16_t duk_small_int_fast_t; +typedef duk_uint_fast16_t duk_small_uint_fast_t; +#define DUK_SMALL_INT_FAST_MIN DUK_INT_FAST16_MIN +#define DUK_SMALL_INT_FAST_MAX DUK_INT_FAST16_MAX +#define DUK_SMALL_UINT_FAST_MIN DUK_UINT_FAST16_MIN +#define DUK_SMALL_UINT_FAST_MAX DUK_UINT_FAST16_MAX + +/* Boolean values are represented with the platform 'int'. */ +typedef duk_small_int_t duk_bool_t; +#define DUK_BOOL_MIN DUK_SMALL_INT_MIN +#define DUK_BOOL_MAX DUK_SMALL_INT_MAX + +/* Index values must have at least 32-bit signed range. */ +typedef duk_int_t duk_idx_t; +#define DUK_IDX_MIN DUK_INT_MIN +#define DUK_IDX_MAX DUK_INT_MAX + +/* Unsigned index variant. */ +typedef duk_uint_t duk_uidx_t; +#define DUK_UIDX_MIN DUK_UINT_MIN +#define DUK_UIDX_MAX DUK_UINT_MAX + +/* Array index values, could be exact 32 bits. + * Currently no need for signed duk_arridx_t. + */ +typedef duk_uint_t duk_uarridx_t; +#define DUK_UARRIDX_MIN DUK_UINT_MIN +#define DUK_UARRIDX_MAX DUK_UINT_MAX + +/* Duktape/C function return value, platform int is enough for now to + * represent 0, 1, or negative error code. Must be compatible with + * assigning truth values (e.g. duk_ret_t rc = (foo == bar);). + */ +typedef duk_small_int_t duk_ret_t; +#define DUK_RET_MIN DUK_SMALL_INT_MIN +#define DUK_RET_MAX DUK_SMALL_INT_MAX + +/* Error codes are represented with platform int. High bits are used + * for flags and such, so 32 bits are needed. + */ +typedef duk_int_t duk_errcode_t; +#define DUK_ERRCODE_MIN DUK_INT_MIN +#define DUK_ERRCODE_MAX DUK_INT_MAX + +/* Codepoint type. Must be 32 bits or more because it is used also for + * internal codepoints. The type is signed because negative codepoints + * are used as internal markers (e.g. to mark EOF or missing argument). + * (X)UTF-8/CESU-8 encode/decode take and return an unsigned variant to + * ensure duk_uint32_t casts back and forth nicely. Almost everything + * else uses the signed one. + */ +typedef duk_int_t duk_codepoint_t; +typedef duk_uint_t duk_ucodepoint_t; +#define DUK_CODEPOINT_MIN DUK_INT_MIN +#define DUK_CODEPOINT_MAX DUK_INT_MAX +#define DUK_UCODEPOINT_MIN DUK_UINT_MIN +#define DUK_UCODEPOINT_MAX DUK_UINT_MAX + +/* IEEE float/double typedef. */ +typedef float duk_float_t; +typedef double duk_double_t; + +/* We're generally assuming that we're working on a platform with a 32-bit + * address space. If DUK_SIZE_MAX is a typecast value (which is necessary + * if SIZE_MAX is missing), the check must be avoided because the + * preprocessor can't do a comparison. + */ +#if !defined(DUK_SIZE_MAX) +#error DUK_SIZE_MAX is undefined, probably missing SIZE_MAX +#elif !defined(DUK_SIZE_MAX_COMPUTED) +#if DUK_SIZE_MAX < 0xffffffffUL +/* On some systems SIZE_MAX can be smaller than max unsigned 32-bit value + * which seems incorrect if size_t is (at least) an unsigned 32-bit type. + * However, it doesn't seem useful to error out compilation if this is the + * case. + */ +#endif +#endif + +/* Type for public API calls. */ +typedef struct duk_hthread duk_context; + +/* Check whether we should use 64-bit integers or not. + * + * Quite incomplete now. Use 64-bit types if detected (C99 or other detection) + * unless they are known to be unreliable. For instance, 64-bit types are + * available on VBCC but seem to misbehave. + */ +#if defined(DUK_F_HAVE_64BIT) && !defined(DUK_F_VBCC) +#define DUK_USE_64BIT_OPS +#else +#undef DUK_USE_64BIT_OPS +#endif + +/* + * Fill-ins for platform, architecture, and compiler + */ + +#if !defined(DUK_SETJMP) +#define DUK_USE_SETJMP +#define DUK_SETJMP(jb) setjmp((jb)) +#define DUK_LONGJMP(jb) longjmp((jb), 1) +#endif + +typedef FILE duk_file; +#if !defined(DUK_STDIN) +#define DUK_STDIN stdin +#endif +#if !defined(DUK_STDOUT) +#define DUK_STDOUT stdout +#endif +#if !defined(DUK_STDERR) +#define DUK_STDERR stderr +#endif + +/* Special naming to avoid conflict with e.g. DUK_FREE() in duk_heap.h + * (which is unfortunately named). May sometimes need replacement, e.g. + * some compilers don't handle zero length or NULL correctly in realloc(). + */ +#if !defined(DUK_ANSI_MALLOC) +#define DUK_ANSI_MALLOC malloc +#endif +#if !defined(DUK_ANSI_REALLOC) +#define DUK_ANSI_REALLOC realloc +#endif +#if !defined(DUK_ANSI_CALLOC) +#define DUK_ANSI_CALLOC calloc +#endif +#if !defined(DUK_ANSI_FREE) +#define DUK_ANSI_FREE free +#endif + +/* ANSI C (various versions) and some implementations require that the + * pointer arguments to memset(), memcpy(), and memmove() be valid values + * even when byte size is 0 (even a NULL pointer is considered invalid in + * this context). Zero-size operations as such are allowed, as long as their + * pointer arguments point to a valid memory area. The DUK_MEMSET(), + * DUK_MEMCPY(), and DUK_MEMMOVE() macros require this same behavior, i.e.: + * (1) pointers must be valid and non-NULL, (2) zero size must otherwise be + * allowed. If these are not fulfilled, a macro wrapper is needed. + * + * http://stackoverflow.com/questions/5243012/is-it-guaranteed-to-be-safe-to-perform-memcpy0-0-0 + * http://lists.cs.uiuc.edu/pipermail/llvmdev/2007-October/011065.html + * + * Not sure what's the required behavior when a pointer points just past the + * end of a buffer, which often happens in practice (e.g. zero size memmoves). + * For example, if allocation size is 3, the following pointer would not + * technically point to a valid memory byte: + * + * <-- alloc --> + * | 0 | 1 | 2 | ..... + * ^-- p=3, points after last valid byte (2) + */ +#if !defined(DUK_MEMCPY) +#if defined(DUK_F_UCLIBC) +/* Old uclibcs have a broken memcpy so use memmove instead (this is overly wide + * now on purpose): http://lists.uclibc.org/pipermail/uclibc-cvs/2008-October/025511.html + */ +#define DUK_MEMCPY memmove +#else +#define DUK_MEMCPY memcpy +#endif +#endif +#if !defined(DUK_MEMMOVE) +#define DUK_MEMMOVE memmove +#endif +#if !defined(DUK_MEMCMP) +#define DUK_MEMCMP memcmp +#endif +#if !defined(DUK_MEMSET) +#define DUK_MEMSET memset +#endif +#if !defined(DUK_STRLEN) +#define DUK_STRLEN strlen +#endif +#if !defined(DUK_STRCMP) +#define DUK_STRCMP strcmp +#endif +#if !defined(DUK_STRNCMP) +#define DUK_STRNCMP strncmp +#endif +#if !defined(DUK_PRINTF) +#define DUK_PRINTF printf +#endif +#if !defined(DUK_FPRINTF) +#define DUK_FPRINTF fprintf +#endif +#if !defined(DUK_SPRINTF) +#define DUK_SPRINTF sprintf +#endif +#if !defined(DUK_SNPRINTF) +/* snprintf() is technically not part of C89 but usually available. */ +#define DUK_SNPRINTF snprintf +#endif +#if !defined(DUK_VSPRINTF) +#define DUK_VSPRINTF vsprintf +#endif +#if !defined(DUK_VSNPRINTF) +/* vsnprintf() is technically not part of C89 but usually available. */ +#define DUK_VSNPRINTF vsnprintf +#endif +#if !defined(DUK_SSCANF) +#define DUK_SSCANF sscanf +#endif +#if !defined(DUK_VSSCANF) +#define DUK_VSSCANF vsscanf +#endif +#if !defined(DUK_FOPEN) +#define DUK_FOPEN fopen +#endif +#if !defined(DUK_FCLOSE) +#define DUK_FCLOSE fclose +#endif +#if !defined(DUK_FREAD) +#define DUK_FREAD fread +#endif +#if !defined(DUK_FWRITE) +#define DUK_FWRITE fwrite +#endif +#if !defined(DUK_FSEEK) +#define DUK_FSEEK fseek +#endif +#if !defined(DUK_FTELL) +#define DUK_FTELL ftell +#endif +#if !defined(DUK_FFLUSH) +#define DUK_FFLUSH fflush +#endif +#if !defined(DUK_FPUTC) +#define DUK_FPUTC fputc +#endif +#if !defined(DUK_MEMZERO) +#define DUK_MEMZERO(p,n) DUK_MEMSET((p), 0, (n)) +#endif +#if !defined(DUK_ABORT) +#define DUK_ABORT abort +#endif +#if !defined(DUK_EXIT) +#define DUK_EXIT exit +#endif + +#if !defined(DUK_DOUBLE_2TO32) +#define DUK_DOUBLE_2TO32 4294967296.0 +#endif +#if !defined(DUK_DOUBLE_2TO31) +#define DUK_DOUBLE_2TO31 2147483648.0 +#endif + +#if !defined(DUK_DOUBLE_INFINITY) +#undef DUK_USE_COMPUTED_INFINITY +#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION < 40600) +/* GCC older than 4.6: avoid overflow warnings related to using INFINITY */ +#define DUK_DOUBLE_INFINITY (__builtin_inf()) +#elif defined(INFINITY) +#define DUK_DOUBLE_INFINITY ((double) INFINITY) +#elif !defined(DUK_F_VBCC) && !defined(DUK_F_MSVC) && !defined(DUK_F_BCC) +#define DUK_DOUBLE_INFINITY (1.0 / 0.0) +#else +/* In VBCC (1.0 / 0.0) results in a warning and 0.0 instead of infinity. + * Use a computed infinity (initialized when a heap is created at the + * latest). + */ +#define DUK_USE_COMPUTED_INFINITY +#define DUK_DOUBLE_INFINITY duk_computed_infinity +#endif +#endif + +#if !defined(DUK_DOUBLE_NAN) +#undef DUK_USE_COMPUTED_NAN +#if defined(NAN) +#define DUK_DOUBLE_NAN NAN +#elif !defined(DUK_F_VBCC) && !defined(DUK_F_MSVC) && !defined(DUK_F_BCC) +#define DUK_DOUBLE_NAN (0.0 / 0.0) +#else +/* In VBCC (0.0 / 0.0) results in a warning and 0.0 instead of NaN. + * In MSVC (VS2010 Express) (0.0 / 0.0) results in a compile error. + * Use a computed NaN (initialized when a heap is created at the + * latest). + */ +#define DUK_USE_COMPUTED_NAN +#define DUK_DOUBLE_NAN duk_computed_nan +#endif +#endif + +/* Many platforms are missing fpclassify() and friends, so use replacements + * if necessary. The replacement constants (FP_NAN etc) can be anything but + * match Linux constants now. + */ +#undef DUK_USE_REPL_FPCLASSIFY +#undef DUK_USE_REPL_SIGNBIT +#undef DUK_USE_REPL_ISFINITE +#undef DUK_USE_REPL_ISNAN +#undef DUK_USE_REPL_ISINF + +/* Complex condition broken into separate parts. */ +#undef DUK_F_USE_REPL_ALL +#if !(defined(FP_NAN) && defined(FP_INFINITE) && defined(FP_ZERO) && \ + defined(FP_SUBNORMAL) && defined(FP_NORMAL)) +/* Missing some obvious constants. */ +#define DUK_F_USE_REPL_ALL +#elif defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC) +/* VBCC is missing the built-ins even in C99 mode (perhaps a header issue) */ +#define DUK_F_USE_REPL_ALL +#elif defined(DUK_F_FREEBSD) && defined(DUK_F_CLANG) +/* Placeholder fix for (detection is wider than necessary): + * http://llvm.org/bugs/show_bug.cgi?id=17788 + */ +#define DUK_F_USE_REPL_ALL +#elif defined(DUK_F_UCLIBC) +/* At least some uclibc versions have broken floating point math. For + * example, fpclassify() can incorrectly classify certain NaN formats. + * To be safe, use replacements. + */ +#define DUK_F_USE_REPL_ALL +#endif + +#if defined(DUK_F_USE_REPL_ALL) +#define DUK_USE_REPL_FPCLASSIFY +#define DUK_USE_REPL_SIGNBIT +#define DUK_USE_REPL_ISFINITE +#define DUK_USE_REPL_ISNAN +#define DUK_USE_REPL_ISINF +#define DUK_FPCLASSIFY duk_repl_fpclassify +#define DUK_SIGNBIT duk_repl_signbit +#define DUK_ISFINITE duk_repl_isfinite +#define DUK_ISNAN duk_repl_isnan +#define DUK_ISINF duk_repl_isinf +#define DUK_FP_NAN 0 +#define DUK_FP_INFINITE 1 +#define DUK_FP_ZERO 2 +#define DUK_FP_SUBNORMAL 3 +#define DUK_FP_NORMAL 4 +#else +#define DUK_FPCLASSIFY fpclassify +#define DUK_SIGNBIT signbit +#define DUK_ISFINITE isfinite +#define DUK_ISNAN isnan +#define DUK_ISINF isinf +#define DUK_FP_NAN FP_NAN +#define DUK_FP_INFINITE FP_INFINITE +#define DUK_FP_ZERO FP_ZERO +#define DUK_FP_SUBNORMAL FP_SUBNORMAL +#define DUK_FP_NORMAL FP_NORMAL +#endif + +#if defined(DUK_F_USE_REPL_ALL) +#undef DUK_F_USE_REPL_ALL +#endif + +/* Some math functions are C99 only. This is also an issue with some + * embedded environments using uclibc where uclibc has been configured + * not to provide some functions. For now, use replacements whenever + * using uclibc. + */ +#undef DUK_USE_MATH_FMIN +#undef DUK_USE_MATH_FMAX +#undef DUK_USE_MATH_ROUND +#if defined(DUK_F_UCLIBC) +/* uclibc may be missing these */ +#elif defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC) +/* vbcc + AmigaOS may be missing these */ +#elif !defined(DUK_F_C99) && !defined(DUK_F_CPP11) +/* build is not C99 or C++11, play it safe */ +#else +/* C99 or C++11, no known issues */ +#define DUK_USE_MATH_FMIN +#define DUK_USE_MATH_FMAX +#define DUK_USE_MATH_ROUND +#endif + +/* These functions don't currently need replacement but are wrapped for + * completeness. Because these are used as function pointers, they need + * to be defined as concrete C functions (not macros). + */ +#if !defined(DUK_FABS) +#define DUK_FABS fabs +#endif +#if !defined(DUK_FMIN) +#define DUK_FMIN fmin +#endif +#if !defined(DUK_FMAX) +#define DUK_FMAX fmax +#endif +#if !defined(DUK_FLOOR) +#define DUK_FLOOR floor +#endif +#if !defined(DUK_CEIL) +#define DUK_CEIL ceil +#endif +#if !defined(DUK_FMOD) +#define DUK_FMOD fmod +#endif +#if !defined(DUK_POW) +#define DUK_POW pow +#endif +#if !defined(DUK_ACOS) +#define DUK_ACOS acos +#endif +#if !defined(DUK_ASIN) +#define DUK_ASIN asin +#endif +#if !defined(DUK_ATAN) +#define DUK_ATAN atan +#endif +#if !defined(DUK_ATAN2) +#define DUK_ATAN2 atan2 +#endif +#if !defined(DUK_SIN) +#define DUK_SIN sin +#endif +#if !defined(DUK_COS) +#define DUK_COS cos +#endif +#if !defined(DUK_TAN) +#define DUK_TAN tan +#endif +#if !defined(DUK_EXP) +#define DUK_EXP exp +#endif +#if !defined(DUK_LOG) +#define DUK_LOG log +#endif +#if !defined(DUK_SQRT) +#define DUK_SQRT sqrt +#endif + +/* NetBSD 6.0 x86 (at least) has a few problems with pow() semantics, + * see test-bug-netbsd-math-pow.js. Use NetBSD specific workaround. + * (This might be a wider problem; if so, generalize the define name.) + */ +#undef DUK_USE_POW_NETBSD_WORKAROUND +#if defined(DUK_F_NETBSD) +#define DUK_USE_POW_NETBSD_WORKAROUND +#endif + +/* Rely as little as possible on compiler behavior for NaN comparison, + * signed zero handling, etc. Currently never activated but may be needed + * for broken compilers. + */ +#undef DUK_USE_PARANOID_MATH + +/* There was a curious bug where test-bi-date-canceling.js would fail e.g. + * on 64-bit Ubuntu, gcc-4.8.1, -m32, and no -std=c99. Some date computations + * using doubles would be optimized which then broke some corner case tests. + * The problem goes away by adding 'volatile' to the datetime computations. + * Not sure what the actual triggering conditions are, but using this on + * non-C99 systems solves the known issues and has relatively little cost + * on other platforms. + */ +#undef DUK_USE_PARANOID_DATE_COMPUTATION +#if !defined(DUK_F_C99) +#define DUK_USE_PARANOID_DATE_COMPUTATION +#endif + +/* + * Byte order and double memory layout detection + * + * Endianness detection is a major portability hassle because the macros + * and headers are not standardized. There's even variance across UNIX + * platforms. Even with "standard" headers, details like underscore count + * varies between platforms, e.g. both __BYTE_ORDER and _BYTE_ORDER are used + * (Crossbridge has a single underscore, for instance). + * + * The checks below are structured with this in mind: several approaches are + * used, and at the end we check if any of them worked. This allows generic + * approaches to be tried first, and platform/compiler specific hacks tried + * last. As a last resort, the user can force a specific endianness, as it's + * not likely that automatic detection will work on the most exotic platforms. + * + * Duktape supports little and big endian machines. There's also support + * for a hybrid used by some ARM machines where integers are little endian + * but IEEE double values use a mixed order (12345678 -> 43218765). This + * byte order for doubles is referred to as "mixed endian". + */ + +/* For custom platforms allow user to define byteorder explicitly. + * Since endianness headers are not standardized, this is a useful + * workaround for custom platforms for which endianness detection + * is not directly supported. Perhaps custom hardware is used and + * user cannot submit upstream patches. + */ +#if defined(DUK_OPT_FORCE_BYTEORDER) +#undef DUK_USE_BYTEORDER +#if (DUK_OPT_FORCE_BYTEORDER == 1) +#define DUK_USE_BYTEORDER 1 +#elif (DUK_OPT_FORCE_BYTEORDER == 2) +#define DUK_USE_BYTEORDER 2 +#elif (DUK_OPT_FORCE_BYTEORDER == 3) +#define DUK_USE_BYTEORDER 3 +#else +#error invalid DUK_OPT_FORCE_BYTEORDER value +#endif +#endif /* DUK_OPT_FORCE_BYTEORDER */ + +/* GCC and Clang provide endianness defines as built-in predefines, with + * leading and trailing double underscores (e.g. __BYTE_ORDER__). See + * output of "make gccpredefs" and "make clangpredefs". Clang doesn't + * seem to provide __FLOAT_WORD_ORDER__; assume not mixed endian for clang. + * http://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html + */ +#if !defined(DUK_USE_BYTEORDER) && defined(__BYTE_ORDER__) +#if defined(__ORDER_LITTLE_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) +#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && (__FLOAT_WORD_ORDER__ == __ORDER_LITTLE_ENDIAN__) +#define DUK_USE_BYTEORDER 1 +#elif defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__) +#define DUK_USE_BYTEORDER 2 +#elif !defined(__FLOAT_WORD_ORDER__) +/* Float word order not known, assume not a hybrid. */ +#define DUK_USE_BYTEORDER 1 +#else +/* Byte order is little endian but cannot determine IEEE double word order. */ +#endif /* float word order */ +#elif defined(__ORDER_BIG_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) +#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__) +#define DUK_USE_BYTEORDER 3 +#elif !defined(__FLOAT_WORD_ORDER__) +/* Float word order not known, assume not a hybrid. */ +#define DUK_USE_BYTEORDER 3 +#else +/* Byte order is big endian but cannot determine IEEE double word order. */ +#endif /* float word order */ +#else +/* Cannot determine byte order; __ORDER_PDP_ENDIAN__ is related to 32-bit + * integer ordering and is not relevant. + */ +#endif /* integer byte order */ +#endif /* !defined(DUK_USE_BYTEORDER) && defined(__BYTE_ORDER__) */ + +/* More or less standard endianness predefines provided by header files. + * The ARM hybrid case is detected by assuming that __FLOAT_WORD_ORDER + * will be big endian, see: http://lists.mysql.com/internals/443. + * On some platforms some defines may be present with an empty value which + * causes comparisons to fail: https://github.com/svaarala/duktape/issues/453. + */ +#if !defined(DUK_USE_BYTEORDER) +#if defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && (__BYTE_ORDER == __LITTLE_ENDIAN) || \ + defined(_BYTE_ORDER) && defined(_LITTLE_ENDIAN) && (_BYTE_ORDER == _LITTLE_ENDIAN) || \ + defined(__LITTLE_ENDIAN__) +#if defined(__FLOAT_WORD_ORDER) && defined(__LITTLE_ENDIAN) && (__FLOAT_WORD_ORDER == __LITTLE_ENDIAN) || \ + defined(_FLOAT_WORD_ORDER) && defined(_LITTLE_ENDIAN) && (_FLOAT_WORD_ORDER == _LITTLE_ENDIAN) +#define DUK_USE_BYTEORDER 1 +#elif defined(__FLOAT_WORD_ORDER) && defined(__BIG_ENDIAN) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) || \ + defined(_FLOAT_WORD_ORDER) && defined(_BIG_ENDIAN) && (_FLOAT_WORD_ORDER == _BIG_ENDIAN) +#define DUK_USE_BYTEORDER 2 +#elif !defined(__FLOAT_WORD_ORDER) && !defined(_FLOAT_WORD_ORDER) +/* Float word order not known, assume not a hybrid. */ +#define DUK_USE_BYTEORDER 1 +#else +/* Byte order is little endian but cannot determine IEEE double word order. */ +#endif /* float word order */ +#elif defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && (__BYTE_ORDER == __BIG_ENDIAN) || \ + defined(_BYTE_ORDER) && defined(_BIG_ENDIAN) && (_BYTE_ORDER == _BIG_ENDIAN) || \ + defined(__BIG_ENDIAN__) +#if defined(__FLOAT_WORD_ORDER) && defined(__BIG_ENDIAN) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) || \ + defined(_FLOAT_WORD_ORDER) && defined(_BIG_ENDIAN) && (_FLOAT_WORD_ORDER == _BIG_ENDIAN) +#define DUK_USE_BYTEORDER 3 +#elif !defined(__FLOAT_WORD_ORDER) && !defined(_FLOAT_WORD_ORDER) +/* Float word order not known, assume not a hybrid. */ +#define DUK_USE_BYTEORDER 3 +#else +/* Byte order is big endian but cannot determine IEEE double word order. */ +#endif /* float word order */ +#else +/* Cannot determine byte order. */ +#endif /* integer byte order */ +#endif /* !defined(DUK_USE_BYTEORDER) */ + +/* QNX gcc cross compiler seems to define e.g. __LITTLEENDIAN__ or __BIGENDIAN__: + * $ /opt/qnx650/host/linux/x86/usr/bin/i486-pc-nto-qnx6.5.0-gcc -dM -E - > 24) | \ + ((((duk_uint32_t) (x)) >> 8) & 0xff00UL) | \ + ((((duk_uint32_t) (x)) << 8) & 0xff0000UL) | \ + (((duk_uint32_t) (x)) << 24)) +#endif +#if !defined(DUK_BSWAP16) +#define DUK_BSWAP16(x) \ + ((duk_uint16_t) (x) >> 8) | \ + ((duk_uint16_t) (x) << 8) +#endif + +/* Explicit marker needed; may be 'defined', 'undefined, 'or 'not provided'. */ +#if !defined(DUK_F_VARIADIC_MACROS_PROVIDED) +#undef DUK_USE_VARIADIC_MACROS +#if defined(DUK_F_C99) || defined(DUK_F_CPP11) +#define DUK_USE_VARIADIC_MACROS +#endif +#endif + +#if !(defined(DUK_USE_FLEX_C99) || defined(DUK_USE_FLEX_ZEROSIZE) || defined(DUK_USE_FLEX_ONESIZE)) +#if defined(DUK_F_C99) +#define DUK_USE_FLEX_C99 +#else +#define DUK_USE_FLEX_ZEROSIZE /* Not standard but common enough */ +#endif +#endif + +#if !(defined(DUK_USE_PACK_GCC_ATTR) || defined(DUK_USE_PACK_CLANG_ATTR) || \ + defined(DUK_USE_PACK_MSVC_PRAGMA) || defined(DUK_USE_PACK_DUMMY_MEMBER)) +#define DUK_USE_PACK_DUMMY_MEMBER +#endif + +#if 0 /* not defined by default */ +#undef DUK_USE_GCC_PRAGMAS +#endif + +/* Workaround for GH-323: avoid inlining control when compiling from + * multiple sources, as it causes compiler portability trouble. + */ +#if !defined(DUK_SINGLE_FILE) +#undef DUK_NOINLINE +#undef DUK_INLINE +#undef DUK_ALWAYS_INLINE +#define DUK_NOINLINE /*nop*/ +#define DUK_INLINE /*nop*/ +#define DUK_ALWAYS_INLINE /*nop*/ +#endif + +/* + * Check whether or not a packed duk_tval representation is possible. + * What's basically required is that pointers are 32-bit values + * (sizeof(void *) == 4). Best effort check, not always accurate. + * If guess goes wrong, crashes may result; self tests also verify + * the guess. + */ + +/* Explicit marker needed; may be 'defined', 'undefined, 'or 'not provided'. */ +#if !defined(DUK_F_PACKED_TVAL_PROVIDED) +#undef DUK_F_PACKED_TVAL_POSSIBLE + +/* Strict C99 case: DUK_UINTPTR_MAX (= UINTPTR_MAX) should be very reliable */ +#if !defined(DUK_F_PACKED_TVAL_POSSIBLE) && defined(DUK_UINTPTR_MAX) +#if (DUK_UINTPTR_MAX <= 0xffffffffUL) +#define DUK_F_PACKED_TVAL_POSSIBLE +#endif +#endif + +/* Non-C99 case, still relying on DUK_UINTPTR_MAX, as long as it is not a computed value */ +#if !defined(DUK_F_PACKED_TVAL_POSSIBLE) && defined(DUK_UINTPTR_MAX) && !defined(DUK_UINTPTR_MAX_COMPUTED) +#if (DUK_UINTPTR_MAX <= 0xffffffffUL) +#define DUK_F_PACKED_TVAL_POSSIBLE +#endif +#endif + +/* DUK_SIZE_MAX (= SIZE_MAX) is often reliable */ +#if !defined(DUK_F_PACKED_TVAL_POSSIBLE) && defined(DUK_SIZE_MAX) && !defined(DUK_SIZE_MAX_COMPUTED) +#if (DUK_SIZE_MAX <= 0xffffffffUL) +#define DUK_F_PACKED_TVAL_POSSIBLE +#endif +#endif + +#undef DUK_USE_PACKED_TVAL +#if defined(DUK_F_PACKED_TVAL_POSSIBLE) +#define DUK_USE_PACKED_TVAL +#endif + +#undef DUK_F_PACKED_TVAL_POSSIBLE +#endif /* DUK_F_PACKED_TVAL_PROVIDED */ + +/* Feature option forcing. */ +#if defined(DUK_OPT_NO_PACKED_TVAL) +#undef DUK_USE_PACKED_TVAL +#elif defined(DUK_OPT_PACKED_TVAL) +#undef DUK_USE_PACKED_TVAL +#define DUK_USE_PACKED_TVAL +#endif +/* Object property allocation layout has implications for memory and code + * footprint and generated code size/speed. The best layout also depends + * on whether the platform has alignment requirements or benefits from + * having mostly aligned accesses. + */ +#undef DUK_USE_HOBJECT_LAYOUT_1 +#undef DUK_USE_HOBJECT_LAYOUT_2 +#undef DUK_USE_HOBJECT_LAYOUT_3 +#if (DUK_USE_ALIGN_BY == 1) +/* On platforms without any alignment issues, layout 1 is preferable + * because it compiles to slightly less code and provides direct access + * to property keys. + */ +#define DUK_USE_HOBJECT_LAYOUT_1 +#else +/* On other platforms use layout 2, which requires some padding but + * is a bit more natural than layout 3 in ordering the entries. Layout + * 3 is currently not used. + */ +#define DUK_USE_HOBJECT_LAYOUT_2 +#endif + +/* GCC/clang inaccurate math would break compliance and probably duk_tval, + * so refuse to compile. Relax this if -ffast-math is tested to work. + */ +#if defined(__FAST_MATH__) +#error __FAST_MATH__ defined, refusing to compile +#endif + +/* + * Feature option handling + */ + +#if !defined(DUK_USE_ALIGN_BY) +#if defined(DUK_OPT_FORCE_ALIGN) +#define DUK_USE_ALIGN_BY DUK_OPT_FORCE_ALIGN +#else +#define DUK_USE_ALIGN_BY 8 +#endif +#endif + +#if defined(DUK_OPT_ASSERTIONS) +#define DUK_USE_ASSERTIONS +#elif defined(DUK_OPT_NO_ASSERTIONS) +#undef DUK_USE_ASSERTIONS +#else +#undef DUK_USE_ASSERTIONS +#endif + +#if defined(DUK_OPT_AUGMENT_ERRORS) +#define DUK_USE_AUGMENT_ERROR_CREATE +#elif defined(DUK_OPT_NO_AUGMENT_ERRORS) +#undef DUK_USE_AUGMENT_ERROR_CREATE +#else +#define DUK_USE_AUGMENT_ERROR_CREATE +#endif + +#if defined(DUK_OPT_AUGMENT_ERRORS) +#define DUK_USE_AUGMENT_ERROR_THROW +#elif defined(DUK_OPT_NO_AUGMENT_ERRORS) +#undef DUK_USE_AUGMENT_ERROR_THROW +#else +#define DUK_USE_AUGMENT_ERROR_THROW +#endif + +#if defined(DUK_OPT_BROWSER_LIKE) +#define DUK_USE_BROWSER_LIKE +#elif defined(DUK_OPT_NO_BROWSER_LIKE) +#undef DUK_USE_BROWSER_LIKE +#else +#define DUK_USE_BROWSER_LIKE +#endif + +#if defined(DUK_OPT_BUFFEROBJECT_SUPPORT) +#define DUK_USE_BUFFEROBJECT_SUPPORT +#elif defined(DUK_OPT_NO_BUFFEROBJECT_SUPPORT) +#undef DUK_USE_BUFFEROBJECT_SUPPORT +#else +#define DUK_USE_BUFFEROBJECT_SUPPORT +#endif + +#if defined(DUK_OPT_BUFLEN16) +#define DUK_USE_BUFLEN16 +#elif defined(DUK_OPT_NO_BUFLEN16) +#undef DUK_USE_BUFLEN16 +#else +#undef DUK_USE_BUFLEN16 +#endif + +#if defined(DUK_OPT_BYTECODE_DUMP_SUPPORT) +#define DUK_USE_BYTECODE_DUMP_SUPPORT +#elif defined(DUK_OPT_NO_BYTECODE_DUMP_SUPPORT) +#undef DUK_USE_BYTECODE_DUMP_SUPPORT +#else +#define DUK_USE_BYTECODE_DUMP_SUPPORT +#endif + +#if defined(DUK_OPT_COMMONJS_MODULES) +#define DUK_USE_COMMONJS_MODULES +#elif defined(DUK_OPT_NO_COMMONJS_MODULES) +#undef DUK_USE_COMMONJS_MODULES +#else +#define DUK_USE_COMMONJS_MODULES +#endif + +#if defined(DUK_OPT_CPP_EXCEPTIONS) +#define DUK_USE_CPP_EXCEPTIONS +#elif defined(DUK_OPT_NO_CPP_EXCEPTIONS) +#undef DUK_USE_CPP_EXCEPTIONS +#else +#undef DUK_USE_CPP_EXCEPTIONS +#endif + +#if defined(DUK_OPT_DATAPTR16) +#define DUK_USE_DATAPTR16 +#elif defined(DUK_OPT_NO_DATAPTR16) +#undef DUK_USE_DATAPTR16 +#else +#undef DUK_USE_DATAPTR16 +#endif + +#if defined(DUK_OPT_DATAPTR_DEC16) +#define DUK_USE_DATAPTR_DEC16(udata,ptr) DUK_OPT_DATAPTR_DEC16((udata),(ptr)) +#else +#undef DUK_USE_DATAPTR_DEC16 +#endif + +#if defined(DUK_OPT_DATAPTR_ENC16) +#define DUK_USE_DATAPTR_ENC16(udata,ptr) DUK_OPT_DATAPTR_ENC16((udata),(ptr)) +#else +#undef DUK_USE_DATAPTR_ENC16 +#endif + +#if defined(DUK_OPT_DDDPRINT) +#define DUK_USE_DDDPRINT +#elif defined(DUK_OPT_NO_DDDPRINT) +#undef DUK_USE_DDDPRINT +#else +#undef DUK_USE_DDDPRINT +#endif + +#if defined(DUK_OPT_DDPRINT) +#define DUK_USE_DDPRINT +#elif defined(DUK_OPT_NO_DDPRINT) +#undef DUK_USE_DDPRINT +#else +#undef DUK_USE_DDPRINT +#endif + +#if defined(DUK_OPT_DEBUG) +#define DUK_USE_DEBUG +#elif defined(DUK_OPT_NO_DEBUG) +#undef DUK_USE_DEBUG +#else +#undef DUK_USE_DEBUG +#endif + +#if defined(DUK_OPT_DEBUGGER_DUMPHEAP) +#define DUK_USE_DEBUGGER_DUMPHEAP +#elif defined(DUK_OPT_NO_DEBUGGER_DUMPHEAP) +#undef DUK_USE_DEBUGGER_DUMPHEAP +#else +#undef DUK_USE_DEBUGGER_DUMPHEAP +#endif + +#if defined(DUK_OPT_DEBUGGER_FWD_LOGGING) +#define DUK_USE_DEBUGGER_FWD_LOGGING +#elif defined(DUK_OPT_NO_DEBUGGER_FWD_LOGGING) +#undef DUK_USE_DEBUGGER_FWD_LOGGING +#else +#undef DUK_USE_DEBUGGER_FWD_LOGGING +#endif + +#if defined(DUK_OPT_DEBUGGER_FWD_PRINTALERT) +#define DUK_USE_DEBUGGER_FWD_PRINTALERT +#elif defined(DUK_OPT_NO_DEBUGGER_FWD_PRINTALERT) +#undef DUK_USE_DEBUGGER_FWD_PRINTALERT +#else +#undef DUK_USE_DEBUGGER_FWD_PRINTALERT +#endif + +#if defined(DUK_OPT_DEBUGGER_PAUSE_UNCAUGHT) +#define DUK_USE_DEBUGGER_PAUSE_UNCAUGHT +#elif defined(DUK_OPT_NO_DEBUGGER_PAUSE_UNCAUGHT) +#undef DUK_USE_DEBUGGER_PAUSE_UNCAUGHT +#else +#undef DUK_USE_DEBUGGER_PAUSE_UNCAUGHT +#endif + +#if defined(DUK_OPT_DEBUGGER_SUPPORT) +#define DUK_USE_DEBUGGER_SUPPORT +#elif defined(DUK_OPT_NO_DEBUGGER_SUPPORT) +#undef DUK_USE_DEBUGGER_SUPPORT +#else +#undef DUK_USE_DEBUGGER_SUPPORT +#endif + +#if defined(DUK_OPT_DEBUGGER_THROW_NOTIFY) +#define DUK_USE_DEBUGGER_THROW_NOTIFY +#elif defined(DUK_OPT_NO_DEBUGGER_THROW_NOTIFY) +#undef DUK_USE_DEBUGGER_THROW_NOTIFY +#else +#define DUK_USE_DEBUGGER_THROW_NOTIFY +#endif + +#if defined(DUK_OPT_DEBUGGER_TRANSPORT_TORTURE) +#define DUK_USE_DEBUGGER_TRANSPORT_TORTURE +#elif defined(DUK_OPT_NO_DEBUGGER_TRANSPORT_TORTURE) +#undef DUK_USE_DEBUGGER_TRANSPORT_TORTURE +#else +#undef DUK_USE_DEBUGGER_TRANSPORT_TORTURE +#endif + +#if defined(DUK_OPT_DEBUG_BUFSIZE) +#define DUK_USE_DEBUG_BUFSIZE DUK_OPT_DEBUG_BUFSIZE +#else +#define DUK_USE_DEBUG_BUFSIZE 65536L +#endif + +#if defined(DUK_OPT_REFERENCE_COUNTING) +#define DUK_USE_DOUBLE_LINKED_HEAP +#elif defined(DUK_OPT_NO_REFERENCE_COUNTING) +#undef DUK_USE_DOUBLE_LINKED_HEAP +#else +#define DUK_USE_DOUBLE_LINKED_HEAP +#endif + +#if defined(DUK_OPT_DPRINT) +#define DUK_USE_DPRINT +#elif defined(DUK_OPT_NO_DPRINT) +#undef DUK_USE_DPRINT +#else +#undef DUK_USE_DPRINT +#endif + +#if defined(DUK_OPT_DPRINT_COLORS) +#define DUK_USE_DPRINT_COLORS +#elif defined(DUK_OPT_NO_DPRINT_COLORS) +#undef DUK_USE_DPRINT_COLORS +#else +#undef DUK_USE_DPRINT_COLORS +#endif + +#if defined(DUK_OPT_DPRINT_RDTSC) +#define DUK_USE_DPRINT_RDTSC +#elif defined(DUK_OPT_NO_DPRINT_RDTSC) +#undef DUK_USE_DPRINT_RDTSC +#else +#undef DUK_USE_DPRINT_RDTSC +#endif + +#if defined(DUK_OPT_AUGMENT_ERRORS) +#define DUK_USE_ERRCREATE +#elif defined(DUK_OPT_NO_AUGMENT_ERRORS) +#undef DUK_USE_ERRCREATE +#else +#define DUK_USE_ERRCREATE +#endif + +#if defined(DUK_OPT_AUGMENT_ERRORS) +#define DUK_USE_ERRTHROW +#elif defined(DUK_OPT_NO_AUGMENT_ERRORS) +#undef DUK_USE_ERRTHROW +#else +#define DUK_USE_ERRTHROW +#endif + +#if defined(DUK_OPT_ES6_OBJECT_PROTO_PROPERTY) +#define DUK_USE_ES6_OBJECT_PROTO_PROPERTY +#elif defined(DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY) +#undef DUK_USE_ES6_OBJECT_PROTO_PROPERTY +#else +#define DUK_USE_ES6_OBJECT_PROTO_PROPERTY +#endif + +#if defined(DUK_OPT_ES6_OBJECT_SETPROTOTYPEOF) +#define DUK_USE_ES6_OBJECT_SETPROTOTYPEOF +#elif defined(DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF) +#undef DUK_USE_ES6_OBJECT_SETPROTOTYPEOF +#else +#define DUK_USE_ES6_OBJECT_SETPROTOTYPEOF +#endif + +#if defined(DUK_OPT_ES6_PROXY) +#define DUK_USE_ES6_PROXY +#elif defined(DUK_OPT_NO_ES6_PROXY) +#undef DUK_USE_ES6_PROXY +#else +#define DUK_USE_ES6_PROXY +#endif + +#undef DUK_USE_EXEC_INDIRECT_BOUND_CHECK +#if defined(DUK_OPT_DEBUG) || defined(DUK_OPT_ASSERTIONS) +/* Enabled with debug/assertions just so that any issues can be caught. */ +#define DUK_USE_EXEC_INDIRECT_BOUND_CHECK +#endif + +#undef DUK_USE_EXEC_TIMEOUT_CHECK +#if defined(DUK_OPT_EXEC_TIMEOUT_CHECK) +#define DUK_USE_EXEC_TIMEOUT_CHECK(udata) DUK_OPT_EXEC_TIMEOUT_CHECK((udata)) +#endif + +#undef DUK_USE_EXTSTR_FREE +#if defined(DUK_OPT_EXTERNAL_STRINGS) && defined(DUK_OPT_EXTSTR_FREE) +#define DUK_USE_EXTSTR_FREE(udata,ptr) DUK_OPT_EXTSTR_FREE((udata), (ptr)) +#endif + +#undef DUK_USE_EXTSTR_INTERN_CHECK +#if defined(DUK_OPT_EXTERNAL_STRINGS) && defined(DUK_OPT_EXTSTR_INTERN_CHECK) +#define DUK_USE_EXTSTR_INTERN_CHECK(udata,ptr,len) DUK_OPT_EXTSTR_INTERN_CHECK((udata), (ptr), (len)) +#endif + +/* Support for 48-bit signed integer duk_tval with transparent semantics. */ +#undef DUK_USE_FASTINT +#if defined(DUK_OPT_FASTINT) +#if !defined(DUK_F_HAVE_64BIT) +#error DUK_OPT_FASTINT requires 64-bit integer type support at the moment +#endif +#define DUK_USE_FASTINT +#endif + +#if defined(DUK_OPT_FILE_IO) +#define DUK_USE_FILE_IO +#elif defined(DUK_OPT_NO_FILE_IO) +#undef DUK_USE_FILE_IO +#else +#define DUK_USE_FILE_IO +#endif + +#if defined(DUK_OPT_FUNCPTR16) +#define DUK_USE_FUNCPTR16 +#elif defined(DUK_OPT_NO_FUNCPTR16) +#undef DUK_USE_FUNCPTR16 +#else +#undef DUK_USE_FUNCPTR16 +#endif + +#if defined(DUK_OPT_FUNCPTR_DEC16) +#define DUK_USE_FUNCPTR_DEC16(udata,ptr) DUK_OPT_FUNCPTR_DEC16((udata),(ptr)) +#else +#undef DUK_USE_FUNCPTR_DEC16 +#endif + +#if defined(DUK_OPT_FUNCPTR_ENC16) +#define DUK_USE_FUNCPTR_ENC16(udata,ptr) DUK_OPT_FUNCPTR_ENC16((udata),(ptr)) +#else +#undef DUK_USE_FUNCPTR_ENC16 +#endif + +#if defined(DUK_OPT_GC_TORTURE) +#define DUK_USE_GC_TORTURE +#elif defined(DUK_OPT_NO_GC_TORTURE) +#undef DUK_USE_GC_TORTURE +#else +#undef DUK_USE_GC_TORTURE +#endif + +#if defined(DUK_OPT_HEAPPTR16) +#define DUK_USE_HEAPPTR16 +#elif defined(DUK_OPT_NO_HEAPPTR16) +#undef DUK_USE_HEAPPTR16 +#else +#undef DUK_USE_HEAPPTR16 +#endif + +#if defined(DUK_OPT_HEAPPTR_DEC16) +#define DUK_USE_HEAPPTR_DEC16(udata,ptr) DUK_OPT_HEAPPTR_DEC16((udata),(ptr)) +#else +#undef DUK_USE_HEAPPTR_DEC16 +#endif + +#if defined(DUK_OPT_HEAPPTR_ENC16) +#define DUK_USE_HEAPPTR_ENC16(udata,ptr) DUK_OPT_HEAPPTR_ENC16((udata),(ptr)) +#else +#undef DUK_USE_HEAPPTR_ENC16 +#endif + +/* For now, hash part is dropped if and only if 16-bit object fields are used. */ +#define DUK_USE_HOBJECT_HASH_PART +#if defined(DUK_OPT_OBJSIZES16) +#undef DUK_USE_HOBJECT_HASH_PART +#endif + +#if defined(DUK_OPT_EXTERNAL_STRINGS) +#define DUK_USE_HSTRING_EXTDATA +#elif defined(DUK_OPT_NO_EXTERNAL_STRINGS) +#undef DUK_USE_HSTRING_EXTDATA +#else +#undef DUK_USE_HSTRING_EXTDATA +#endif + +#if defined(DUK_OPT_INTERRUPT_COUNTER) +#define DUK_USE_INTERRUPT_COUNTER +#elif defined(DUK_OPT_NO_INTERRUPT_COUNTER) +#undef DUK_USE_INTERRUPT_COUNTER +#else +#undef DUK_USE_INTERRUPT_COUNTER +#endif + +#if defined(DUK_OPT_JC) +#define DUK_USE_JC +#elif defined(DUK_OPT_NO_JC) +#undef DUK_USE_JC +#else +#define DUK_USE_JC +#endif + +#if defined(DUK_OPT_JSON_STRINGIFY_FASTPATH) +#define DUK_USE_JSON_STRINGIFY_FASTPATH +#elif defined(DUK_OPT_NO_JSON_STRINGIFY_FASTPATH) +#undef DUK_USE_JSON_STRINGIFY_FASTPATH +#else +#undef DUK_USE_JSON_STRINGIFY_FASTPATH +#endif + +#if defined(DUK_OPT_JX) +#define DUK_USE_JX +#elif defined(DUK_OPT_NO_JX) +#undef DUK_USE_JX +#else +#define DUK_USE_JX +#endif + +#if defined(DUK_OPT_LIGHTFUNC_BUILTINS) +#define DUK_USE_LIGHTFUNC_BUILTINS +#elif defined(DUK_OPT_NO_LIGHTFUNC_BUILTINS) +#undef DUK_USE_LIGHTFUNC_BUILTINS +#else +#undef DUK_USE_LIGHTFUNC_BUILTINS +#endif + +#if defined(DUK_OPT_MARK_AND_SWEEP) +#define DUK_USE_MARK_AND_SWEEP +#elif defined(DUK_OPT_NO_MARK_AND_SWEEP) +#undef DUK_USE_MARK_AND_SWEEP +#else +#define DUK_USE_MARK_AND_SWEEP +#endif + +#if defined(DUK_OPT_MS_STRINGTABLE_RESIZE) +#define DUK_USE_MS_STRINGTABLE_RESIZE +#elif defined(DUK_OPT_NO_MS_STRINGTABLE_RESIZE) +#undef DUK_USE_MS_STRINGTABLE_RESIZE +#else +#define DUK_USE_MS_STRINGTABLE_RESIZE +#endif + +#if defined(DUK_OPT_NONSTD_ARRAY_CONCAT_TRAILER) +#define DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER +#elif defined(DUK_OPT_NO_NONSTD_ARRAY_CONCAT_TRAILER) +#undef DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER +#else +#define DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER +#endif + +#if defined(DUK_OPT_NONSTD_ARRAY_MAP_TRAILER) +#define DUK_USE_NONSTD_ARRAY_MAP_TRAILER +#elif defined(DUK_OPT_NO_NONSTD_ARRAY_MAP_TRAILER) +#undef DUK_USE_NONSTD_ARRAY_MAP_TRAILER +#else +#define DUK_USE_NONSTD_ARRAY_MAP_TRAILER +#endif + +#if defined(DUK_OPT_NONSTD_ARRAY_SPLICE_DELCOUNT) +#define DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT +#elif defined(DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT) +#undef DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT +#else +#define DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT +#endif + +#if defined(DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY) +#define DUK_USE_NONSTD_FUNC_CALLER_PROPERTY +#elif defined(DUK_OPT_NO_NONSTD_FUNC_CALLER_PROPERTY) +#undef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY +#else +#undef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY +#endif + +#if defined(DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY) +#define DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY +#elif defined(DUK_OPT_NO_NONSTD_FUNC_SOURCE_PROPERTY) +#undef DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY +#else +#undef DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY +#endif + +#if defined(DUK_OPT_NONSTD_FUNC_STMT) +#define DUK_USE_NONSTD_FUNC_STMT +#elif defined(DUK_OPT_NO_NONSTD_FUNC_STMT) +#undef DUK_USE_NONSTD_FUNC_STMT +#else +#define DUK_USE_NONSTD_FUNC_STMT +#endif + +#if defined(DUK_OPT_NONSTD_ACCESSOR_KEY_ARGUMENT) +#define DUK_USE_NONSTD_GETTER_KEY_ARGUMENT +#elif defined(DUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT) +#undef DUK_USE_NONSTD_GETTER_KEY_ARGUMENT +#else +#define DUK_USE_NONSTD_GETTER_KEY_ARGUMENT +#endif + +#if defined(DUK_OPT_NONSTD_JSON_ESC_U2028_U2029) +#define DUK_USE_NONSTD_JSON_ESC_U2028_U2029 +#elif defined(DUK_OPT_NO_NONSTD_JSON_ESC_U2028_U2029) +#undef DUK_USE_NONSTD_JSON_ESC_U2028_U2029 +#else +#define DUK_USE_NONSTD_JSON_ESC_U2028_U2029 +#endif + +#if defined(DUK_OPT_NONSTD_REGEXP_DOLLAR_ESCAPE) +#define DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE +#elif defined(DUK_OPT_NO_NONSTD_REGEXP_DOLLAR_ESCAPE) +#undef DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE +#else +#define DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE +#endif + +#if defined(DUK_OPT_NONSTD_ACCESSOR_KEY_ARGUMENT) +#define DUK_USE_NONSTD_SETTER_KEY_ARGUMENT +#elif defined(DUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT) +#undef DUK_USE_NONSTD_SETTER_KEY_ARGUMENT +#else +#define DUK_USE_NONSTD_SETTER_KEY_ARGUMENT +#endif + +#if defined(DUK_OPT_NONSTD_STRING_FROMCHARCODE_32BIT) +#define DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT +#elif defined(DUK_OPT_NO_NONSTD_STRING_FROMCHARCODE_32BIT) +#undef DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT +#else +#define DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT +#endif + +#if defined(DUK_OPT_OBJSIZES16) +#define DUK_USE_OBJSIZES16 +#elif defined(DUK_OPT_NO_OBJSIZES16) +#undef DUK_USE_OBJSIZES16 +#else +#undef DUK_USE_OBJSIZES16 +#endif + +#if defined(DUK_OPT_OCTAL_SUPPORT) +#define DUK_USE_OCTAL_SUPPORT +#elif defined(DUK_OPT_NO_OCTAL_SUPPORT) +#undef DUK_USE_OCTAL_SUPPORT +#else +#define DUK_USE_OCTAL_SUPPORT +#endif + +#if defined(DUK_OPT_PACKED_TVAL) +#define DUK_USE_PACKED_TVAL +#elif defined(DUK_OPT_NO_PACKED_TVAL) +#undef DUK_USE_PACKED_TVAL +#else +#undef DUK_USE_PACKED_TVAL +#endif + +#undef DUK_USE_PANIC_ABORT +#if !defined(DUK_OPT_SEGFAULT_ON_PANIC) +#define DUK_USE_PANIC_ABORT +#endif + +#undef DUK_USE_PANIC_HANDLER +#if defined(DUK_OPT_PANIC_HANDLER) +#define DUK_USE_PANIC_HANDLER(code,msg) DUK_OPT_PANIC_HANDLER((code),(msg)) +#endif + +#undef DUK_USE_PANIC_SEGFAULT +#if defined(DUK_OPT_SEGFAULT_ON_PANIC) +#define DUK_USE_PANIC_SEGFAULT +#endif + +#if defined(DUK_OPT_PARANOID_ERRORS) +#define DUK_USE_PARANOID_ERRORS +#elif defined(DUK_OPT_NO_PARANOID_ERRORS) +#undef DUK_USE_PARANOID_ERRORS +#else +#undef DUK_USE_PARANOID_ERRORS +#endif + +#if defined(DUK_OPT_PC2LINE) +#define DUK_USE_PC2LINE +#elif defined(DUK_OPT_NO_PC2LINE) +#undef DUK_USE_PC2LINE +#else +#define DUK_USE_PC2LINE +#endif + +#if defined(DUK_OPT_REFCOUNT16) +#define DUK_USE_REFCOUNT16 +#elif defined(DUK_OPT_NO_REFCOUNT16) +#undef DUK_USE_REFCOUNT16 +#else +#undef DUK_USE_REFCOUNT16 +#endif + +#if defined(DUK_OPT_REFERENCE_COUNTING) +#define DUK_USE_REFERENCE_COUNTING +#elif defined(DUK_OPT_NO_REFERENCE_COUNTING) +#undef DUK_USE_REFERENCE_COUNTING +#else +#define DUK_USE_REFERENCE_COUNTING +#endif + +#if defined(DUK_OPT_REGEXP_CANON_WORKAROUND) +#define DUK_USE_REGEXP_CANON_WORKAROUND +#elif defined(DUK_OPT_NO_REGEXP_CANON_WORKAROUND) +#undef DUK_USE_REGEXP_CANON_WORKAROUND +#else +#undef DUK_USE_REGEXP_CANON_WORKAROUND +#endif + +#if defined(DUK_OPT_REGEXP_SUPPORT) +#define DUK_USE_REGEXP_SUPPORT +#elif defined(DUK_OPT_NO_REGEXP_SUPPORT) +#undef DUK_USE_REGEXP_SUPPORT +#else +#define DUK_USE_REGEXP_SUPPORT +#endif + +#if defined(DUK_OPT_SECTION_B) +#define DUK_USE_SECTION_B +#elif defined(DUK_OPT_NO_SECTION_B) +#undef DUK_USE_SECTION_B +#else +#define DUK_USE_SECTION_B +#endif + +#if defined(DUK_OPT_SELF_TESTS) +#define DUK_USE_SELF_TESTS +#elif defined(DUK_OPT_NO_SELF_TESTS) +#undef DUK_USE_SELF_TESTS +#else +#undef DUK_USE_SELF_TESTS +#endif + +#if defined(DUK_OPT_SETJMP) +#define DUK_USE_SETJMP +#elif defined(DUK_OPT_NO_SETJMP) +#undef DUK_USE_SETJMP +#else +#define DUK_USE_SETJMP +#endif + +#if defined(DUK_OPT_SHUFFLE_TORTURE) +#define DUK_USE_SHUFFLE_TORTURE +#elif defined(DUK_OPT_NO_SHUFFLE_TORTURE) +#undef DUK_USE_SHUFFLE_TORTURE +#else +#undef DUK_USE_SHUFFLE_TORTURE +#endif + +#if defined(DUK_OPT_SIGSETJMP) +#define DUK_USE_SIGSETJMP +#elif defined(DUK_OPT_NO_SIGSETJMP) +#undef DUK_USE_SIGSETJMP +#else +#undef DUK_USE_SIGSETJMP +#endif + +#if defined(DUK_OPT_SOURCE_NONBMP) +#define DUK_USE_SOURCE_NONBMP +#elif defined(DUK_OPT_NO_SOURCE_NONBMP) +#undef DUK_USE_SOURCE_NONBMP +#else +#define DUK_USE_SOURCE_NONBMP +#endif + +#if defined(DUK_OPT_STRHASH16) +#define DUK_USE_STRHASH16 +#elif defined(DUK_OPT_NO_STRHASH16) +#undef DUK_USE_STRHASH16 +#else +#undef DUK_USE_STRHASH16 +#endif + +#if defined(DUK_OPT_STRICT_DECL) +#define DUK_USE_STRICT_DECL +#elif defined(DUK_OPT_NO_STRICT_DECL) +#undef DUK_USE_STRICT_DECL +#else +#define DUK_USE_STRICT_DECL +#endif + +#if defined(DUK_OPT_STRICT_UTF8_SOURCE) +#define DUK_USE_STRICT_UTF8_SOURCE +#elif defined(DUK_OPT_NO_STRICT_UTF8_SOURCE) +#undef DUK_USE_STRICT_UTF8_SOURCE +#else +#undef DUK_USE_STRICT_UTF8_SOURCE +#endif + +#if defined(DUK_OPT_STRLEN16) +#define DUK_USE_STRLEN16 +#elif defined(DUK_OPT_NO_STRLEN16) +#undef DUK_USE_STRLEN16 +#else +#undef DUK_USE_STRLEN16 +#endif + +#undef DUK_USE_STRTAB_CHAIN +#if defined(DUK_OPT_STRTAB_CHAIN) && defined(DUK_OPT_STRTAB_CHAIN_SIZE) +#define DUK_USE_STRTAB_CHAIN +#endif + +#undef DUK_USE_STRTAB_CHAIN_SIZE +#if defined(DUK_OPT_STRTAB_CHAIN) && defined(DUK_OPT_STRTAB_CHAIN_SIZE) +/* Low memory algorithm: separate chaining using arrays, fixed size hash */ +#define DUK_USE_STRTAB_CHAIN_SIZE DUK_OPT_STRTAB_CHAIN_SIZE +#endif + +#undef DUK_USE_STRTAB_PROBE +#if !(defined(DUK_OPT_STRTAB_CHAIN) && defined(DUK_OPT_STRTAB_CHAIN_SIZE)) +#define DUK_USE_STRTAB_PROBE +#endif + +#if defined(DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY) +#undef DUK_USE_TAILCALL +#else +#define DUK_USE_TAILCALL +#endif + +#if defined(DUK_OPT_TARGET_INFO) +#define DUK_USE_TARGET_INFO DUK_OPT_TARGET_INFO +#else +#define DUK_USE_TARGET_INFO "unknown" +#endif + +#if defined(DUK_OPT_NO_AUGMENT_ERRORS) +#undef DUK_USE_TRACEBACKS +#elif defined(DUK_OPT_NO_TRACEBACKS) +#undef DUK_USE_TRACEBACKS +#else +#define DUK_USE_TRACEBACKS +#endif + +#if defined(DUK_OPT_TRACEBACK_DEPTH) +#define DUK_USE_TRACEBACK_DEPTH DUK_OPT_TRACEBACK_DEPTH +#else +#define DUK_USE_TRACEBACK_DEPTH 10 +#endif + +#if defined(DUK_OPT_UNDERSCORE_SETJMP) +#define DUK_USE_UNDERSCORE_SETJMP +#elif defined(DUK_OPT_NO_UNDERSCORE_SETJMP) +#undef DUK_USE_UNDERSCORE_SETJMP +#else +#undef DUK_USE_UNDERSCORE_SETJMP +#endif + +#if defined(DUK_OPT_DECLARE) +#define DUK_USE_USER_DECLARE() DUK_OPT_DECLARE +#else +#define DUK_USE_USER_DECLARE() /* no user declarations */ +#endif + +/* User provided InitJS. */ +#undef DUK_USE_USER_INITJS +#if defined(DUK_OPT_USER_INITJS) +#define DUK_USE_USER_INITJS (DUK_OPT_USER_INITJS) +#endif + +#if defined(DUK_OPT_VERBOSE_ERRORS) +#define DUK_USE_VERBOSE_ERRORS +#elif defined(DUK_OPT_NO_VERBOSE_ERRORS) +#undef DUK_USE_VERBOSE_ERRORS +#else +#define DUK_USE_VERBOSE_ERRORS +#endif + +#if defined(DUK_OPT_VOLUNTARY_GC) +#define DUK_USE_VOLUNTARY_GC +#elif defined(DUK_OPT_NO_VOLUNTARY_GC) +#undef DUK_USE_VOLUNTARY_GC +#else +#define DUK_USE_VOLUNTARY_GC +#endif + +#if defined(DUK_OPT_ZERO_BUFFER_DATA) +#define DUK_USE_ZERO_BUFFER_DATA +#elif defined(DUK_OPT_NO_ZERO_BUFFER_DATA) +#undef DUK_USE_ZERO_BUFFER_DATA +#else +#define DUK_USE_ZERO_BUFFER_DATA +#endif + +/* + * Autogenerated defaults + */ + +#define DUK_USE_AVOID_PLATFORM_FUNCPTRS +#define DUK_USE_BASE64_FASTPATH +#define DUK_USE_BUILTIN_INITJS +#define DUK_USE_COMPILER_RECLIMIT 2500 +#undef DUK_USE_DATE_FORMAT_STRING +#undef DUK_USE_DATE_GET_LOCAL_TZOFFSET +#undef DUK_USE_DATE_GET_NOW +#undef DUK_USE_DATE_PARSE_STRING +#undef DUK_USE_DATE_PRS_GETDATE +#define DUK_USE_ESBC_LIMITS +#define DUK_USE_ESBC_MAX_BYTES 2147418112L +#define DUK_USE_ESBC_MAX_LINENUMBER 2147418112L +#undef DUK_USE_EXEC_FUN_LOCAL +#undef DUK_USE_EXPLICIT_NULL_INIT +#define DUK_USE_FAST_REFCOUNT_DEFAULT +#define DUK_USE_HEX_FASTPATH +#undef DUK_USE_INTERRUPT_DEBUG_FIXUP +#define DUK_USE_JSON_DECNUMBER_FASTPATH +#define DUK_USE_JSON_DECSTRING_FASTPATH +#define DUK_USE_JSON_DEC_RECLIMIT 1000 +#define DUK_USE_JSON_EATWHITE_FASTPATH +#define DUK_USE_JSON_ENC_RECLIMIT 1000 +#define DUK_USE_JSON_QUOTESTRING_FASTPATH +#define DUK_USE_LEXER_SLIDING_WINDOW +#undef DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE +#define DUK_USE_MARK_AND_SWEEP_RECLIMIT 256 +#define DUK_USE_MATH_BUILTIN +#define DUK_USE_NATIVE_CALL_RECLIMIT 1000 +#undef DUK_USE_PANIC_EXIT +#undef DUK_USE_PREFER_SIZE +#define DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS +#undef DUK_USE_REFZERO_FINALIZER_TORTURE +#define DUK_USE_REGEXP_COMPILER_RECLIMIT 10000 +#define DUK_USE_REGEXP_EXECUTOR_RECLIMIT 10000 +#undef DUK_USE_STRHASH_DENSE +#define DUK_USE_STRHASH_SKIP_SHIFT 5 +#undef DUK_USE_VALSTACK_UNSAFE +#define DUK_USE_VERBOSE_EXECUTOR_ERRORS + +/* + * Alternative customization header + * + * If you want to modify the final DUK_USE_xxx flags directly (without + * using the available DUK_OPT_xxx flags), define DUK_OPT_HAVE_CUSTOM_H + * and tweak the final flags there. + */ + +#if defined(DUK_OPT_HAVE_CUSTOM_H) +#include "duk_custom.h" +#endif + +/* + * You may add overriding #define/#undef directives below for + * customization. You of course cannot un-#include or un-typedef + * anything; these require direct changes above. + */ + +/* __OVERRIDE_DEFINES__ */ + +/* + * Date provider selection + * + * User may define DUK_USE_DATE_GET_NOW() etc directly, in which case we'll + * rely on an external provider. If this is not done, revert to previous + * behavior and use Unix/Windows built-in provider. + */ + +#if defined(DUK_COMPILING_DUKTAPE) + +#if defined(DUK_USE_DATE_GET_NOW) +/* External provider already defined. */ +#elif defined(DUK_USE_DATE_NOW_GETTIMEOFDAY) +#define DUK_USE_DATE_GET_NOW(ctx) duk_bi_date_get_now_gettimeofday((ctx)) +#elif defined(DUK_USE_DATE_NOW_TIME) +#define DUK_USE_DATE_GET_NOW(ctx) duk_bi_date_get_now_time((ctx)) +#elif defined(DUK_USE_DATE_NOW_WINDOWS) +#define DUK_USE_DATE_GET_NOW(ctx) duk_bi_date_get_now_windows((ctx)) +#else +#error no provider for DUK_USE_DATE_GET_NOW() +#endif + +#if defined(DUK_USE_DATE_GET_LOCAL_TZOFFSET) +/* External provider already defined. */ +#elif defined(DUK_USE_DATE_TZO_GMTIME_R) || defined(DUK_USE_DATE_TZO_GMTIME) +#define DUK_USE_DATE_GET_LOCAL_TZOFFSET(d) duk_bi_date_get_local_tzoffset_gmtime((d)) +#elif defined(DUK_USE_DATE_TZO_WINDOWS) +#define DUK_USE_DATE_GET_LOCAL_TZOFFSET(d) duk_bi_date_get_local_tzoffset_windows((d)) +#else +#error no provider for DUK_USE_DATE_GET_LOCAL_TZOFFSET() +#endif + +#if defined(DUK_USE_DATE_PARSE_STRING) +/* External provider already defined. */ +#elif defined(DUK_USE_DATE_PRS_STRPTIME) +#define DUK_USE_DATE_PARSE_STRING(ctx,str) duk_bi_date_parse_string_strptime((ctx), (str)) +#elif defined(DUK_USE_DATE_PRS_GETDATE) +#define DUK_USE_DATE_PARSE_STRING(ctx,str) duk_bi_date_parse_string_getdate((ctx), (str)) +#else +/* No provider for DUK_USE_DATE_PARSE_STRING(), fall back to ISO 8601 only. */ +#endif + +#if defined(DUK_USE_DATE_FORMAT_STRING) +/* External provider already defined. */ +#elif defined(DUK_USE_DATE_FMT_STRFTIME) +#define DUK_USE_DATE_FORMAT_STRING(ctx,parts,tzoffset,flags) \ + duk_bi_date_format_parts_strftime((ctx), (parts), (tzoffset), (flags)) +#else +/* No provider for DUK_USE_DATE_FORMAT_STRING(), fall back to ISO 8601 only. */ +#endif + +#endif /* DUK_COMPILING_DUKTAPE */ + +/* + * Checks for config option consistency (DUK_USE_xxx) + */ + +#if defined(DUK_USE_32BIT_PTRS) +#error unsupported config option used (option has been removed): DUK_USE_32BIT_PTRS +#endif +#if defined(DUK_USE_ALIGN_4) +#error unsupported config option used (option has been removed): DUK_USE_ALIGN_4 +#endif +#if defined(DUK_USE_ALIGN_8) +#error unsupported config option used (option has been removed): DUK_USE_ALIGN_8 +#endif +#if defined(DUK_USE_BYTEORDER_FORCED) +#error unsupported config option used (option has been removed): DUK_USE_BYTEORDER_FORCED +#endif +#if defined(DUK_USE_DATAPTR_DEC16) && !defined(DUK_USE_DATAPTR16) +#error config option DUK_USE_DATAPTR_DEC16 requires option DUK_USE_DATAPTR16 (which is missing) +#endif +#if defined(DUK_USE_DATAPTR_ENC16) && !defined(DUK_USE_DATAPTR16) +#error config option DUK_USE_DATAPTR_ENC16 requires option DUK_USE_DATAPTR16 (which is missing) +#endif +#if defined(DUK_USE_DEBUGGER_SUPPORT) && !defined(DUK_USE_INTERRUPT_COUNTER) +#error config option DUK_USE_DEBUGGER_SUPPORT requires option DUK_USE_INTERRUPT_COUNTER (which is missing) +#endif +#if defined(DUK_USE_DEEP_C_STACK) +#error unsupported config option used (option has been removed): DUK_USE_DEEP_C_STACK +#endif +#if defined(DUK_USE_DOUBLE_BE) +#error unsupported config option used (option has been removed): DUK_USE_DOUBLE_BE +#endif +#if defined(DUK_USE_DOUBLE_BE) && defined(DUK_USE_DOUBLE_LE) +#error config option DUK_USE_DOUBLE_BE conflicts with option DUK_USE_DOUBLE_LE (which is also defined) +#endif +#if defined(DUK_USE_DOUBLE_BE) && defined(DUK_USE_DOUBLE_ME) +#error config option DUK_USE_DOUBLE_BE conflicts with option DUK_USE_DOUBLE_ME (which is also defined) +#endif +#if defined(DUK_USE_DOUBLE_LE) +#error unsupported config option used (option has been removed): DUK_USE_DOUBLE_LE +#endif +#if defined(DUK_USE_DOUBLE_LE) && defined(DUK_USE_DOUBLE_BE) +#error config option DUK_USE_DOUBLE_LE conflicts with option DUK_USE_DOUBLE_BE (which is also defined) +#endif +#if defined(DUK_USE_DOUBLE_LE) && defined(DUK_USE_DOUBLE_ME) +#error config option DUK_USE_DOUBLE_LE conflicts with option DUK_USE_DOUBLE_ME (which is also defined) +#endif +#if defined(DUK_USE_DOUBLE_ME) +#error unsupported config option used (option has been removed): DUK_USE_DOUBLE_ME +#endif +#if defined(DUK_USE_DOUBLE_ME) && defined(DUK_USE_DOUBLE_LE) +#error config option DUK_USE_DOUBLE_ME conflicts with option DUK_USE_DOUBLE_LE (which is also defined) +#endif +#if defined(DUK_USE_DOUBLE_ME) && defined(DUK_USE_DOUBLE_BE) +#error config option DUK_USE_DOUBLE_ME conflicts with option DUK_USE_DOUBLE_BE (which is also defined) +#endif +#if defined(DUK_USE_DPRINT) && !defined(DUK_USE_DEBUG) +#error config option DUK_USE_DPRINT requires option DUK_USE_DEBUG (which is missing) +#endif +#if defined(DUK_USE_ESBC_MAX_BYTES) && !defined(DUK_USE_ESBC_LIMITS) +#error config option DUK_USE_ESBC_MAX_BYTES requires option DUK_USE_ESBC_LIMITS (which is missing) +#endif +#if defined(DUK_USE_ESBC_MAX_LINENUMBER) && !defined(DUK_USE_ESBC_LIMITS) +#error config option DUK_USE_ESBC_MAX_LINENUMBER requires option DUK_USE_ESBC_LIMITS (which is missing) +#endif +#if defined(DUK_USE_EXEC_TIMEOUT_CHECK) && !defined(DUK_USE_INTERRUPT_COUNTER) +#error config option DUK_USE_EXEC_TIMEOUT_CHECK requires option DUK_USE_INTERRUPT_COUNTER (which is missing) +#endif +#if defined(DUK_USE_EXTSTR_FREE) && !defined(DUK_USE_HSTRING_EXTDATA) +#error config option DUK_USE_EXTSTR_FREE requires option DUK_USE_HSTRING_EXTDATA (which is missing) +#endif +#if defined(DUK_USE_EXTSTR_INTERN_CHECK) && !defined(DUK_USE_HSTRING_EXTDATA) +#error config option DUK_USE_EXTSTR_INTERN_CHECK requires option DUK_USE_HSTRING_EXTDATA (which is missing) +#endif +#if defined(DUK_USE_FULL_TVAL) +#error unsupported config option used (option has been removed): DUK_USE_FULL_TVAL +#endif +#if defined(DUK_USE_FUNCPTR_DEC16) && !defined(DUK_USE_FUNCPTR16) +#error config option DUK_USE_FUNCPTR_DEC16 requires option DUK_USE_FUNCPTR16 (which is missing) +#endif +#if defined(DUK_USE_FUNCPTR_ENC16) && !defined(DUK_USE_FUNCPTR16) +#error config option DUK_USE_FUNCPTR_ENC16 requires option DUK_USE_FUNCPTR16 (which is missing) +#endif +#if defined(DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS) +#error unsupported config option used (option has been removed): DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS +#endif +#if defined(DUK_USE_HEAPPTR16) && defined(DUK_USE_DEBUG) +#error config option DUK_USE_HEAPPTR16 conflicts with option DUK_USE_DEBUG (which is also defined) +#endif +#if defined(DUK_USE_HEAPPTR_DEC16) && !defined(DUK_USE_HEAPPTR16) +#error config option DUK_USE_HEAPPTR_DEC16 requires option DUK_USE_HEAPPTR16 (which is missing) +#endif +#if defined(DUK_USE_HEAPPTR_ENC16) && !defined(DUK_USE_HEAPPTR16) +#error config option DUK_USE_HEAPPTR_ENC16 requires option DUK_USE_HEAPPTR16 (which is missing) +#endif +#if defined(DUK_USE_INTEGER_BE) +#error unsupported config option used (option has been removed): DUK_USE_INTEGER_BE +#endif +#if defined(DUK_USE_INTEGER_BE) && defined(DUK_USE_INTEGER_LE) +#error config option DUK_USE_INTEGER_BE conflicts with option DUK_USE_INTEGER_LE (which is also defined) +#endif +#if defined(DUK_USE_INTEGER_BE) && defined(DUK_USE_INTEGER_ME) +#error config option DUK_USE_INTEGER_BE conflicts with option DUK_USE_INTEGER_ME (which is also defined) +#endif +#if defined(DUK_USE_INTEGER_LE) +#error unsupported config option used (option has been removed): DUK_USE_INTEGER_LE +#endif +#if defined(DUK_USE_INTEGER_LE) && defined(DUK_USE_INTEGER_BE) +#error config option DUK_USE_INTEGER_LE conflicts with option DUK_USE_INTEGER_BE (which is also defined) +#endif +#if defined(DUK_USE_INTEGER_LE) && defined(DUK_USE_INTEGER_ME) +#error config option DUK_USE_INTEGER_LE conflicts with option DUK_USE_INTEGER_ME (which is also defined) +#endif +#if defined(DUK_USE_INTEGER_ME) +#error unsupported config option used (option has been removed): DUK_USE_INTEGER_ME +#endif +#if defined(DUK_USE_INTEGER_ME) && defined(DUK_USE_INTEGER_LE) +#error config option DUK_USE_INTEGER_ME conflicts with option DUK_USE_INTEGER_LE (which is also defined) +#endif +#if defined(DUK_USE_INTEGER_ME) && defined(DUK_USE_INTEGER_BE) +#error config option DUK_USE_INTEGER_ME conflicts with option DUK_USE_INTEGER_BE (which is also defined) +#endif +#if defined(DUK_USE_NO_DOUBLE_ALIASING_SELFTEST) +#error unsupported config option used (option has been removed): DUK_USE_NO_DOUBLE_ALIASING_SELFTEST +#endif +#if defined(DUK_USE_PACKED_TVAL_POSSIBLE) +#error unsupported config option used (option has been removed): DUK_USE_PACKED_TVAL_POSSIBLE +#endif +#if defined(DUK_USE_RDTSC) +#error unsupported config option used (option has been removed): DUK_USE_RDTSC +#endif +#if defined(DUK_USE_STRTAB_CHAIN_SIZE) && !defined(DUK_USE_STRTAB_CHAIN) +#error config option DUK_USE_STRTAB_CHAIN_SIZE requires option DUK_USE_STRTAB_CHAIN (which is missing) +#endif +#if defined(DUK_USE_TAILCALL) && defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY) +#error config option DUK_USE_TAILCALL conflicts with option DUK_USE_NONSTD_FUNC_CALLER_PROPERTY (which is also defined) +#endif +#if defined(DUK_USE_UNALIGNED_ACCESSES_POSSIBLE) +#error unsupported config option used (option has been removed): DUK_USE_UNALIGNED_ACCESSES_POSSIBLE +#endif + +#if defined(DUK_USE_CPP_EXCEPTIONS) && !defined(__cplusplus) +#error DUK_USE_CPP_EXCEPTIONS enabled but not compiling with a C++ compiler +#endif + +/* + * Convert DUK_USE_BYTEORDER, from whatever source, into currently used + * internal defines. If detection failed, #error out. + */ + +#if defined(DUK_USE_BYTEORDER) +#if (DUK_USE_BYTEORDER == 1) +#define DUK_USE_INTEGER_LE +#define DUK_USE_DOUBLE_LE +#elif (DUK_USE_BYTEORDER == 2) +#define DUK_USE_INTEGER_LE /* integer endianness is little on purpose */ +#define DUK_USE_DOUBLE_ME +#elif (DUK_USE_BYTEORDER == 3) +#define DUK_USE_INTEGER_BE +#define DUK_USE_DOUBLE_BE +#else +#error unsupported: byte order invalid +#endif /* byte order */ +#else +#error unsupported: byte order detection failed +#endif /* defined(DUK_USE_BYTEORDER) */ + +#endif /* DUK_CONFIG_H_INCLUDED */ diff --git a/src/duktape/duktape/duktape.c b/src/duktape/duktape/duktape.c index 44324404e9..dc62df8d19 100644 --- a/src/duktape/duktape/duktape.c +++ b/src/duktape/duktape/duktape.c @@ -1,6 +1,8 @@ /* - * Single file autogenerated distributable for Duktape 1.2.2. - * Git commit 5f4302c732d21b3b721db3d3473db32e4eb92470 (v1.2.2). + * Single source autogenerated distributable for Duktape 1.4.0. + * + * Git commit cad6f595382a0cc1a7e4207794ade5be11b3e397 (v1.4.0). + * Git branch master. * * See Duktape AUTHORS.rst and LICENSE.txt for copyright and * licensing information. @@ -14,7 +16,7 @@ * * (http://opensource.org/licenses/MIT) * -* Copyright (c) 2013-2015 by Duktape authors (see AUTHORS.rst) +* Copyright (c) 2013-2016 by Duktape authors (see AUTHORS.rst) * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal @@ -33,7 +35,6 @@ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. -* */ /* AUTHORS.rst */ /* @@ -54,14 +55,18 @@ * Please include an e-mail address, a link to your GitHub profile, or something * similar to allow your contribution to be identified accurately. * -* The following people have contributed code and agreed to irrevocably license -* their contributions under the Duktape ``LICENSE.txt`` (in order of appearance): +* The following people have contributed code, website contents, or Wiki contents, +* and agreed to irrevocably license their contributions under the Duktape +* ``LICENSE.txt`` (in order of appearance): * * * Sami Vaarala * * Niki Dobrev * * Andreas \u00d6man * * L\u00e1szl\u00f3 Lang\u00f3 * * Legimet +* * Karl Skomski +* * Bruce Pascoe +* * Ren\u00e9 Hollander * * Other contributions * =================== @@ -86,7 +91,7 @@ * * Josh Engebretson (https://github.com/JoshEngebretson) * * Remo Eichenberger (https://github.com/remoe) * * Mamod Mehyar (https://github.com/mamod) -* * David Demelier (https://github.com/hftmarkand) +* * David Demelier (https://github.com/markand) * * Tim Caswell (https://github.com/creationix) * * Mitchell Blank Jr (https://github.com/mitchblank) * * https://github.com/yushli @@ -95,6 +100,10 @@ * * Joshua Peek (https://github.com/josh) * * Bruce E. Pascoe (https://github.com/fatcerberus) * * https://github.com/Kelledin +* * https://github.com/sstruchtrup +* * Michael Drake (https://github.com/tlsa) +* * https://github.com/chris-y +* * Laurent Zubiaur (https://github.com/lzubiaur) * * If you are accidentally missing from this list, send me an e-mail * (``sami.vaarala@iki.fi``) and I'll fix the omission. @@ -129,7 +138,7 @@ /* * User declarations, e.g. prototypes for user functions used by Duktape - * macros. Concretely, if DUK_OPT_PANIC_HANDLER is used and the macro + * macros. Concretely, if DUK_USE_PANIC_HANDLER is used and the macro * value calls a user function, it needs to be declared for Duktape * compilation to avoid warnings. */ @@ -149,23 +158,31 @@ DUK_USE_USER_DECLARE() #ifndef DUK_REPLACEMENTS_H_INCLUDED #define DUK_REPLACEMENTS_H_INCLUDED -#ifdef DUK_USE_REPL_FPCLASSIFY +#if defined(DUK_USE_COMPUTED_INFINITY) +DUK_INTERNAL_DECL double duk_computed_infinity; +#endif + +#if defined(DUK_USE_COMPUTED_NAN) +DUK_INTERNAL_DECL double duk_computed_nan; +#endif + +#if defined(DUK_USE_REPL_FPCLASSIFY) DUK_INTERNAL_DECL int duk_repl_fpclassify(double x); #endif -#ifdef DUK_USE_REPL_SIGNBIT +#if defined(DUK_USE_REPL_SIGNBIT) DUK_INTERNAL_DECL int duk_repl_signbit(double x); #endif -#ifdef DUK_USE_REPL_ISFINITE +#if defined(DUK_USE_REPL_ISFINITE) DUK_INTERNAL_DECL int duk_repl_isfinite(double x); #endif -#ifdef DUK_USE_REPL_ISNAN +#if defined(DUK_USE_REPL_ISNAN) DUK_INTERNAL_DECL int duk_repl_isnan(double x); #endif -#ifdef DUK_USE_REPL_ISINF +#if defined(DUK_USE_REPL_ISINF) DUK_INTERNAL_DECL int duk_repl_isinf(double x); #endif @@ -184,6 +201,7 @@ DUK_INTERNAL_DECL int duk_repl_isinf(double x); #ifndef DUK_JMPBUF_H_INCLUDED #define DUK_JMPBUF_H_INCLUDED +#if !defined(DUK_USE_CPP_EXCEPTIONS) struct duk_jmpbuf { #if defined(DUK_USE_SETJMP) || defined(DUK_USE_UNDERSCORE_SETJMP) jmp_buf jb; @@ -193,8 +211,28 @@ struct duk_jmpbuf { #error internal error, no long control transfer provider #endif }; +#endif #endif /* DUK_JMPBUF_H_INCLUDED */ +#line 1 "duk_exception.h" +/* + * Exception for Duktape internal throws when C++ exceptions are used + * for long control transfers. + * + * Doesn't inherit from any exception base class to minimize the chance + * that user code would accidentally catch this exception. + */ + +#ifndef DUK_EXCEPTION_H_INCLUDED +#define DUK_EXCEPTION_H_INCLUDED + +#if defined(DUK_USE_CPP_EXCEPTIONS) +class duk_internal_exception { + /* intentionally empty */ +}; +#endif + +#endif /* DUK_EXCEPTION_H_INCLUDED */ #line 1 "duk_forwdecl.h" /* * Forward declarations for all Duktape structures. @@ -207,7 +245,11 @@ struct duk_jmpbuf { * Forward declarations */ +#if defined(DUK_USE_CPP_EXCEPTIONS) +class duk_internal_exception; +#else struct duk_jmpbuf; +#endif /* duk_tval intentionally skipped */ struct duk_heaphdr; @@ -218,9 +260,11 @@ struct duk_hobject; struct duk_hcompiledfunction; struct duk_hnativefunction; struct duk_hthread; +struct duk_hbufferobject; struct duk_hbuffer; struct duk_hbuffer_fixed; struct duk_hbuffer_dynamic; +struct duk_hbuffer_external; struct duk_propaccessor; union duk_propvalue; @@ -241,11 +285,13 @@ struct duk_fixedbuffer; struct duk_bitdecoder_ctx; struct duk_bitencoder_ctx; +struct duk_bufwriter_ctx; struct duk_token; struct duk_re_token; struct duk_lexer_point; struct duk_lexer_ctx; +struct duk_lexer_codepoint; struct duk_compiler_instr; struct duk_compiler_func; @@ -254,7 +300,11 @@ struct duk_compiler_ctx; struct duk_re_matcher_ctx; struct duk_re_compiler_ctx; +#if defined(DUK_USE_CPP_EXCEPTIONS) +/* no typedef */ +#else typedef struct duk_jmpbuf duk_jmpbuf; +#endif /* duk_tval intentionally skipped */ typedef struct duk_heaphdr duk_heaphdr; @@ -264,10 +314,12 @@ typedef struct duk_hstring_external duk_hstring_external; typedef struct duk_hobject duk_hobject; typedef struct duk_hcompiledfunction duk_hcompiledfunction; typedef struct duk_hnativefunction duk_hnativefunction; +typedef struct duk_hbufferobject duk_hbufferobject; typedef struct duk_hthread duk_hthread; typedef struct duk_hbuffer duk_hbuffer; typedef struct duk_hbuffer_fixed duk_hbuffer_fixed; typedef struct duk_hbuffer_dynamic duk_hbuffer_dynamic; +typedef struct duk_hbuffer_external duk_hbuffer_external; typedef struct duk_propaccessor duk_propaccessor; typedef union duk_propvalue duk_propvalue; @@ -288,11 +340,13 @@ typedef struct duk_fixedbuffer duk_fixedbuffer; typedef struct duk_bitdecoder_ctx duk_bitdecoder_ctx; typedef struct duk_bitencoder_ctx duk_bitencoder_ctx; +typedef struct duk_bufwriter_ctx duk_bufwriter_ctx; typedef struct duk_token duk_token; typedef struct duk_re_token duk_re_token; typedef struct duk_lexer_point duk_lexer_point; typedef struct duk_lexer_ctx duk_lexer_ctx; +typedef struct duk_lexer_codepoint duk_lexer_codepoint; typedef struct duk_compiler_instr duk_compiler_instr; typedef struct duk_compiler_func duk_compiler_func; @@ -312,348 +366,426 @@ typedef struct duk_re_compiler_ctx duk_re_compiler_ctx; #if defined(DUK_USE_DOUBLE_LE) #if !defined(DUK_SINGLE_FILE) -DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; +DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[2624]; #endif /* !DUK_SINGLE_FILE */ -#define DUK_STRDATA_DATA_LENGTH 1943 +#define DUK_STRDATA_DATA_LENGTH 2624 #define DUK_STRDATA_MAX_STRLEN 24 #define DUK_STRIDX_UC_LOGGER 0 /* 'Logger' */ #define DUK_STRIDX_UC_THREAD 1 /* 'Thread' */ #define DUK_STRIDX_UC_POINTER 2 /* 'Pointer' */ -#define DUK_STRIDX_UC_BUFFER 3 /* 'Buffer' */ -#define DUK_STRIDX_DEC_ENV 4 /* 'DecEnv' */ -#define DUK_STRIDX_OBJ_ENV 5 /* 'ObjEnv' */ -#define DUK_STRIDX_EMPTY_STRING 6 /* '' */ -#define DUK_STRIDX_GLOBAL 7 /* 'global' */ -#define DUK_STRIDX_UC_ARGUMENTS 8 /* 'Arguments' */ -#define DUK_STRIDX_JSON 9 /* 'JSON' */ -#define DUK_STRIDX_MATH 10 /* 'Math' */ -#define DUK_STRIDX_UC_ERROR 11 /* 'Error' */ -#define DUK_STRIDX_REG_EXP 12 /* 'RegExp' */ -#define DUK_STRIDX_DATE 13 /* 'Date' */ -#define DUK_STRIDX_UC_NUMBER 14 /* 'Number' */ -#define DUK_STRIDX_UC_BOOLEAN 15 /* 'Boolean' */ -#define DUK_STRIDX_UC_STRING 16 /* 'String' */ -#define DUK_STRIDX_ARRAY 17 /* 'Array' */ -#define DUK_STRIDX_UC_FUNCTION 18 /* 'Function' */ -#define DUK_STRIDX_UC_OBJECT 19 /* 'Object' */ -#define DUK_STRIDX_UC_NULL 20 /* 'Null' */ -#define DUK_STRIDX_UC_UNDEFINED 21 /* 'Undefined' */ -#define DUK_STRIDX_JSON_EXT_FUNCTION2 22 /* '{_func:true}' */ -#define DUK_STRIDX_JSON_EXT_FUNCTION1 23 /* '{"_func":true}' */ -#define DUK_STRIDX_JSON_EXT_NEGINF 24 /* '{"_ninf":true}' */ -#define DUK_STRIDX_JSON_EXT_POSINF 25 /* '{"_inf":true}' */ -#define DUK_STRIDX_JSON_EXT_NAN 26 /* '{"_nan":true}' */ -#define DUK_STRIDX_JSON_EXT_UNDEFINED 27 /* '{"_undef":true}' */ -#define DUK_STRIDX_TO_LOG_STRING 28 /* 'toLogString' */ -#define DUK_STRIDX_CLOG 29 /* 'clog' */ -#define DUK_STRIDX_LC_L 30 /* 'l' */ -#define DUK_STRIDX_LC_N 31 /* 'n' */ -#define DUK_STRIDX_LC_FATAL 32 /* 'fatal' */ -#define DUK_STRIDX_LC_ERROR 33 /* 'error' */ -#define DUK_STRIDX_LC_WARN 34 /* 'warn' */ -#define DUK_STRIDX_LC_DEBUG 35 /* 'debug' */ -#define DUK_STRIDX_LC_TRACE 36 /* 'trace' */ -#define DUK_STRIDX_RAW 37 /* 'raw' */ -#define DUK_STRIDX_FMT 38 /* 'fmt' */ -#define DUK_STRIDX_CURRENT 39 /* 'current' */ -#define DUK_STRIDX_RESUME 40 /* 'resume' */ -#define DUK_STRIDX_COMPACT 41 /* 'compact' */ -#define DUK_STRIDX_JC 42 /* 'jc' */ -#define DUK_STRIDX_JX 43 /* 'jx' */ -#define DUK_STRIDX_BASE64 44 /* 'base64' */ -#define DUK_STRIDX_HEX 45 /* 'hex' */ -#define DUK_STRIDX_DEC 46 /* 'dec' */ -#define DUK_STRIDX_ENC 47 /* 'enc' */ -#define DUK_STRIDX_FIN 48 /* 'fin' */ -#define DUK_STRIDX_GC 49 /* 'gc' */ -#define DUK_STRIDX_ACT 50 /* 'act' */ -#define DUK_STRIDX_LC_INFO 51 /* 'info' */ -#define DUK_STRIDX_VERSION 52 /* 'version' */ -#define DUK_STRIDX_ENV 53 /* 'env' */ -#define DUK_STRIDX_MOD_LOADED 54 /* 'modLoaded' */ -#define DUK_STRIDX_MOD_SEARCH 55 /* 'modSearch' */ -#define DUK_STRIDX_ERR_THROW 56 /* 'errThrow' */ -#define DUK_STRIDX_ERR_CREATE 57 /* 'errCreate' */ -#define DUK_STRIDX_COMPILE 58 /* 'compile' */ -#define DUK_STRIDX_INT_REGBASE 59 /* '\x00Regbase' */ -#define DUK_STRIDX_INT_THREAD 60 /* '\x00Thread' */ -#define DUK_STRIDX_INT_HANDLER 61 /* '\x00Handler' */ -#define DUK_STRIDX_INT_FINALIZER 62 /* '\x00Finalizer' */ -#define DUK_STRIDX_INT_CALLEE 63 /* '\x00Callee' */ -#define DUK_STRIDX_INT_MAP 64 /* '\x00Map' */ -#define DUK_STRIDX_INT_ARGS 65 /* '\x00Args' */ -#define DUK_STRIDX_INT_THIS 66 /* '\x00This' */ -#define DUK_STRIDX_INT_PC2LINE 67 /* '\x00Pc2line' */ -#define DUK_STRIDX_INT_SOURCE 68 /* '\x00Source' */ -#define DUK_STRIDX_INT_VARENV 69 /* '\x00Varenv' */ -#define DUK_STRIDX_INT_LEXENV 70 /* '\x00Lexenv' */ -#define DUK_STRIDX_INT_VARMAP 71 /* '\x00Varmap' */ -#define DUK_STRIDX_INT_FORMALS 72 /* '\x00Formals' */ -#define DUK_STRIDX_INT_BYTECODE 73 /* '\x00Bytecode' */ -#define DUK_STRIDX_INT_NEXT 74 /* '\x00Next' */ -#define DUK_STRIDX_INT_TARGET 75 /* '\x00Target' */ -#define DUK_STRIDX_INT_VALUE 76 /* '\x00Value' */ -#define DUK_STRIDX_LC_POINTER 77 /* 'pointer' */ -#define DUK_STRIDX_LC_BUFFER 78 /* 'buffer' */ -#define DUK_STRIDX_INT_TRACEDATA 79 /* '\x00Tracedata' */ -#define DUK_STRIDX_LINE_NUMBER 80 /* 'lineNumber' */ -#define DUK_STRIDX_FILE_NAME 81 /* 'fileName' */ -#define DUK_STRIDX_PC 82 /* 'pc' */ -#define DUK_STRIDX_STACK 83 /* 'stack' */ -#define DUK_STRIDX_THROW_TYPE_ERROR 84 /* 'ThrowTypeError' */ -#define DUK_STRIDX_DUKTAPE 85 /* 'Duktape' */ -#define DUK_STRIDX_ID 86 /* 'id' */ -#define DUK_STRIDX_REQUIRE 87 /* 'require' */ -#define DUK_STRIDX___PROTO__ 88 /* '__proto__' */ -#define DUK_STRIDX_SET_PROTOTYPE_OF 89 /* 'setPrototypeOf' */ -#define DUK_STRIDX_OWN_KEYS 90 /* 'ownKeys' */ -#define DUK_STRIDX_ENUMERATE 91 /* 'enumerate' */ -#define DUK_STRIDX_DELETE_PROPERTY 92 /* 'deleteProperty' */ -#define DUK_STRIDX_HAS 93 /* 'has' */ -#define DUK_STRIDX_PROXY 94 /* 'Proxy' */ -#define DUK_STRIDX_CALLEE 95 /* 'callee' */ -#define DUK_STRIDX_INVALID_DATE 96 /* 'Invalid Date' */ -#define DUK_STRIDX_BRACKETED_ELLIPSIS 97 /* '[...]' */ -#define DUK_STRIDX_NEWLINE_TAB 98 /* '\n\t' */ -#define DUK_STRIDX_SPACE 99 /* ' ' */ -#define DUK_STRIDX_COMMA 100 /* ',' */ -#define DUK_STRIDX_MINUS_ZERO 101 /* '-0' */ -#define DUK_STRIDX_PLUS_ZERO 102 /* '+0' */ -#define DUK_STRIDX_ZERO 103 /* '0' */ -#define DUK_STRIDX_MINUS_INFINITY 104 /* '-Infinity' */ -#define DUK_STRIDX_PLUS_INFINITY 105 /* '+Infinity' */ -#define DUK_STRIDX_INFINITY 106 /* 'Infinity' */ -#define DUK_STRIDX_LC_OBJECT 107 /* 'object' */ -#define DUK_STRIDX_LC_STRING 108 /* 'string' */ -#define DUK_STRIDX_LC_NUMBER 109 /* 'number' */ -#define DUK_STRIDX_LC_BOOLEAN 110 /* 'boolean' */ -#define DUK_STRIDX_LC_UNDEFINED 111 /* 'undefined' */ -#define DUK_STRIDX_STRINGIFY 112 /* 'stringify' */ -#define DUK_STRIDX_TAN 113 /* 'tan' */ -#define DUK_STRIDX_SQRT 114 /* 'sqrt' */ -#define DUK_STRIDX_SIN 115 /* 'sin' */ -#define DUK_STRIDX_ROUND 116 /* 'round' */ -#define DUK_STRIDX_RANDOM 117 /* 'random' */ -#define DUK_STRIDX_POW 118 /* 'pow' */ -#define DUK_STRIDX_MIN 119 /* 'min' */ -#define DUK_STRIDX_MAX 120 /* 'max' */ -#define DUK_STRIDX_LOG 121 /* 'log' */ -#define DUK_STRIDX_FLOOR 122 /* 'floor' */ -#define DUK_STRIDX_EXP 123 /* 'exp' */ -#define DUK_STRIDX_COS 124 /* 'cos' */ -#define DUK_STRIDX_CEIL 125 /* 'ceil' */ -#define DUK_STRIDX_ATAN2 126 /* 'atan2' */ -#define DUK_STRIDX_ATAN 127 /* 'atan' */ -#define DUK_STRIDX_ASIN 128 /* 'asin' */ -#define DUK_STRIDX_ACOS 129 /* 'acos' */ -#define DUK_STRIDX_ABS 130 /* 'abs' */ -#define DUK_STRIDX_SQRT2 131 /* 'SQRT2' */ -#define DUK_STRIDX_SQRT1_2 132 /* 'SQRT1_2' */ -#define DUK_STRIDX_PI 133 /* 'PI' */ -#define DUK_STRIDX_LOG10E 134 /* 'LOG10E' */ -#define DUK_STRIDX_LOG2E 135 /* 'LOG2E' */ -#define DUK_STRIDX_LN2 136 /* 'LN2' */ -#define DUK_STRIDX_LN10 137 /* 'LN10' */ -#define DUK_STRIDX_E 138 /* 'E' */ -#define DUK_STRIDX_MESSAGE 139 /* 'message' */ -#define DUK_STRIDX_NAME 140 /* 'name' */ -#define DUK_STRIDX_INPUT 141 /* 'input' */ -#define DUK_STRIDX_INDEX 142 /* 'index' */ -#define DUK_STRIDX_ESCAPED_EMPTY_REGEXP 143 /* '(?:)' */ -#define DUK_STRIDX_LAST_INDEX 144 /* 'lastIndex' */ -#define DUK_STRIDX_MULTILINE 145 /* 'multiline' */ -#define DUK_STRIDX_IGNORE_CASE 146 /* 'ignoreCase' */ -#define DUK_STRIDX_SOURCE 147 /* 'source' */ -#define DUK_STRIDX_TEST 148 /* 'test' */ -#define DUK_STRIDX_EXEC 149 /* 'exec' */ -#define DUK_STRIDX_TO_GMT_STRING 150 /* 'toGMTString' */ -#define DUK_STRIDX_SET_YEAR 151 /* 'setYear' */ -#define DUK_STRIDX_GET_YEAR 152 /* 'getYear' */ -#define DUK_STRIDX_TO_JSON 153 /* 'toJSON' */ -#define DUK_STRIDX_TO_ISO_STRING 154 /* 'toISOString' */ -#define DUK_STRIDX_TO_UTC_STRING 155 /* 'toUTCString' */ -#define DUK_STRIDX_SET_UTC_FULL_YEAR 156 /* 'setUTCFullYear' */ -#define DUK_STRIDX_SET_FULL_YEAR 157 /* 'setFullYear' */ -#define DUK_STRIDX_SET_UTC_MONTH 158 /* 'setUTCMonth' */ -#define DUK_STRIDX_SET_MONTH 159 /* 'setMonth' */ -#define DUK_STRIDX_SET_UTC_DATE 160 /* 'setUTCDate' */ -#define DUK_STRIDX_SET_DATE 161 /* 'setDate' */ -#define DUK_STRIDX_SET_UTC_HOURS 162 /* 'setUTCHours' */ -#define DUK_STRIDX_SET_HOURS 163 /* 'setHours' */ -#define DUK_STRIDX_SET_UTC_MINUTES 164 /* 'setUTCMinutes' */ -#define DUK_STRIDX_SET_MINUTES 165 /* 'setMinutes' */ -#define DUK_STRIDX_SET_UTC_SECONDS 166 /* 'setUTCSeconds' */ -#define DUK_STRIDX_SET_SECONDS 167 /* 'setSeconds' */ -#define DUK_STRIDX_SET_UTC_MILLISECONDS 168 /* 'setUTCMilliseconds' */ -#define DUK_STRIDX_SET_MILLISECONDS 169 /* 'setMilliseconds' */ -#define DUK_STRIDX_SET_TIME 170 /* 'setTime' */ -#define DUK_STRIDX_GET_TIMEZONE_OFFSET 171 /* 'getTimezoneOffset' */ -#define DUK_STRIDX_GET_UTC_MILLISECONDS 172 /* 'getUTCMilliseconds' */ -#define DUK_STRIDX_GET_MILLISECONDS 173 /* 'getMilliseconds' */ -#define DUK_STRIDX_GET_UTC_SECONDS 174 /* 'getUTCSeconds' */ -#define DUK_STRIDX_GET_SECONDS 175 /* 'getSeconds' */ -#define DUK_STRIDX_GET_UTC_MINUTES 176 /* 'getUTCMinutes' */ -#define DUK_STRIDX_GET_MINUTES 177 /* 'getMinutes' */ -#define DUK_STRIDX_GET_UTC_HOURS 178 /* 'getUTCHours' */ -#define DUK_STRIDX_GET_HOURS 179 /* 'getHours' */ -#define DUK_STRIDX_GET_UTC_DAY 180 /* 'getUTCDay' */ -#define DUK_STRIDX_GET_DAY 181 /* 'getDay' */ -#define DUK_STRIDX_GET_UTC_DATE 182 /* 'getUTCDate' */ -#define DUK_STRIDX_GET_DATE 183 /* 'getDate' */ -#define DUK_STRIDX_GET_UTC_MONTH 184 /* 'getUTCMonth' */ -#define DUK_STRIDX_GET_MONTH 185 /* 'getMonth' */ -#define DUK_STRIDX_GET_UTC_FULL_YEAR 186 /* 'getUTCFullYear' */ -#define DUK_STRIDX_GET_FULL_YEAR 187 /* 'getFullYear' */ -#define DUK_STRIDX_GET_TIME 188 /* 'getTime' */ -#define DUK_STRIDX_TO_LOCALE_TIME_STRING 189 /* 'toLocaleTimeString' */ -#define DUK_STRIDX_TO_LOCALE_DATE_STRING 190 /* 'toLocaleDateString' */ -#define DUK_STRIDX_TO_TIME_STRING 191 /* 'toTimeString' */ -#define DUK_STRIDX_TO_DATE_STRING 192 /* 'toDateString' */ -#define DUK_STRIDX_NOW 193 /* 'now' */ -#define DUK_STRIDX_UTC 194 /* 'UTC' */ -#define DUK_STRIDX_PARSE 195 /* 'parse' */ -#define DUK_STRIDX_TO_PRECISION 196 /* 'toPrecision' */ -#define DUK_STRIDX_TO_EXPONENTIAL 197 /* 'toExponential' */ -#define DUK_STRIDX_TO_FIXED 198 /* 'toFixed' */ -#define DUK_STRIDX_POSITIVE_INFINITY 199 /* 'POSITIVE_INFINITY' */ -#define DUK_STRIDX_NEGATIVE_INFINITY 200 /* 'NEGATIVE_INFINITY' */ -#define DUK_STRIDX_NAN 201 /* 'NaN' */ -#define DUK_STRIDX_MIN_VALUE 202 /* 'MIN_VALUE' */ -#define DUK_STRIDX_MAX_VALUE 203 /* 'MAX_VALUE' */ -#define DUK_STRIDX_SUBSTR 204 /* 'substr' */ -#define DUK_STRIDX_TRIM 205 /* 'trim' */ -#define DUK_STRIDX_TO_LOCALE_UPPER_CASE 206 /* 'toLocaleUpperCase' */ -#define DUK_STRIDX_TO_UPPER_CASE 207 /* 'toUpperCase' */ -#define DUK_STRIDX_TO_LOCALE_LOWER_CASE 208 /* 'toLocaleLowerCase' */ -#define DUK_STRIDX_TO_LOWER_CASE 209 /* 'toLowerCase' */ -#define DUK_STRIDX_SUBSTRING 210 /* 'substring' */ -#define DUK_STRIDX_SPLIT 211 /* 'split' */ -#define DUK_STRIDX_SEARCH 212 /* 'search' */ -#define DUK_STRIDX_REPLACE 213 /* 'replace' */ -#define DUK_STRIDX_MATCH 214 /* 'match' */ -#define DUK_STRIDX_LOCALE_COMPARE 215 /* 'localeCompare' */ -#define DUK_STRIDX_CHAR_CODE_AT 216 /* 'charCodeAt' */ -#define DUK_STRIDX_CHAR_AT 217 /* 'charAt' */ -#define DUK_STRIDX_FROM_CHAR_CODE 218 /* 'fromCharCode' */ -#define DUK_STRIDX_REDUCE_RIGHT 219 /* 'reduceRight' */ -#define DUK_STRIDX_REDUCE 220 /* 'reduce' */ -#define DUK_STRIDX_FILTER 221 /* 'filter' */ -#define DUK_STRIDX_MAP 222 /* 'map' */ -#define DUK_STRIDX_FOR_EACH 223 /* 'forEach' */ -#define DUK_STRIDX_SOME 224 /* 'some' */ -#define DUK_STRIDX_EVERY 225 /* 'every' */ -#define DUK_STRIDX_LAST_INDEX_OF 226 /* 'lastIndexOf' */ -#define DUK_STRIDX_INDEX_OF 227 /* 'indexOf' */ -#define DUK_STRIDX_UNSHIFT 228 /* 'unshift' */ -#define DUK_STRIDX_SPLICE 229 /* 'splice' */ -#define DUK_STRIDX_SORT 230 /* 'sort' */ -#define DUK_STRIDX_SLICE 231 /* 'slice' */ -#define DUK_STRIDX_SHIFT 232 /* 'shift' */ -#define DUK_STRIDX_REVERSE 233 /* 'reverse' */ -#define DUK_STRIDX_PUSH 234 /* 'push' */ -#define DUK_STRIDX_POP 235 /* 'pop' */ -#define DUK_STRIDX_JOIN 236 /* 'join' */ -#define DUK_STRIDX_CONCAT 237 /* 'concat' */ -#define DUK_STRIDX_IS_ARRAY 238 /* 'isArray' */ -#define DUK_STRIDX_LC_ARGUMENTS 239 /* 'arguments' */ -#define DUK_STRIDX_CALLER 240 /* 'caller' */ -#define DUK_STRIDX_BIND 241 /* 'bind' */ -#define DUK_STRIDX_CALL 242 /* 'call' */ -#define DUK_STRIDX_APPLY 243 /* 'apply' */ -#define DUK_STRIDX_PROPERTY_IS_ENUMERABLE 244 /* 'propertyIsEnumerable' */ -#define DUK_STRIDX_IS_PROTOTYPE_OF 245 /* 'isPrototypeOf' */ -#define DUK_STRIDX_HAS_OWN_PROPERTY 246 /* 'hasOwnProperty' */ -#define DUK_STRIDX_VALUE_OF 247 /* 'valueOf' */ -#define DUK_STRIDX_TO_LOCALE_STRING 248 /* 'toLocaleString' */ -#define DUK_STRIDX_TO_STRING 249 /* 'toString' */ -#define DUK_STRIDX_CONSTRUCTOR 250 /* 'constructor' */ -#define DUK_STRIDX_SET 251 /* 'set' */ -#define DUK_STRIDX_GET 252 /* 'get' */ -#define DUK_STRIDX_ENUMERABLE 253 /* 'enumerable' */ -#define DUK_STRIDX_CONFIGURABLE 254 /* 'configurable' */ -#define DUK_STRIDX_WRITABLE 255 /* 'writable' */ -#define DUK_STRIDX_VALUE 256 /* 'value' */ -#define DUK_STRIDX_KEYS 257 /* 'keys' */ -#define DUK_STRIDX_IS_EXTENSIBLE 258 /* 'isExtensible' */ -#define DUK_STRIDX_IS_FROZEN 259 /* 'isFrozen' */ -#define DUK_STRIDX_IS_SEALED 260 /* 'isSealed' */ -#define DUK_STRIDX_PREVENT_EXTENSIONS 261 /* 'preventExtensions' */ -#define DUK_STRIDX_FREEZE 262 /* 'freeze' */ -#define DUK_STRIDX_SEAL 263 /* 'seal' */ -#define DUK_STRIDX_DEFINE_PROPERTIES 264 /* 'defineProperties' */ -#define DUK_STRIDX_DEFINE_PROPERTY 265 /* 'defineProperty' */ -#define DUK_STRIDX_CREATE 266 /* 'create' */ -#define DUK_STRIDX_GET_OWN_PROPERTY_NAMES 267 /* 'getOwnPropertyNames' */ -#define DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR 268 /* 'getOwnPropertyDescriptor' */ -#define DUK_STRIDX_GET_PROTOTYPE_OF 269 /* 'getPrototypeOf' */ -#define DUK_STRIDX_PROTOTYPE 270 /* 'prototype' */ -#define DUK_STRIDX_LENGTH 271 /* 'length' */ -#define DUK_STRIDX_ALERT 272 /* 'alert' */ -#define DUK_STRIDX_PRINT 273 /* 'print' */ -#define DUK_STRIDX_UNESCAPE 274 /* 'unescape' */ -#define DUK_STRIDX_ESCAPE 275 /* 'escape' */ -#define DUK_STRIDX_ENCODE_URI_COMPONENT 276 /* 'encodeURIComponent' */ -#define DUK_STRIDX_ENCODE_URI 277 /* 'encodeURI' */ -#define DUK_STRIDX_DECODE_URI_COMPONENT 278 /* 'decodeURIComponent' */ -#define DUK_STRIDX_DECODE_URI 279 /* 'decodeURI' */ -#define DUK_STRIDX_IS_FINITE 280 /* 'isFinite' */ -#define DUK_STRIDX_IS_NAN 281 /* 'isNaN' */ -#define DUK_STRIDX_PARSE_FLOAT 282 /* 'parseFloat' */ -#define DUK_STRIDX_PARSE_INT 283 /* 'parseInt' */ -#define DUK_STRIDX_EVAL 284 /* 'eval' */ -#define DUK_STRIDX_URI_ERROR 285 /* 'URIError' */ -#define DUK_STRIDX_TYPE_ERROR 286 /* 'TypeError' */ -#define DUK_STRIDX_SYNTAX_ERROR 287 /* 'SyntaxError' */ -#define DUK_STRIDX_REFERENCE_ERROR 288 /* 'ReferenceError' */ -#define DUK_STRIDX_RANGE_ERROR 289 /* 'RangeError' */ -#define DUK_STRIDX_EVAL_ERROR 290 /* 'EvalError' */ -#define DUK_STRIDX_BREAK 291 /* 'break' */ -#define DUK_STRIDX_CASE 292 /* 'case' */ -#define DUK_STRIDX_CATCH 293 /* 'catch' */ -#define DUK_STRIDX_CONTINUE 294 /* 'continue' */ -#define DUK_STRIDX_DEBUGGER 295 /* 'debugger' */ -#define DUK_STRIDX_DEFAULT 296 /* 'default' */ -#define DUK_STRIDX_DELETE 297 /* 'delete' */ -#define DUK_STRIDX_DO 298 /* 'do' */ -#define DUK_STRIDX_ELSE 299 /* 'else' */ -#define DUK_STRIDX_FINALLY 300 /* 'finally' */ -#define DUK_STRIDX_FOR 301 /* 'for' */ -#define DUK_STRIDX_LC_FUNCTION 302 /* 'function' */ -#define DUK_STRIDX_IF 303 /* 'if' */ -#define DUK_STRIDX_IN 304 /* 'in' */ -#define DUK_STRIDX_INSTANCEOF 305 /* 'instanceof' */ -#define DUK_STRIDX_NEW 306 /* 'new' */ -#define DUK_STRIDX_RETURN 307 /* 'return' */ -#define DUK_STRIDX_SWITCH 308 /* 'switch' */ -#define DUK_STRIDX_THIS 309 /* 'this' */ -#define DUK_STRIDX_THROW 310 /* 'throw' */ -#define DUK_STRIDX_TRY 311 /* 'try' */ -#define DUK_STRIDX_TYPEOF 312 /* 'typeof' */ -#define DUK_STRIDX_VAR 313 /* 'var' */ -#define DUK_STRIDX_VOID 314 /* 'void' */ -#define DUK_STRIDX_WHILE 315 /* 'while' */ -#define DUK_STRIDX_WITH 316 /* 'with' */ -#define DUK_STRIDX_CLASS 317 /* 'class' */ -#define DUK_STRIDX_CONST 318 /* 'const' */ -#define DUK_STRIDX_ENUM 319 /* 'enum' */ -#define DUK_STRIDX_EXPORT 320 /* 'export' */ -#define DUK_STRIDX_EXTENDS 321 /* 'extends' */ -#define DUK_STRIDX_IMPORT 322 /* 'import' */ -#define DUK_STRIDX_SUPER 323 /* 'super' */ -#define DUK_STRIDX_LC_NULL 324 /* 'null' */ -#define DUK_STRIDX_TRUE 325 /* 'true' */ -#define DUK_STRIDX_FALSE 326 /* 'false' */ -#define DUK_STRIDX_IMPLEMENTS 327 /* 'implements' */ -#define DUK_STRIDX_INTERFACE 328 /* 'interface' */ -#define DUK_STRIDX_LET 329 /* 'let' */ -#define DUK_STRIDX_PACKAGE 330 /* 'package' */ -#define DUK_STRIDX_PRIVATE 331 /* 'private' */ -#define DUK_STRIDX_PROTECTED 332 /* 'protected' */ -#define DUK_STRIDX_PUBLIC 333 /* 'public' */ -#define DUK_STRIDX_STATIC 334 /* 'static' */ -#define DUK_STRIDX_YIELD 335 /* 'yield' */ +#define DUK_STRIDX_DEC_ENV 3 /* 'DecEnv' */ +#define DUK_STRIDX_OBJ_ENV 4 /* 'ObjEnv' */ +#define DUK_STRIDX_FLOAT64_ARRAY 5 /* 'Float64Array' */ +#define DUK_STRIDX_FLOAT32_ARRAY 6 /* 'Float32Array' */ +#define DUK_STRIDX_UINT32_ARRAY 7 /* 'Uint32Array' */ +#define DUK_STRIDX_INT32_ARRAY 8 /* 'Int32Array' */ +#define DUK_STRIDX_UINT16_ARRAY 9 /* 'Uint16Array' */ +#define DUK_STRIDX_INT16_ARRAY 10 /* 'Int16Array' */ +#define DUK_STRIDX_UINT8_CLAMPED_ARRAY 11 /* 'Uint8ClampedArray' */ +#define DUK_STRIDX_UINT8_ARRAY 12 /* 'Uint8Array' */ +#define DUK_STRIDX_INT8_ARRAY 13 /* 'Int8Array' */ +#define DUK_STRIDX_DATA_VIEW 14 /* 'DataView' */ +#define DUK_STRIDX_ARRAY_BUFFER 15 /* 'ArrayBuffer' */ +#define DUK_STRIDX_UC_BUFFER 16 /* 'Buffer' */ +#define DUK_STRIDX_EMPTY_STRING 17 /* '' */ +#define DUK_STRIDX_GLOBAL 18 /* 'global' */ +#define DUK_STRIDX_UC_ARGUMENTS 19 /* 'Arguments' */ +#define DUK_STRIDX_JSON 20 /* 'JSON' */ +#define DUK_STRIDX_MATH 21 /* 'Math' */ +#define DUK_STRIDX_UC_ERROR 22 /* 'Error' */ +#define DUK_STRIDX_REG_EXP 23 /* 'RegExp' */ +#define DUK_STRIDX_DATE 24 /* 'Date' */ +#define DUK_STRIDX_UC_NUMBER 25 /* 'Number' */ +#define DUK_STRIDX_UC_BOOLEAN 26 /* 'Boolean' */ +#define DUK_STRIDX_UC_STRING 27 /* 'String' */ +#define DUK_STRIDX_ARRAY 28 /* 'Array' */ +#define DUK_STRIDX_UC_FUNCTION 29 /* 'Function' */ +#define DUK_STRIDX_UC_OBJECT 30 /* 'Object' */ +#define DUK_STRIDX_UC_NULL 31 /* 'Null' */ +#define DUK_STRIDX_UC_UNDEFINED 32 /* 'Undefined' */ +#define DUK_STRIDX_JSON_EXT_FUNCTION2 33 /* '{_func:true}' */ +#define DUK_STRIDX_JSON_EXT_FUNCTION1 34 /* '{"_func":true}' */ +#define DUK_STRIDX_JSON_EXT_NEGINF 35 /* '{"_ninf":true}' */ +#define DUK_STRIDX_JSON_EXT_POSINF 36 /* '{"_inf":true}' */ +#define DUK_STRIDX_JSON_EXT_NAN 37 /* '{"_nan":true}' */ +#define DUK_STRIDX_JSON_EXT_UNDEFINED 38 /* '{"_undef":true}' */ +#define DUK_STRIDX_TO_LOG_STRING 39 /* 'toLogString' */ +#define DUK_STRIDX_CLOG 40 /* 'clog' */ +#define DUK_STRIDX_LC_L 41 /* 'l' */ +#define DUK_STRIDX_LC_N 42 /* 'n' */ +#define DUK_STRIDX_LC_FATAL 43 /* 'fatal' */ +#define DUK_STRIDX_LC_ERROR 44 /* 'error' */ +#define DUK_STRIDX_LC_WARN 45 /* 'warn' */ +#define DUK_STRIDX_LC_DEBUG 46 /* 'debug' */ +#define DUK_STRIDX_LC_TRACE 47 /* 'trace' */ +#define DUK_STRIDX_RAW 48 /* 'raw' */ +#define DUK_STRIDX_FMT 49 /* 'fmt' */ +#define DUK_STRIDX_CURRENT 50 /* 'current' */ +#define DUK_STRIDX_RESUME 51 /* 'resume' */ +#define DUK_STRIDX_COMPACT 52 /* 'compact' */ +#define DUK_STRIDX_JC 53 /* 'jc' */ +#define DUK_STRIDX_JX 54 /* 'jx' */ +#define DUK_STRIDX_BASE64 55 /* 'base64' */ +#define DUK_STRIDX_HEX 56 /* 'hex' */ +#define DUK_STRIDX_DEC 57 /* 'dec' */ +#define DUK_STRIDX_ENC 58 /* 'enc' */ +#define DUK_STRIDX_FIN 59 /* 'fin' */ +#define DUK_STRIDX_GC 60 /* 'gc' */ +#define DUK_STRIDX_ACT 61 /* 'act' */ +#define DUK_STRIDX_LC_INFO 62 /* 'info' */ +#define DUK_STRIDX_VERSION 63 /* 'version' */ +#define DUK_STRIDX_ENV 64 /* 'env' */ +#define DUK_STRIDX_MOD_LOADED 65 /* 'modLoaded' */ +#define DUK_STRIDX_MOD_SEARCH 66 /* 'modSearch' */ +#define DUK_STRIDX_ERR_THROW 67 /* 'errThrow' */ +#define DUK_STRIDX_ERR_CREATE 68 /* 'errCreate' */ +#define DUK_STRIDX_COMPILE 69 /* 'compile' */ +#define DUK_STRIDX_INT_REGBASE 70 /* '\x00Regbase' */ +#define DUK_STRIDX_INT_THREAD 71 /* '\x00Thread' */ +#define DUK_STRIDX_INT_HANDLER 72 /* '\x00Handler' */ +#define DUK_STRIDX_INT_FINALIZER 73 /* '\x00Finalizer' */ +#define DUK_STRIDX_INT_CALLEE 74 /* '\x00Callee' */ +#define DUK_STRIDX_INT_MAP 75 /* '\x00Map' */ +#define DUK_STRIDX_INT_ARGS 76 /* '\x00Args' */ +#define DUK_STRIDX_INT_THIS 77 /* '\x00This' */ +#define DUK_STRIDX_INT_PC2LINE 78 /* '\x00Pc2line' */ +#define DUK_STRIDX_INT_SOURCE 79 /* '\x00Source' */ +#define DUK_STRIDX_INT_VARENV 80 /* '\x00Varenv' */ +#define DUK_STRIDX_INT_LEXENV 81 /* '\x00Lexenv' */ +#define DUK_STRIDX_INT_VARMAP 82 /* '\x00Varmap' */ +#define DUK_STRIDX_INT_FORMALS 83 /* '\x00Formals' */ +#define DUK_STRIDX_INT_BYTECODE 84 /* '\x00Bytecode' */ +#define DUK_STRIDX_INT_NEXT 85 /* '\x00Next' */ +#define DUK_STRIDX_INT_TARGET 86 /* '\x00Target' */ +#define DUK_STRIDX_INT_VALUE 87 /* '\x00Value' */ +#define DUK_STRIDX_LC_POINTER 88 /* 'pointer' */ +#define DUK_STRIDX_INT_TRACEDATA 89 /* '\x00Tracedata' */ +#define DUK_STRIDX_LINE_NUMBER 90 /* 'lineNumber' */ +#define DUK_STRIDX_FILE_NAME 91 /* 'fileName' */ +#define DUK_STRIDX_PC 92 /* 'pc' */ +#define DUK_STRIDX_STACK 93 /* 'stack' */ +#define DUK_STRIDX_THROW_TYPE_ERROR 94 /* 'ThrowTypeError' */ +#define DUK_STRIDX_DUKTAPE 95 /* 'Duktape' */ +#define DUK_STRIDX_SET_FLOAT64 96 /* 'setFloat64' */ +#define DUK_STRIDX_SET_FLOAT32 97 /* 'setFloat32' */ +#define DUK_STRIDX_SET_UINT32 98 /* 'setUint32' */ +#define DUK_STRIDX_SET_INT32 99 /* 'setInt32' */ +#define DUK_STRIDX_SET_UINT16 100 /* 'setUint16' */ +#define DUK_STRIDX_SET_INT16 101 /* 'setInt16' */ +#define DUK_STRIDX_SET_UINT8 102 /* 'setUint8' */ +#define DUK_STRIDX_SET_INT8 103 /* 'setInt8' */ +#define DUK_STRIDX_GET_FLOAT64 104 /* 'getFloat64' */ +#define DUK_STRIDX_GET_FLOAT32 105 /* 'getFloat32' */ +#define DUK_STRIDX_GET_UINT32 106 /* 'getUint32' */ +#define DUK_STRIDX_GET_INT32 107 /* 'getInt32' */ +#define DUK_STRIDX_GET_UINT16 108 /* 'getUint16' */ +#define DUK_STRIDX_GET_INT16 109 /* 'getInt16' */ +#define DUK_STRIDX_GET_UINT8 110 /* 'getUint8' */ +#define DUK_STRIDX_GET_INT8 111 /* 'getInt8' */ +#define DUK_STRIDX_SUBARRAY 112 /* 'subarray' */ +#define DUK_STRIDX_BYTES_PER_ELEMENT 113 /* 'BYTES_PER_ELEMENT' */ +#define DUK_STRIDX_BYTE_OFFSET 114 /* 'byteOffset' */ +#define DUK_STRIDX_LC_BUFFER 115 /* 'buffer' */ +#define DUK_STRIDX_IS_VIEW 116 /* 'isView' */ +#define DUK_STRIDX_DATA 117 /* 'data' */ +#define DUK_STRIDX_TYPE 118 /* 'type' */ +#define DUK_STRIDX_WRITE_INT_BE 119 /* 'writeIntBE' */ +#define DUK_STRIDX_WRITE_INT_LE 120 /* 'writeIntLE' */ +#define DUK_STRIDX_WRITE_UINT_BE 121 /* 'writeUIntBE' */ +#define DUK_STRIDX_WRITE_UINT_LE 122 /* 'writeUIntLE' */ +#define DUK_STRIDX_WRITE_DOUBLE_BE 123 /* 'writeDoubleBE' */ +#define DUK_STRIDX_WRITE_DOUBLE_LE 124 /* 'writeDoubleLE' */ +#define DUK_STRIDX_WRITE_FLOAT_BE 125 /* 'writeFloatBE' */ +#define DUK_STRIDX_WRITE_FLOAT_LE 126 /* 'writeFloatLE' */ +#define DUK_STRIDX_WRITE_INT32_BE 127 /* 'writeInt32BE' */ +#define DUK_STRIDX_WRITE_INT32_LE 128 /* 'writeInt32LE' */ +#define DUK_STRIDX_WRITE_UINT32_BE 129 /* 'writeUInt32BE' */ +#define DUK_STRIDX_WRITE_UINT32_LE 130 /* 'writeUInt32LE' */ +#define DUK_STRIDX_WRITE_INT16_BE 131 /* 'writeInt16BE' */ +#define DUK_STRIDX_WRITE_INT16_LE 132 /* 'writeInt16LE' */ +#define DUK_STRIDX_WRITE_UINT16_BE 133 /* 'writeUInt16BE' */ +#define DUK_STRIDX_WRITE_UINT16_LE 134 /* 'writeUInt16LE' */ +#define DUK_STRIDX_WRITE_INT8 135 /* 'writeInt8' */ +#define DUK_STRIDX_WRITE_UINT8 136 /* 'writeUInt8' */ +#define DUK_STRIDX_READ_INT_BE 137 /* 'readIntBE' */ +#define DUK_STRIDX_READ_INT_LE 138 /* 'readIntLE' */ +#define DUK_STRIDX_READ_UINT_BE 139 /* 'readUIntBE' */ +#define DUK_STRIDX_READ_UINT_LE 140 /* 'readUIntLE' */ +#define DUK_STRIDX_READ_DOUBLE_BE 141 /* 'readDoubleBE' */ +#define DUK_STRIDX_READ_DOUBLE_LE 142 /* 'readDoubleLE' */ +#define DUK_STRIDX_READ_FLOAT_BE 143 /* 'readFloatBE' */ +#define DUK_STRIDX_READ_FLOAT_LE 144 /* 'readFloatLE' */ +#define DUK_STRIDX_READ_INT32_BE 145 /* 'readInt32BE' */ +#define DUK_STRIDX_READ_INT32_LE 146 /* 'readInt32LE' */ +#define DUK_STRIDX_READ_UINT32_BE 147 /* 'readUInt32BE' */ +#define DUK_STRIDX_READ_UINT32_LE 148 /* 'readUInt32LE' */ +#define DUK_STRIDX_READ_INT16_BE 149 /* 'readInt16BE' */ +#define DUK_STRIDX_READ_INT16_LE 150 /* 'readInt16LE' */ +#define DUK_STRIDX_READ_UINT16_BE 151 /* 'readUInt16BE' */ +#define DUK_STRIDX_READ_UINT16_LE 152 /* 'readUInt16LE' */ +#define DUK_STRIDX_READ_INT8 153 /* 'readInt8' */ +#define DUK_STRIDX_READ_UINT8 154 /* 'readUInt8' */ +#define DUK_STRIDX_COPY 155 /* 'copy' */ +#define DUK_STRIDX_EQUALS 156 /* 'equals' */ +#define DUK_STRIDX_FILL 157 /* 'fill' */ +#define DUK_STRIDX_WRITE 158 /* 'write' */ +#define DUK_STRIDX_COMPARE 159 /* 'compare' */ +#define DUK_STRIDX_BYTE_LENGTH 160 /* 'byteLength' */ +#define DUK_STRIDX_IS_BUFFER 161 /* 'isBuffer' */ +#define DUK_STRIDX_IS_ENCODING 162 /* 'isEncoding' */ +#define DUK_STRIDX_EXPORTS 163 /* 'exports' */ +#define DUK_STRIDX_ID 164 /* 'id' */ +#define DUK_STRIDX_REQUIRE 165 /* 'require' */ +#define DUK_STRIDX___PROTO__ 166 /* '__proto__' */ +#define DUK_STRIDX_SET_PROTOTYPE_OF 167 /* 'setPrototypeOf' */ +#define DUK_STRIDX_OWN_KEYS 168 /* 'ownKeys' */ +#define DUK_STRIDX_ENUMERATE 169 /* 'enumerate' */ +#define DUK_STRIDX_DELETE_PROPERTY 170 /* 'deleteProperty' */ +#define DUK_STRIDX_HAS 171 /* 'has' */ +#define DUK_STRIDX_PROXY 172 /* 'Proxy' */ +#define DUK_STRIDX_CALLEE 173 /* 'callee' */ +#define DUK_STRIDX_INVALID_DATE 174 /* 'Invalid Date' */ +#define DUK_STRIDX_BRACKETED_ELLIPSIS 175 /* '[...]' */ +#define DUK_STRIDX_NEWLINE_TAB 176 /* '\n\t' */ +#define DUK_STRIDX_SPACE 177 /* ' ' */ +#define DUK_STRIDX_COMMA 178 /* ',' */ +#define DUK_STRIDX_MINUS_ZERO 179 /* '-0' */ +#define DUK_STRIDX_PLUS_ZERO 180 /* '+0' */ +#define DUK_STRIDX_ZERO 181 /* '0' */ +#define DUK_STRIDX_MINUS_INFINITY 182 /* '-Infinity' */ +#define DUK_STRIDX_PLUS_INFINITY 183 /* '+Infinity' */ +#define DUK_STRIDX_INFINITY 184 /* 'Infinity' */ +#define DUK_STRIDX_LC_OBJECT 185 /* 'object' */ +#define DUK_STRIDX_LC_STRING 186 /* 'string' */ +#define DUK_STRIDX_LC_NUMBER 187 /* 'number' */ +#define DUK_STRIDX_LC_BOOLEAN 188 /* 'boolean' */ +#define DUK_STRIDX_LC_UNDEFINED 189 /* 'undefined' */ +#define DUK_STRIDX_STRINGIFY 190 /* 'stringify' */ +#define DUK_STRIDX_TAN 191 /* 'tan' */ +#define DUK_STRIDX_SQRT 192 /* 'sqrt' */ +#define DUK_STRIDX_SIN 193 /* 'sin' */ +#define DUK_STRIDX_ROUND 194 /* 'round' */ +#define DUK_STRIDX_RANDOM 195 /* 'random' */ +#define DUK_STRIDX_POW 196 /* 'pow' */ +#define DUK_STRIDX_MIN 197 /* 'min' */ +#define DUK_STRIDX_MAX 198 /* 'max' */ +#define DUK_STRIDX_LOG 199 /* 'log' */ +#define DUK_STRIDX_FLOOR 200 /* 'floor' */ +#define DUK_STRIDX_EXP 201 /* 'exp' */ +#define DUK_STRIDX_COS 202 /* 'cos' */ +#define DUK_STRIDX_CEIL 203 /* 'ceil' */ +#define DUK_STRIDX_ATAN2 204 /* 'atan2' */ +#define DUK_STRIDX_ATAN 205 /* 'atan' */ +#define DUK_STRIDX_ASIN 206 /* 'asin' */ +#define DUK_STRIDX_ACOS 207 /* 'acos' */ +#define DUK_STRIDX_ABS 208 /* 'abs' */ +#define DUK_STRIDX_SQRT2 209 /* 'SQRT2' */ +#define DUK_STRIDX_SQRT1_2 210 /* 'SQRT1_2' */ +#define DUK_STRIDX_PI 211 /* 'PI' */ +#define DUK_STRIDX_LOG10E 212 /* 'LOG10E' */ +#define DUK_STRIDX_LOG2E 213 /* 'LOG2E' */ +#define DUK_STRIDX_LN2 214 /* 'LN2' */ +#define DUK_STRIDX_LN10 215 /* 'LN10' */ +#define DUK_STRIDX_E 216 /* 'E' */ +#define DUK_STRIDX_MESSAGE 217 /* 'message' */ +#define DUK_STRIDX_NAME 218 /* 'name' */ +#define DUK_STRIDX_INPUT 219 /* 'input' */ +#define DUK_STRIDX_INDEX 220 /* 'index' */ +#define DUK_STRIDX_ESCAPED_EMPTY_REGEXP 221 /* '(?:)' */ +#define DUK_STRIDX_LAST_INDEX 222 /* 'lastIndex' */ +#define DUK_STRIDX_MULTILINE 223 /* 'multiline' */ +#define DUK_STRIDX_IGNORE_CASE 224 /* 'ignoreCase' */ +#define DUK_STRIDX_SOURCE 225 /* 'source' */ +#define DUK_STRIDX_TEST 226 /* 'test' */ +#define DUK_STRIDX_EXEC 227 /* 'exec' */ +#define DUK_STRIDX_TO_GMT_STRING 228 /* 'toGMTString' */ +#define DUK_STRIDX_SET_YEAR 229 /* 'setYear' */ +#define DUK_STRIDX_GET_YEAR 230 /* 'getYear' */ +#define DUK_STRIDX_TO_JSON 231 /* 'toJSON' */ +#define DUK_STRIDX_TO_ISO_STRING 232 /* 'toISOString' */ +#define DUK_STRIDX_TO_UTC_STRING 233 /* 'toUTCString' */ +#define DUK_STRIDX_SET_UTC_FULL_YEAR 234 /* 'setUTCFullYear' */ +#define DUK_STRIDX_SET_FULL_YEAR 235 /* 'setFullYear' */ +#define DUK_STRIDX_SET_UTC_MONTH 236 /* 'setUTCMonth' */ +#define DUK_STRIDX_SET_MONTH 237 /* 'setMonth' */ +#define DUK_STRIDX_SET_UTC_DATE 238 /* 'setUTCDate' */ +#define DUK_STRIDX_SET_DATE 239 /* 'setDate' */ +#define DUK_STRIDX_SET_UTC_HOURS 240 /* 'setUTCHours' */ +#define DUK_STRIDX_SET_HOURS 241 /* 'setHours' */ +#define DUK_STRIDX_SET_UTC_MINUTES 242 /* 'setUTCMinutes' */ +#define DUK_STRIDX_SET_MINUTES 243 /* 'setMinutes' */ +#define DUK_STRIDX_SET_UTC_SECONDS 244 /* 'setUTCSeconds' */ +#define DUK_STRIDX_SET_SECONDS 245 /* 'setSeconds' */ +#define DUK_STRIDX_SET_UTC_MILLISECONDS 246 /* 'setUTCMilliseconds' */ +#define DUK_STRIDX_SET_MILLISECONDS 247 /* 'setMilliseconds' */ +#define DUK_STRIDX_SET_TIME 248 /* 'setTime' */ +#define DUK_STRIDX_GET_TIMEZONE_OFFSET 249 /* 'getTimezoneOffset' */ +#define DUK_STRIDX_GET_UTC_MILLISECONDS 250 /* 'getUTCMilliseconds' */ +#define DUK_STRIDX_GET_MILLISECONDS 251 /* 'getMilliseconds' */ +#define DUK_STRIDX_GET_UTC_SECONDS 252 /* 'getUTCSeconds' */ +#define DUK_STRIDX_GET_SECONDS 253 /* 'getSeconds' */ +#define DUK_STRIDX_GET_UTC_MINUTES 254 /* 'getUTCMinutes' */ +#define DUK_STRIDX_GET_MINUTES 255 /* 'getMinutes' */ +#define DUK_STRIDX_GET_UTC_HOURS 256 /* 'getUTCHours' */ +#define DUK_STRIDX_GET_HOURS 257 /* 'getHours' */ +#define DUK_STRIDX_GET_UTC_DAY 258 /* 'getUTCDay' */ +#define DUK_STRIDX_GET_DAY 259 /* 'getDay' */ +#define DUK_STRIDX_GET_UTC_DATE 260 /* 'getUTCDate' */ +#define DUK_STRIDX_GET_DATE 261 /* 'getDate' */ +#define DUK_STRIDX_GET_UTC_MONTH 262 /* 'getUTCMonth' */ +#define DUK_STRIDX_GET_MONTH 263 /* 'getMonth' */ +#define DUK_STRIDX_GET_UTC_FULL_YEAR 264 /* 'getUTCFullYear' */ +#define DUK_STRIDX_GET_FULL_YEAR 265 /* 'getFullYear' */ +#define DUK_STRIDX_GET_TIME 266 /* 'getTime' */ +#define DUK_STRIDX_TO_LOCALE_TIME_STRING 267 /* 'toLocaleTimeString' */ +#define DUK_STRIDX_TO_LOCALE_DATE_STRING 268 /* 'toLocaleDateString' */ +#define DUK_STRIDX_TO_TIME_STRING 269 /* 'toTimeString' */ +#define DUK_STRIDX_TO_DATE_STRING 270 /* 'toDateString' */ +#define DUK_STRIDX_NOW 271 /* 'now' */ +#define DUK_STRIDX_UTC 272 /* 'UTC' */ +#define DUK_STRIDX_PARSE 273 /* 'parse' */ +#define DUK_STRIDX_TO_PRECISION 274 /* 'toPrecision' */ +#define DUK_STRIDX_TO_EXPONENTIAL 275 /* 'toExponential' */ +#define DUK_STRIDX_TO_FIXED 276 /* 'toFixed' */ +#define DUK_STRIDX_POSITIVE_INFINITY 277 /* 'POSITIVE_INFINITY' */ +#define DUK_STRIDX_NEGATIVE_INFINITY 278 /* 'NEGATIVE_INFINITY' */ +#define DUK_STRIDX_NAN 279 /* 'NaN' */ +#define DUK_STRIDX_MIN_VALUE 280 /* 'MIN_VALUE' */ +#define DUK_STRIDX_MAX_VALUE 281 /* 'MAX_VALUE' */ +#define DUK_STRIDX_SUBSTR 282 /* 'substr' */ +#define DUK_STRIDX_TRIM 283 /* 'trim' */ +#define DUK_STRIDX_TO_LOCALE_UPPER_CASE 284 /* 'toLocaleUpperCase' */ +#define DUK_STRIDX_TO_UPPER_CASE 285 /* 'toUpperCase' */ +#define DUK_STRIDX_TO_LOCALE_LOWER_CASE 286 /* 'toLocaleLowerCase' */ +#define DUK_STRIDX_TO_LOWER_CASE 287 /* 'toLowerCase' */ +#define DUK_STRIDX_SUBSTRING 288 /* 'substring' */ +#define DUK_STRIDX_SPLIT 289 /* 'split' */ +#define DUK_STRIDX_SEARCH 290 /* 'search' */ +#define DUK_STRIDX_REPLACE 291 /* 'replace' */ +#define DUK_STRIDX_MATCH 292 /* 'match' */ +#define DUK_STRIDX_LOCALE_COMPARE 293 /* 'localeCompare' */ +#define DUK_STRIDX_CHAR_CODE_AT 294 /* 'charCodeAt' */ +#define DUK_STRIDX_CHAR_AT 295 /* 'charAt' */ +#define DUK_STRIDX_FROM_CHAR_CODE 296 /* 'fromCharCode' */ +#define DUK_STRIDX_REDUCE_RIGHT 297 /* 'reduceRight' */ +#define DUK_STRIDX_REDUCE 298 /* 'reduce' */ +#define DUK_STRIDX_FILTER 299 /* 'filter' */ +#define DUK_STRIDX_MAP 300 /* 'map' */ +#define DUK_STRIDX_FOR_EACH 301 /* 'forEach' */ +#define DUK_STRIDX_SOME 302 /* 'some' */ +#define DUK_STRIDX_EVERY 303 /* 'every' */ +#define DUK_STRIDX_LAST_INDEX_OF 304 /* 'lastIndexOf' */ +#define DUK_STRIDX_INDEX_OF 305 /* 'indexOf' */ +#define DUK_STRIDX_UNSHIFT 306 /* 'unshift' */ +#define DUK_STRIDX_SPLICE 307 /* 'splice' */ +#define DUK_STRIDX_SORT 308 /* 'sort' */ +#define DUK_STRIDX_SLICE 309 /* 'slice' */ +#define DUK_STRIDX_SHIFT 310 /* 'shift' */ +#define DUK_STRIDX_REVERSE 311 /* 'reverse' */ +#define DUK_STRIDX_PUSH 312 /* 'push' */ +#define DUK_STRIDX_POP 313 /* 'pop' */ +#define DUK_STRIDX_JOIN 314 /* 'join' */ +#define DUK_STRIDX_CONCAT 315 /* 'concat' */ +#define DUK_STRIDX_IS_ARRAY 316 /* 'isArray' */ +#define DUK_STRIDX_LC_ARGUMENTS 317 /* 'arguments' */ +#define DUK_STRIDX_CALLER 318 /* 'caller' */ +#define DUK_STRIDX_BIND 319 /* 'bind' */ +#define DUK_STRIDX_CALL 320 /* 'call' */ +#define DUK_STRIDX_APPLY 321 /* 'apply' */ +#define DUK_STRIDX_PROPERTY_IS_ENUMERABLE 322 /* 'propertyIsEnumerable' */ +#define DUK_STRIDX_IS_PROTOTYPE_OF 323 /* 'isPrototypeOf' */ +#define DUK_STRIDX_HAS_OWN_PROPERTY 324 /* 'hasOwnProperty' */ +#define DUK_STRIDX_VALUE_OF 325 /* 'valueOf' */ +#define DUK_STRIDX_TO_LOCALE_STRING 326 /* 'toLocaleString' */ +#define DUK_STRIDX_TO_STRING 327 /* 'toString' */ +#define DUK_STRIDX_CONSTRUCTOR 328 /* 'constructor' */ +#define DUK_STRIDX_SET 329 /* 'set' */ +#define DUK_STRIDX_GET 330 /* 'get' */ +#define DUK_STRIDX_ENUMERABLE 331 /* 'enumerable' */ +#define DUK_STRIDX_CONFIGURABLE 332 /* 'configurable' */ +#define DUK_STRIDX_WRITABLE 333 /* 'writable' */ +#define DUK_STRIDX_VALUE 334 /* 'value' */ +#define DUK_STRIDX_KEYS 335 /* 'keys' */ +#define DUK_STRIDX_IS_EXTENSIBLE 336 /* 'isExtensible' */ +#define DUK_STRIDX_IS_FROZEN 337 /* 'isFrozen' */ +#define DUK_STRIDX_IS_SEALED 338 /* 'isSealed' */ +#define DUK_STRIDX_PREVENT_EXTENSIONS 339 /* 'preventExtensions' */ +#define DUK_STRIDX_FREEZE 340 /* 'freeze' */ +#define DUK_STRIDX_SEAL 341 /* 'seal' */ +#define DUK_STRIDX_DEFINE_PROPERTIES 342 /* 'defineProperties' */ +#define DUK_STRIDX_DEFINE_PROPERTY 343 /* 'defineProperty' */ +#define DUK_STRIDX_CREATE 344 /* 'create' */ +#define DUK_STRIDX_GET_OWN_PROPERTY_NAMES 345 /* 'getOwnPropertyNames' */ +#define DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR 346 /* 'getOwnPropertyDescriptor' */ +#define DUK_STRIDX_GET_PROTOTYPE_OF 347 /* 'getPrototypeOf' */ +#define DUK_STRIDX_PROTOTYPE 348 /* 'prototype' */ +#define DUK_STRIDX_LENGTH 349 /* 'length' */ +#define DUK_STRIDX_ALERT 350 /* 'alert' */ +#define DUK_STRIDX_PRINT 351 /* 'print' */ +#define DUK_STRIDX_UNESCAPE 352 /* 'unescape' */ +#define DUK_STRIDX_ESCAPE 353 /* 'escape' */ +#define DUK_STRIDX_ENCODE_URI_COMPONENT 354 /* 'encodeURIComponent' */ +#define DUK_STRIDX_ENCODE_URI 355 /* 'encodeURI' */ +#define DUK_STRIDX_DECODE_URI_COMPONENT 356 /* 'decodeURIComponent' */ +#define DUK_STRIDX_DECODE_URI 357 /* 'decodeURI' */ +#define DUK_STRIDX_IS_FINITE 358 /* 'isFinite' */ +#define DUK_STRIDX_IS_NAN 359 /* 'isNaN' */ +#define DUK_STRIDX_PARSE_FLOAT 360 /* 'parseFloat' */ +#define DUK_STRIDX_PARSE_INT 361 /* 'parseInt' */ +#define DUK_STRIDX_EVAL 362 /* 'eval' */ +#define DUK_STRIDX_URI_ERROR 363 /* 'URIError' */ +#define DUK_STRIDX_TYPE_ERROR 364 /* 'TypeError' */ +#define DUK_STRIDX_SYNTAX_ERROR 365 /* 'SyntaxError' */ +#define DUK_STRIDX_REFERENCE_ERROR 366 /* 'ReferenceError' */ +#define DUK_STRIDX_RANGE_ERROR 367 /* 'RangeError' */ +#define DUK_STRIDX_EVAL_ERROR 368 /* 'EvalError' */ +#define DUK_STRIDX_BREAK 369 /* 'break' */ +#define DUK_STRIDX_CASE 370 /* 'case' */ +#define DUK_STRIDX_CATCH 371 /* 'catch' */ +#define DUK_STRIDX_CONTINUE 372 /* 'continue' */ +#define DUK_STRIDX_DEBUGGER 373 /* 'debugger' */ +#define DUK_STRIDX_DEFAULT 374 /* 'default' */ +#define DUK_STRIDX_DELETE 375 /* 'delete' */ +#define DUK_STRIDX_DO 376 /* 'do' */ +#define DUK_STRIDX_ELSE 377 /* 'else' */ +#define DUK_STRIDX_FINALLY 378 /* 'finally' */ +#define DUK_STRIDX_FOR 379 /* 'for' */ +#define DUK_STRIDX_LC_FUNCTION 380 /* 'function' */ +#define DUK_STRIDX_IF 381 /* 'if' */ +#define DUK_STRIDX_IN 382 /* 'in' */ +#define DUK_STRIDX_INSTANCEOF 383 /* 'instanceof' */ +#define DUK_STRIDX_NEW 384 /* 'new' */ +#define DUK_STRIDX_RETURN 385 /* 'return' */ +#define DUK_STRIDX_SWITCH 386 /* 'switch' */ +#define DUK_STRIDX_THIS 387 /* 'this' */ +#define DUK_STRIDX_THROW 388 /* 'throw' */ +#define DUK_STRIDX_TRY 389 /* 'try' */ +#define DUK_STRIDX_TYPEOF 390 /* 'typeof' */ +#define DUK_STRIDX_VAR 391 /* 'var' */ +#define DUK_STRIDX_CONST 392 /* 'const' */ +#define DUK_STRIDX_VOID 393 /* 'void' */ +#define DUK_STRIDX_WHILE 394 /* 'while' */ +#define DUK_STRIDX_WITH 395 /* 'with' */ +#define DUK_STRIDX_CLASS 396 /* 'class' */ +#define DUK_STRIDX_ENUM 397 /* 'enum' */ +#define DUK_STRIDX_EXPORT 398 /* 'export' */ +#define DUK_STRIDX_EXTENDS 399 /* 'extends' */ +#define DUK_STRIDX_IMPORT 400 /* 'import' */ +#define DUK_STRIDX_SUPER 401 /* 'super' */ +#define DUK_STRIDX_LC_NULL 402 /* 'null' */ +#define DUK_STRIDX_TRUE 403 /* 'true' */ +#define DUK_STRIDX_FALSE 404 /* 'false' */ +#define DUK_STRIDX_IMPLEMENTS 405 /* 'implements' */ +#define DUK_STRIDX_INTERFACE 406 /* 'interface' */ +#define DUK_STRIDX_LET 407 /* 'let' */ +#define DUK_STRIDX_PACKAGE 408 /* 'package' */ +#define DUK_STRIDX_PRIVATE 409 /* 'private' */ +#define DUK_STRIDX_PROTECTED 410 /* 'protected' */ +#define DUK_STRIDX_PUBLIC 411 /* 'public' */ +#define DUK_STRIDX_STATIC 412 /* 'static' */ +#define DUK_STRIDX_YIELD 413 /* 'yield' */ #define DUK_HEAP_STRING_UC_LOGGER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_LOGGER) #define DUK_HTHREAD_STRING_UC_LOGGER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_LOGGER) @@ -661,12 +793,34 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; #define DUK_HTHREAD_STRING_UC_THREAD(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_THREAD) #define DUK_HEAP_STRING_UC_POINTER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_POINTER) #define DUK_HTHREAD_STRING_UC_POINTER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_POINTER) -#define DUK_HEAP_STRING_UC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BUFFER) -#define DUK_HTHREAD_STRING_UC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BUFFER) #define DUK_HEAP_STRING_DEC_ENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC_ENV) #define DUK_HTHREAD_STRING_DEC_ENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC_ENV) #define DUK_HEAP_STRING_OBJ_ENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OBJ_ENV) #define DUK_HTHREAD_STRING_OBJ_ENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OBJ_ENV) +#define DUK_HEAP_STRING_FLOAT64_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOAT64_ARRAY) +#define DUK_HTHREAD_STRING_FLOAT64_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOAT64_ARRAY) +#define DUK_HEAP_STRING_FLOAT32_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOAT32_ARRAY) +#define DUK_HTHREAD_STRING_FLOAT32_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOAT32_ARRAY) +#define DUK_HEAP_STRING_UINT32_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT32_ARRAY) +#define DUK_HTHREAD_STRING_UINT32_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT32_ARRAY) +#define DUK_HEAP_STRING_INT32_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT32_ARRAY) +#define DUK_HTHREAD_STRING_INT32_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT32_ARRAY) +#define DUK_HEAP_STRING_UINT16_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT16_ARRAY) +#define DUK_HTHREAD_STRING_UINT16_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT16_ARRAY) +#define DUK_HEAP_STRING_INT16_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT16_ARRAY) +#define DUK_HTHREAD_STRING_INT16_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT16_ARRAY) +#define DUK_HEAP_STRING_UINT8_CLAMPED_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT8_CLAMPED_ARRAY) +#define DUK_HTHREAD_STRING_UINT8_CLAMPED_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT8_CLAMPED_ARRAY) +#define DUK_HEAP_STRING_UINT8_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT8_ARRAY) +#define DUK_HTHREAD_STRING_UINT8_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT8_ARRAY) +#define DUK_HEAP_STRING_INT8_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT8_ARRAY) +#define DUK_HTHREAD_STRING_INT8_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT8_ARRAY) +#define DUK_HEAP_STRING_DATA_VIEW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATA_VIEW) +#define DUK_HTHREAD_STRING_DATA_VIEW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATA_VIEW) +#define DUK_HEAP_STRING_ARRAY_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY_BUFFER) +#define DUK_HTHREAD_STRING_ARRAY_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY_BUFFER) +#define DUK_HEAP_STRING_UC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BUFFER) +#define DUK_HTHREAD_STRING_UC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BUFFER) #define DUK_HEAP_STRING_EMPTY_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EMPTY_STRING) #define DUK_HTHREAD_STRING_EMPTY_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EMPTY_STRING) #define DUK_HEAP_STRING_GLOBAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GLOBAL) @@ -811,8 +965,6 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; #define DUK_HTHREAD_STRING_INT_VALUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VALUE) #define DUK_HEAP_STRING_LC_POINTER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_POINTER) #define DUK_HTHREAD_STRING_LC_POINTER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_POINTER) -#define DUK_HEAP_STRING_LC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BUFFER) -#define DUK_HTHREAD_STRING_LC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BUFFER) #define DUK_HEAP_STRING_INT_TRACEDATA(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TRACEDATA) #define DUK_HTHREAD_STRING_INT_TRACEDATA(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TRACEDATA) #define DUK_HEAP_STRING_LINE_NUMBER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LINE_NUMBER) @@ -827,6 +979,142 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; #define DUK_HTHREAD_STRING_THROW_TYPE_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW_TYPE_ERROR) #define DUK_HEAP_STRING_DUKTAPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DUKTAPE) #define DUK_HTHREAD_STRING_DUKTAPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DUKTAPE) +#define DUK_HEAP_STRING_SET_FLOAT64(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FLOAT64) +#define DUK_HTHREAD_STRING_SET_FLOAT64(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FLOAT64) +#define DUK_HEAP_STRING_SET_FLOAT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FLOAT32) +#define DUK_HTHREAD_STRING_SET_FLOAT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FLOAT32) +#define DUK_HEAP_STRING_SET_UINT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UINT32) +#define DUK_HTHREAD_STRING_SET_UINT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UINT32) +#define DUK_HEAP_STRING_SET_INT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_INT32) +#define DUK_HTHREAD_STRING_SET_INT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_INT32) +#define DUK_HEAP_STRING_SET_UINT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UINT16) +#define DUK_HTHREAD_STRING_SET_UINT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UINT16) +#define DUK_HEAP_STRING_SET_INT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_INT16) +#define DUK_HTHREAD_STRING_SET_INT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_INT16) +#define DUK_HEAP_STRING_SET_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UINT8) +#define DUK_HTHREAD_STRING_SET_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UINT8) +#define DUK_HEAP_STRING_SET_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_INT8) +#define DUK_HTHREAD_STRING_SET_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_INT8) +#define DUK_HEAP_STRING_GET_FLOAT64(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FLOAT64) +#define DUK_HTHREAD_STRING_GET_FLOAT64(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FLOAT64) +#define DUK_HEAP_STRING_GET_FLOAT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FLOAT32) +#define DUK_HTHREAD_STRING_GET_FLOAT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FLOAT32) +#define DUK_HEAP_STRING_GET_UINT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UINT32) +#define DUK_HTHREAD_STRING_GET_UINT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UINT32) +#define DUK_HEAP_STRING_GET_INT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_INT32) +#define DUK_HTHREAD_STRING_GET_INT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_INT32) +#define DUK_HEAP_STRING_GET_UINT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UINT16) +#define DUK_HTHREAD_STRING_GET_UINT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UINT16) +#define DUK_HEAP_STRING_GET_INT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_INT16) +#define DUK_HTHREAD_STRING_GET_INT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_INT16) +#define DUK_HEAP_STRING_GET_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UINT8) +#define DUK_HTHREAD_STRING_GET_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UINT8) +#define DUK_HEAP_STRING_GET_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_INT8) +#define DUK_HTHREAD_STRING_GET_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_INT8) +#define DUK_HEAP_STRING_SUBARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBARRAY) +#define DUK_HTHREAD_STRING_SUBARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBARRAY) +#define DUK_HEAP_STRING_BYTES_PER_ELEMENT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTES_PER_ELEMENT) +#define DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTES_PER_ELEMENT) +#define DUK_HEAP_STRING_BYTE_OFFSET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTE_OFFSET) +#define DUK_HTHREAD_STRING_BYTE_OFFSET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTE_OFFSET) +#define DUK_HEAP_STRING_LC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BUFFER) +#define DUK_HTHREAD_STRING_LC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BUFFER) +#define DUK_HEAP_STRING_IS_VIEW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_VIEW) +#define DUK_HTHREAD_STRING_IS_VIEW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_VIEW) +#define DUK_HEAP_STRING_DATA(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATA) +#define DUK_HTHREAD_STRING_DATA(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATA) +#define DUK_HEAP_STRING_TYPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPE) +#define DUK_HTHREAD_STRING_TYPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPE) +#define DUK_HEAP_STRING_WRITE_INT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT_BE) +#define DUK_HTHREAD_STRING_WRITE_INT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT_BE) +#define DUK_HEAP_STRING_WRITE_INT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT_LE) +#define DUK_HTHREAD_STRING_WRITE_INT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT_LE) +#define DUK_HEAP_STRING_WRITE_UINT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT_BE) +#define DUK_HTHREAD_STRING_WRITE_UINT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT_BE) +#define DUK_HEAP_STRING_WRITE_UINT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT_LE) +#define DUK_HTHREAD_STRING_WRITE_UINT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT_LE) +#define DUK_HEAP_STRING_WRITE_DOUBLE_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_DOUBLE_BE) +#define DUK_HTHREAD_STRING_WRITE_DOUBLE_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_DOUBLE_BE) +#define DUK_HEAP_STRING_WRITE_DOUBLE_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_DOUBLE_LE) +#define DUK_HTHREAD_STRING_WRITE_DOUBLE_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_DOUBLE_LE) +#define DUK_HEAP_STRING_WRITE_FLOAT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_FLOAT_BE) +#define DUK_HTHREAD_STRING_WRITE_FLOAT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_FLOAT_BE) +#define DUK_HEAP_STRING_WRITE_FLOAT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_FLOAT_LE) +#define DUK_HTHREAD_STRING_WRITE_FLOAT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_FLOAT_LE) +#define DUK_HEAP_STRING_WRITE_INT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT32_BE) +#define DUK_HTHREAD_STRING_WRITE_INT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT32_BE) +#define DUK_HEAP_STRING_WRITE_INT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT32_LE) +#define DUK_HTHREAD_STRING_WRITE_INT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT32_LE) +#define DUK_HEAP_STRING_WRITE_UINT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT32_BE) +#define DUK_HTHREAD_STRING_WRITE_UINT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT32_BE) +#define DUK_HEAP_STRING_WRITE_UINT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT32_LE) +#define DUK_HTHREAD_STRING_WRITE_UINT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT32_LE) +#define DUK_HEAP_STRING_WRITE_INT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT16_BE) +#define DUK_HTHREAD_STRING_WRITE_INT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT16_BE) +#define DUK_HEAP_STRING_WRITE_INT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT16_LE) +#define DUK_HTHREAD_STRING_WRITE_INT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT16_LE) +#define DUK_HEAP_STRING_WRITE_UINT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT16_BE) +#define DUK_HTHREAD_STRING_WRITE_UINT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT16_BE) +#define DUK_HEAP_STRING_WRITE_UINT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT16_LE) +#define DUK_HTHREAD_STRING_WRITE_UINT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT16_LE) +#define DUK_HEAP_STRING_WRITE_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT8) +#define DUK_HTHREAD_STRING_WRITE_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT8) +#define DUK_HEAP_STRING_WRITE_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT8) +#define DUK_HTHREAD_STRING_WRITE_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT8) +#define DUK_HEAP_STRING_READ_INT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT_BE) +#define DUK_HTHREAD_STRING_READ_INT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT_BE) +#define DUK_HEAP_STRING_READ_INT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT_LE) +#define DUK_HTHREAD_STRING_READ_INT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT_LE) +#define DUK_HEAP_STRING_READ_UINT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT_BE) +#define DUK_HTHREAD_STRING_READ_UINT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT_BE) +#define DUK_HEAP_STRING_READ_UINT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT_LE) +#define DUK_HTHREAD_STRING_READ_UINT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT_LE) +#define DUK_HEAP_STRING_READ_DOUBLE_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_DOUBLE_BE) +#define DUK_HTHREAD_STRING_READ_DOUBLE_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_DOUBLE_BE) +#define DUK_HEAP_STRING_READ_DOUBLE_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_DOUBLE_LE) +#define DUK_HTHREAD_STRING_READ_DOUBLE_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_DOUBLE_LE) +#define DUK_HEAP_STRING_READ_FLOAT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_FLOAT_BE) +#define DUK_HTHREAD_STRING_READ_FLOAT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_FLOAT_BE) +#define DUK_HEAP_STRING_READ_FLOAT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_FLOAT_LE) +#define DUK_HTHREAD_STRING_READ_FLOAT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_FLOAT_LE) +#define DUK_HEAP_STRING_READ_INT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT32_BE) +#define DUK_HTHREAD_STRING_READ_INT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT32_BE) +#define DUK_HEAP_STRING_READ_INT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT32_LE) +#define DUK_HTHREAD_STRING_READ_INT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT32_LE) +#define DUK_HEAP_STRING_READ_UINT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT32_BE) +#define DUK_HTHREAD_STRING_READ_UINT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT32_BE) +#define DUK_HEAP_STRING_READ_UINT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT32_LE) +#define DUK_HTHREAD_STRING_READ_UINT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT32_LE) +#define DUK_HEAP_STRING_READ_INT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT16_BE) +#define DUK_HTHREAD_STRING_READ_INT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT16_BE) +#define DUK_HEAP_STRING_READ_INT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT16_LE) +#define DUK_HTHREAD_STRING_READ_INT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT16_LE) +#define DUK_HEAP_STRING_READ_UINT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT16_BE) +#define DUK_HTHREAD_STRING_READ_UINT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT16_BE) +#define DUK_HEAP_STRING_READ_UINT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT16_LE) +#define DUK_HTHREAD_STRING_READ_UINT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT16_LE) +#define DUK_HEAP_STRING_READ_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT8) +#define DUK_HTHREAD_STRING_READ_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT8) +#define DUK_HEAP_STRING_READ_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT8) +#define DUK_HTHREAD_STRING_READ_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT8) +#define DUK_HEAP_STRING_COPY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COPY) +#define DUK_HTHREAD_STRING_COPY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COPY) +#define DUK_HEAP_STRING_EQUALS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EQUALS) +#define DUK_HTHREAD_STRING_EQUALS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EQUALS) +#define DUK_HEAP_STRING_FILL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILL) +#define DUK_HTHREAD_STRING_FILL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILL) +#define DUK_HEAP_STRING_WRITE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE) +#define DUK_HTHREAD_STRING_WRITE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE) +#define DUK_HEAP_STRING_COMPARE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPARE) +#define DUK_HTHREAD_STRING_COMPARE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPARE) +#define DUK_HEAP_STRING_BYTE_LENGTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTE_LENGTH) +#define DUK_HTHREAD_STRING_BYTE_LENGTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTE_LENGTH) +#define DUK_HEAP_STRING_IS_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_BUFFER) +#define DUK_HTHREAD_STRING_IS_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_BUFFER) +#define DUK_HEAP_STRING_IS_ENCODING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_ENCODING) +#define DUK_HTHREAD_STRING_IS_ENCODING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_ENCODING) +#define DUK_HEAP_STRING_EXPORTS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORTS) +#define DUK_HTHREAD_STRING_EXPORTS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORTS) #define DUK_HEAP_STRING_ID(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ID) #define DUK_HTHREAD_STRING_ID(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ID) #define DUK_HEAP_STRING_REQUIRE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REQUIRE) @@ -1283,6 +1571,8 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; #define DUK_HTHREAD_STRING_TYPEOF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPEOF) #define DUK_HEAP_STRING_VAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VAR) #define DUK_HTHREAD_STRING_VAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VAR) +#define DUK_HEAP_STRING_CONST(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONST) +#define DUK_HTHREAD_STRING_CONST(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONST) #define DUK_HEAP_STRING_VOID(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VOID) #define DUK_HTHREAD_STRING_VOID(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VOID) #define DUK_HEAP_STRING_WHILE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WHILE) @@ -1291,8 +1581,6 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; #define DUK_HTHREAD_STRING_WITH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WITH) #define DUK_HEAP_STRING_CLASS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLASS) #define DUK_HTHREAD_STRING_CLASS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLASS) -#define DUK_HEAP_STRING_CONST(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONST) -#define DUK_HTHREAD_STRING_CONST(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONST) #define DUK_HEAP_STRING_ENUM(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUM) #define DUK_HTHREAD_STRING_ENUM(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUM) #define DUK_HEAP_STRING_EXPORT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORT) @@ -1328,21 +1616,21 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; #define DUK_HEAP_STRING_YIELD(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_YIELD) #define DUK_HTHREAD_STRING_YIELD(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_YIELD) -#define DUK_HEAP_NUM_STRINGS 336 +#define DUK_HEAP_NUM_STRINGS 414 -#define DUK_STRIDX_START_RESERVED 291 -#define DUK_STRIDX_START_STRICT_RESERVED 327 -#define DUK_STRIDX_END_RESERVED 336 /* exclusive endpoint */ +#define DUK_STRIDX_START_RESERVED 369 +#define DUK_STRIDX_START_STRICT_RESERVED 405 +#define DUK_STRIDX_END_RESERVED 414 /* exclusive endpoint */ #if !defined(DUK_SINGLE_FILE) -DUK_INTERNAL_DECL const duk_c_function duk_bi_native_functions[128]; -DUK_INTERNAL_DECL const duk_uint8_t duk_builtins_data[1341]; +DUK_INTERNAL_DECL const duk_c_function duk_bi_native_functions[149]; +DUK_INTERNAL_DECL const duk_uint8_t duk_builtins_data[1955]; #ifdef DUK_USE_BUILTIN_INITJS DUK_INTERNAL_DECL const duk_uint8_t duk_initjs_data[187]; #endif /* DUK_USE_BUILTIN_INITJS */ #endif /* !DUK_SINGLE_FILE */ -#define DUK_BUILTINS_DATA_LENGTH 1341 +#define DUK_BUILTINS_DATA_LENGTH 1955 #ifdef DUK_USE_BUILTIN_INITJS #define DUK_BUILTIN_INITJS_DATA_LENGTH 187 #endif /* DUK_USE_BUILTIN_INITJS */ @@ -1393,353 +1681,456 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_initjs_data[187]; #define DUK_BIDX_LOGGER_CONSTRUCTOR 43 #define DUK_BIDX_LOGGER_PROTOTYPE 44 #define DUK_BIDX_DOUBLE_ERROR 45 +#define DUK_BIDX_ARRAYBUFFER_CONSTRUCTOR 46 +#define DUK_BIDX_ARRAYBUFFER_PROTOTYPE 47 +#define DUK_BIDX_DATAVIEW_CONSTRUCTOR 48 +#define DUK_BIDX_DATAVIEW_PROTOTYPE 49 +#define DUK_BIDX_TYPEDARRAY_PROTOTYPE 50 +#define DUK_BIDX_INT8ARRAY_CONSTRUCTOR 51 +#define DUK_BIDX_INT8ARRAY_PROTOTYPE 52 +#define DUK_BIDX_UINT8ARRAY_CONSTRUCTOR 53 +#define DUK_BIDX_UINT8ARRAY_PROTOTYPE 54 +#define DUK_BIDX_UINT8CLAMPEDARRAY_CONSTRUCTOR 55 +#define DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE 56 +#define DUK_BIDX_INT16ARRAY_CONSTRUCTOR 57 +#define DUK_BIDX_INT16ARRAY_PROTOTYPE 58 +#define DUK_BIDX_UINT16ARRAY_CONSTRUCTOR 59 +#define DUK_BIDX_UINT16ARRAY_PROTOTYPE 60 +#define DUK_BIDX_INT32ARRAY_CONSTRUCTOR 61 +#define DUK_BIDX_INT32ARRAY_PROTOTYPE 62 +#define DUK_BIDX_UINT32ARRAY_CONSTRUCTOR 63 +#define DUK_BIDX_UINT32ARRAY_PROTOTYPE 64 +#define DUK_BIDX_FLOAT32ARRAY_CONSTRUCTOR 65 +#define DUK_BIDX_FLOAT32ARRAY_PROTOTYPE 66 +#define DUK_BIDX_FLOAT64ARRAY_CONSTRUCTOR 67 +#define DUK_BIDX_FLOAT64ARRAY_PROTOTYPE 68 +#define DUK_BIDX_NODEJS_BUFFER_CONSTRUCTOR 69 +#define DUK_BIDX_NODEJS_BUFFER_PROTOTYPE 70 -#define DUK_NUM_BUILTINS 46 +#define DUK_NUM_BUILTINS 71 #elif defined(DUK_USE_DOUBLE_BE) #if !defined(DUK_SINGLE_FILE) -DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; +DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[2624]; #endif /* !DUK_SINGLE_FILE */ -#define DUK_STRDATA_DATA_LENGTH 1943 +#define DUK_STRDATA_DATA_LENGTH 2624 #define DUK_STRDATA_MAX_STRLEN 24 #define DUK_STRIDX_UC_LOGGER 0 /* 'Logger' */ #define DUK_STRIDX_UC_THREAD 1 /* 'Thread' */ #define DUK_STRIDX_UC_POINTER 2 /* 'Pointer' */ -#define DUK_STRIDX_UC_BUFFER 3 /* 'Buffer' */ -#define DUK_STRIDX_DEC_ENV 4 /* 'DecEnv' */ -#define DUK_STRIDX_OBJ_ENV 5 /* 'ObjEnv' */ -#define DUK_STRIDX_EMPTY_STRING 6 /* '' */ -#define DUK_STRIDX_GLOBAL 7 /* 'global' */ -#define DUK_STRIDX_UC_ARGUMENTS 8 /* 'Arguments' */ -#define DUK_STRIDX_JSON 9 /* 'JSON' */ -#define DUK_STRIDX_MATH 10 /* 'Math' */ -#define DUK_STRIDX_UC_ERROR 11 /* 'Error' */ -#define DUK_STRIDX_REG_EXP 12 /* 'RegExp' */ -#define DUK_STRIDX_DATE 13 /* 'Date' */ -#define DUK_STRIDX_UC_NUMBER 14 /* 'Number' */ -#define DUK_STRIDX_UC_BOOLEAN 15 /* 'Boolean' */ -#define DUK_STRIDX_UC_STRING 16 /* 'String' */ -#define DUK_STRIDX_ARRAY 17 /* 'Array' */ -#define DUK_STRIDX_UC_FUNCTION 18 /* 'Function' */ -#define DUK_STRIDX_UC_OBJECT 19 /* 'Object' */ -#define DUK_STRIDX_UC_NULL 20 /* 'Null' */ -#define DUK_STRIDX_UC_UNDEFINED 21 /* 'Undefined' */ -#define DUK_STRIDX_JSON_EXT_FUNCTION2 22 /* '{_func:true}' */ -#define DUK_STRIDX_JSON_EXT_FUNCTION1 23 /* '{"_func":true}' */ -#define DUK_STRIDX_JSON_EXT_NEGINF 24 /* '{"_ninf":true}' */ -#define DUK_STRIDX_JSON_EXT_POSINF 25 /* '{"_inf":true}' */ -#define DUK_STRIDX_JSON_EXT_NAN 26 /* '{"_nan":true}' */ -#define DUK_STRIDX_JSON_EXT_UNDEFINED 27 /* '{"_undef":true}' */ -#define DUK_STRIDX_TO_LOG_STRING 28 /* 'toLogString' */ -#define DUK_STRIDX_CLOG 29 /* 'clog' */ -#define DUK_STRIDX_LC_L 30 /* 'l' */ -#define DUK_STRIDX_LC_N 31 /* 'n' */ -#define DUK_STRIDX_LC_FATAL 32 /* 'fatal' */ -#define DUK_STRIDX_LC_ERROR 33 /* 'error' */ -#define DUK_STRIDX_LC_WARN 34 /* 'warn' */ -#define DUK_STRIDX_LC_DEBUG 35 /* 'debug' */ -#define DUK_STRIDX_LC_TRACE 36 /* 'trace' */ -#define DUK_STRIDX_RAW 37 /* 'raw' */ -#define DUK_STRIDX_FMT 38 /* 'fmt' */ -#define DUK_STRIDX_CURRENT 39 /* 'current' */ -#define DUK_STRIDX_RESUME 40 /* 'resume' */ -#define DUK_STRIDX_COMPACT 41 /* 'compact' */ -#define DUK_STRIDX_JC 42 /* 'jc' */ -#define DUK_STRIDX_JX 43 /* 'jx' */ -#define DUK_STRIDX_BASE64 44 /* 'base64' */ -#define DUK_STRIDX_HEX 45 /* 'hex' */ -#define DUK_STRIDX_DEC 46 /* 'dec' */ -#define DUK_STRIDX_ENC 47 /* 'enc' */ -#define DUK_STRIDX_FIN 48 /* 'fin' */ -#define DUK_STRIDX_GC 49 /* 'gc' */ -#define DUK_STRIDX_ACT 50 /* 'act' */ -#define DUK_STRIDX_LC_INFO 51 /* 'info' */ -#define DUK_STRIDX_VERSION 52 /* 'version' */ -#define DUK_STRIDX_ENV 53 /* 'env' */ -#define DUK_STRIDX_MOD_LOADED 54 /* 'modLoaded' */ -#define DUK_STRIDX_MOD_SEARCH 55 /* 'modSearch' */ -#define DUK_STRIDX_ERR_THROW 56 /* 'errThrow' */ -#define DUK_STRIDX_ERR_CREATE 57 /* 'errCreate' */ -#define DUK_STRIDX_COMPILE 58 /* 'compile' */ -#define DUK_STRIDX_INT_REGBASE 59 /* '\x00Regbase' */ -#define DUK_STRIDX_INT_THREAD 60 /* '\x00Thread' */ -#define DUK_STRIDX_INT_HANDLER 61 /* '\x00Handler' */ -#define DUK_STRIDX_INT_FINALIZER 62 /* '\x00Finalizer' */ -#define DUK_STRIDX_INT_CALLEE 63 /* '\x00Callee' */ -#define DUK_STRIDX_INT_MAP 64 /* '\x00Map' */ -#define DUK_STRIDX_INT_ARGS 65 /* '\x00Args' */ -#define DUK_STRIDX_INT_THIS 66 /* '\x00This' */ -#define DUK_STRIDX_INT_PC2LINE 67 /* '\x00Pc2line' */ -#define DUK_STRIDX_INT_SOURCE 68 /* '\x00Source' */ -#define DUK_STRIDX_INT_VARENV 69 /* '\x00Varenv' */ -#define DUK_STRIDX_INT_LEXENV 70 /* '\x00Lexenv' */ -#define DUK_STRIDX_INT_VARMAP 71 /* '\x00Varmap' */ -#define DUK_STRIDX_INT_FORMALS 72 /* '\x00Formals' */ -#define DUK_STRIDX_INT_BYTECODE 73 /* '\x00Bytecode' */ -#define DUK_STRIDX_INT_NEXT 74 /* '\x00Next' */ -#define DUK_STRIDX_INT_TARGET 75 /* '\x00Target' */ -#define DUK_STRIDX_INT_VALUE 76 /* '\x00Value' */ -#define DUK_STRIDX_LC_POINTER 77 /* 'pointer' */ -#define DUK_STRIDX_LC_BUFFER 78 /* 'buffer' */ -#define DUK_STRIDX_INT_TRACEDATA 79 /* '\x00Tracedata' */ -#define DUK_STRIDX_LINE_NUMBER 80 /* 'lineNumber' */ -#define DUK_STRIDX_FILE_NAME 81 /* 'fileName' */ -#define DUK_STRIDX_PC 82 /* 'pc' */ -#define DUK_STRIDX_STACK 83 /* 'stack' */ -#define DUK_STRIDX_THROW_TYPE_ERROR 84 /* 'ThrowTypeError' */ -#define DUK_STRIDX_DUKTAPE 85 /* 'Duktape' */ -#define DUK_STRIDX_ID 86 /* 'id' */ -#define DUK_STRIDX_REQUIRE 87 /* 'require' */ -#define DUK_STRIDX___PROTO__ 88 /* '__proto__' */ -#define DUK_STRIDX_SET_PROTOTYPE_OF 89 /* 'setPrototypeOf' */ -#define DUK_STRIDX_OWN_KEYS 90 /* 'ownKeys' */ -#define DUK_STRIDX_ENUMERATE 91 /* 'enumerate' */ -#define DUK_STRIDX_DELETE_PROPERTY 92 /* 'deleteProperty' */ -#define DUK_STRIDX_HAS 93 /* 'has' */ -#define DUK_STRIDX_PROXY 94 /* 'Proxy' */ -#define DUK_STRIDX_CALLEE 95 /* 'callee' */ -#define DUK_STRIDX_INVALID_DATE 96 /* 'Invalid Date' */ -#define DUK_STRIDX_BRACKETED_ELLIPSIS 97 /* '[...]' */ -#define DUK_STRIDX_NEWLINE_TAB 98 /* '\n\t' */ -#define DUK_STRIDX_SPACE 99 /* ' ' */ -#define DUK_STRIDX_COMMA 100 /* ',' */ -#define DUK_STRIDX_MINUS_ZERO 101 /* '-0' */ -#define DUK_STRIDX_PLUS_ZERO 102 /* '+0' */ -#define DUK_STRIDX_ZERO 103 /* '0' */ -#define DUK_STRIDX_MINUS_INFINITY 104 /* '-Infinity' */ -#define DUK_STRIDX_PLUS_INFINITY 105 /* '+Infinity' */ -#define DUK_STRIDX_INFINITY 106 /* 'Infinity' */ -#define DUK_STRIDX_LC_OBJECT 107 /* 'object' */ -#define DUK_STRIDX_LC_STRING 108 /* 'string' */ -#define DUK_STRIDX_LC_NUMBER 109 /* 'number' */ -#define DUK_STRIDX_LC_BOOLEAN 110 /* 'boolean' */ -#define DUK_STRIDX_LC_UNDEFINED 111 /* 'undefined' */ -#define DUK_STRIDX_STRINGIFY 112 /* 'stringify' */ -#define DUK_STRIDX_TAN 113 /* 'tan' */ -#define DUK_STRIDX_SQRT 114 /* 'sqrt' */ -#define DUK_STRIDX_SIN 115 /* 'sin' */ -#define DUK_STRIDX_ROUND 116 /* 'round' */ -#define DUK_STRIDX_RANDOM 117 /* 'random' */ -#define DUK_STRIDX_POW 118 /* 'pow' */ -#define DUK_STRIDX_MIN 119 /* 'min' */ -#define DUK_STRIDX_MAX 120 /* 'max' */ -#define DUK_STRIDX_LOG 121 /* 'log' */ -#define DUK_STRIDX_FLOOR 122 /* 'floor' */ -#define DUK_STRIDX_EXP 123 /* 'exp' */ -#define DUK_STRIDX_COS 124 /* 'cos' */ -#define DUK_STRIDX_CEIL 125 /* 'ceil' */ -#define DUK_STRIDX_ATAN2 126 /* 'atan2' */ -#define DUK_STRIDX_ATAN 127 /* 'atan' */ -#define DUK_STRIDX_ASIN 128 /* 'asin' */ -#define DUK_STRIDX_ACOS 129 /* 'acos' */ -#define DUK_STRIDX_ABS 130 /* 'abs' */ -#define DUK_STRIDX_SQRT2 131 /* 'SQRT2' */ -#define DUK_STRIDX_SQRT1_2 132 /* 'SQRT1_2' */ -#define DUK_STRIDX_PI 133 /* 'PI' */ -#define DUK_STRIDX_LOG10E 134 /* 'LOG10E' */ -#define DUK_STRIDX_LOG2E 135 /* 'LOG2E' */ -#define DUK_STRIDX_LN2 136 /* 'LN2' */ -#define DUK_STRIDX_LN10 137 /* 'LN10' */ -#define DUK_STRIDX_E 138 /* 'E' */ -#define DUK_STRIDX_MESSAGE 139 /* 'message' */ -#define DUK_STRIDX_NAME 140 /* 'name' */ -#define DUK_STRIDX_INPUT 141 /* 'input' */ -#define DUK_STRIDX_INDEX 142 /* 'index' */ -#define DUK_STRIDX_ESCAPED_EMPTY_REGEXP 143 /* '(?:)' */ -#define DUK_STRIDX_LAST_INDEX 144 /* 'lastIndex' */ -#define DUK_STRIDX_MULTILINE 145 /* 'multiline' */ -#define DUK_STRIDX_IGNORE_CASE 146 /* 'ignoreCase' */ -#define DUK_STRIDX_SOURCE 147 /* 'source' */ -#define DUK_STRIDX_TEST 148 /* 'test' */ -#define DUK_STRIDX_EXEC 149 /* 'exec' */ -#define DUK_STRIDX_TO_GMT_STRING 150 /* 'toGMTString' */ -#define DUK_STRIDX_SET_YEAR 151 /* 'setYear' */ -#define DUK_STRIDX_GET_YEAR 152 /* 'getYear' */ -#define DUK_STRIDX_TO_JSON 153 /* 'toJSON' */ -#define DUK_STRIDX_TO_ISO_STRING 154 /* 'toISOString' */ -#define DUK_STRIDX_TO_UTC_STRING 155 /* 'toUTCString' */ -#define DUK_STRIDX_SET_UTC_FULL_YEAR 156 /* 'setUTCFullYear' */ -#define DUK_STRIDX_SET_FULL_YEAR 157 /* 'setFullYear' */ -#define DUK_STRIDX_SET_UTC_MONTH 158 /* 'setUTCMonth' */ -#define DUK_STRIDX_SET_MONTH 159 /* 'setMonth' */ -#define DUK_STRIDX_SET_UTC_DATE 160 /* 'setUTCDate' */ -#define DUK_STRIDX_SET_DATE 161 /* 'setDate' */ -#define DUK_STRIDX_SET_UTC_HOURS 162 /* 'setUTCHours' */ -#define DUK_STRIDX_SET_HOURS 163 /* 'setHours' */ -#define DUK_STRIDX_SET_UTC_MINUTES 164 /* 'setUTCMinutes' */ -#define DUK_STRIDX_SET_MINUTES 165 /* 'setMinutes' */ -#define DUK_STRIDX_SET_UTC_SECONDS 166 /* 'setUTCSeconds' */ -#define DUK_STRIDX_SET_SECONDS 167 /* 'setSeconds' */ -#define DUK_STRIDX_SET_UTC_MILLISECONDS 168 /* 'setUTCMilliseconds' */ -#define DUK_STRIDX_SET_MILLISECONDS 169 /* 'setMilliseconds' */ -#define DUK_STRIDX_SET_TIME 170 /* 'setTime' */ -#define DUK_STRIDX_GET_TIMEZONE_OFFSET 171 /* 'getTimezoneOffset' */ -#define DUK_STRIDX_GET_UTC_MILLISECONDS 172 /* 'getUTCMilliseconds' */ -#define DUK_STRIDX_GET_MILLISECONDS 173 /* 'getMilliseconds' */ -#define DUK_STRIDX_GET_UTC_SECONDS 174 /* 'getUTCSeconds' */ -#define DUK_STRIDX_GET_SECONDS 175 /* 'getSeconds' */ -#define DUK_STRIDX_GET_UTC_MINUTES 176 /* 'getUTCMinutes' */ -#define DUK_STRIDX_GET_MINUTES 177 /* 'getMinutes' */ -#define DUK_STRIDX_GET_UTC_HOURS 178 /* 'getUTCHours' */ -#define DUK_STRIDX_GET_HOURS 179 /* 'getHours' */ -#define DUK_STRIDX_GET_UTC_DAY 180 /* 'getUTCDay' */ -#define DUK_STRIDX_GET_DAY 181 /* 'getDay' */ -#define DUK_STRIDX_GET_UTC_DATE 182 /* 'getUTCDate' */ -#define DUK_STRIDX_GET_DATE 183 /* 'getDate' */ -#define DUK_STRIDX_GET_UTC_MONTH 184 /* 'getUTCMonth' */ -#define DUK_STRIDX_GET_MONTH 185 /* 'getMonth' */ -#define DUK_STRIDX_GET_UTC_FULL_YEAR 186 /* 'getUTCFullYear' */ -#define DUK_STRIDX_GET_FULL_YEAR 187 /* 'getFullYear' */ -#define DUK_STRIDX_GET_TIME 188 /* 'getTime' */ -#define DUK_STRIDX_TO_LOCALE_TIME_STRING 189 /* 'toLocaleTimeString' */ -#define DUK_STRIDX_TO_LOCALE_DATE_STRING 190 /* 'toLocaleDateString' */ -#define DUK_STRIDX_TO_TIME_STRING 191 /* 'toTimeString' */ -#define DUK_STRIDX_TO_DATE_STRING 192 /* 'toDateString' */ -#define DUK_STRIDX_NOW 193 /* 'now' */ -#define DUK_STRIDX_UTC 194 /* 'UTC' */ -#define DUK_STRIDX_PARSE 195 /* 'parse' */ -#define DUK_STRIDX_TO_PRECISION 196 /* 'toPrecision' */ -#define DUK_STRIDX_TO_EXPONENTIAL 197 /* 'toExponential' */ -#define DUK_STRIDX_TO_FIXED 198 /* 'toFixed' */ -#define DUK_STRIDX_POSITIVE_INFINITY 199 /* 'POSITIVE_INFINITY' */ -#define DUK_STRIDX_NEGATIVE_INFINITY 200 /* 'NEGATIVE_INFINITY' */ -#define DUK_STRIDX_NAN 201 /* 'NaN' */ -#define DUK_STRIDX_MIN_VALUE 202 /* 'MIN_VALUE' */ -#define DUK_STRIDX_MAX_VALUE 203 /* 'MAX_VALUE' */ -#define DUK_STRIDX_SUBSTR 204 /* 'substr' */ -#define DUK_STRIDX_TRIM 205 /* 'trim' */ -#define DUK_STRIDX_TO_LOCALE_UPPER_CASE 206 /* 'toLocaleUpperCase' */ -#define DUK_STRIDX_TO_UPPER_CASE 207 /* 'toUpperCase' */ -#define DUK_STRIDX_TO_LOCALE_LOWER_CASE 208 /* 'toLocaleLowerCase' */ -#define DUK_STRIDX_TO_LOWER_CASE 209 /* 'toLowerCase' */ -#define DUK_STRIDX_SUBSTRING 210 /* 'substring' */ -#define DUK_STRIDX_SPLIT 211 /* 'split' */ -#define DUK_STRIDX_SEARCH 212 /* 'search' */ -#define DUK_STRIDX_REPLACE 213 /* 'replace' */ -#define DUK_STRIDX_MATCH 214 /* 'match' */ -#define DUK_STRIDX_LOCALE_COMPARE 215 /* 'localeCompare' */ -#define DUK_STRIDX_CHAR_CODE_AT 216 /* 'charCodeAt' */ -#define DUK_STRIDX_CHAR_AT 217 /* 'charAt' */ -#define DUK_STRIDX_FROM_CHAR_CODE 218 /* 'fromCharCode' */ -#define DUK_STRIDX_REDUCE_RIGHT 219 /* 'reduceRight' */ -#define DUK_STRIDX_REDUCE 220 /* 'reduce' */ -#define DUK_STRIDX_FILTER 221 /* 'filter' */ -#define DUK_STRIDX_MAP 222 /* 'map' */ -#define DUK_STRIDX_FOR_EACH 223 /* 'forEach' */ -#define DUK_STRIDX_SOME 224 /* 'some' */ -#define DUK_STRIDX_EVERY 225 /* 'every' */ -#define DUK_STRIDX_LAST_INDEX_OF 226 /* 'lastIndexOf' */ -#define DUK_STRIDX_INDEX_OF 227 /* 'indexOf' */ -#define DUK_STRIDX_UNSHIFT 228 /* 'unshift' */ -#define DUK_STRIDX_SPLICE 229 /* 'splice' */ -#define DUK_STRIDX_SORT 230 /* 'sort' */ -#define DUK_STRIDX_SLICE 231 /* 'slice' */ -#define DUK_STRIDX_SHIFT 232 /* 'shift' */ -#define DUK_STRIDX_REVERSE 233 /* 'reverse' */ -#define DUK_STRIDX_PUSH 234 /* 'push' */ -#define DUK_STRIDX_POP 235 /* 'pop' */ -#define DUK_STRIDX_JOIN 236 /* 'join' */ -#define DUK_STRIDX_CONCAT 237 /* 'concat' */ -#define DUK_STRIDX_IS_ARRAY 238 /* 'isArray' */ -#define DUK_STRIDX_LC_ARGUMENTS 239 /* 'arguments' */ -#define DUK_STRIDX_CALLER 240 /* 'caller' */ -#define DUK_STRIDX_BIND 241 /* 'bind' */ -#define DUK_STRIDX_CALL 242 /* 'call' */ -#define DUK_STRIDX_APPLY 243 /* 'apply' */ -#define DUK_STRIDX_PROPERTY_IS_ENUMERABLE 244 /* 'propertyIsEnumerable' */ -#define DUK_STRIDX_IS_PROTOTYPE_OF 245 /* 'isPrototypeOf' */ -#define DUK_STRIDX_HAS_OWN_PROPERTY 246 /* 'hasOwnProperty' */ -#define DUK_STRIDX_VALUE_OF 247 /* 'valueOf' */ -#define DUK_STRIDX_TO_LOCALE_STRING 248 /* 'toLocaleString' */ -#define DUK_STRIDX_TO_STRING 249 /* 'toString' */ -#define DUK_STRIDX_CONSTRUCTOR 250 /* 'constructor' */ -#define DUK_STRIDX_SET 251 /* 'set' */ -#define DUK_STRIDX_GET 252 /* 'get' */ -#define DUK_STRIDX_ENUMERABLE 253 /* 'enumerable' */ -#define DUK_STRIDX_CONFIGURABLE 254 /* 'configurable' */ -#define DUK_STRIDX_WRITABLE 255 /* 'writable' */ -#define DUK_STRIDX_VALUE 256 /* 'value' */ -#define DUK_STRIDX_KEYS 257 /* 'keys' */ -#define DUK_STRIDX_IS_EXTENSIBLE 258 /* 'isExtensible' */ -#define DUK_STRIDX_IS_FROZEN 259 /* 'isFrozen' */ -#define DUK_STRIDX_IS_SEALED 260 /* 'isSealed' */ -#define DUK_STRIDX_PREVENT_EXTENSIONS 261 /* 'preventExtensions' */ -#define DUK_STRIDX_FREEZE 262 /* 'freeze' */ -#define DUK_STRIDX_SEAL 263 /* 'seal' */ -#define DUK_STRIDX_DEFINE_PROPERTIES 264 /* 'defineProperties' */ -#define DUK_STRIDX_DEFINE_PROPERTY 265 /* 'defineProperty' */ -#define DUK_STRIDX_CREATE 266 /* 'create' */ -#define DUK_STRIDX_GET_OWN_PROPERTY_NAMES 267 /* 'getOwnPropertyNames' */ -#define DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR 268 /* 'getOwnPropertyDescriptor' */ -#define DUK_STRIDX_GET_PROTOTYPE_OF 269 /* 'getPrototypeOf' */ -#define DUK_STRIDX_PROTOTYPE 270 /* 'prototype' */ -#define DUK_STRIDX_LENGTH 271 /* 'length' */ -#define DUK_STRIDX_ALERT 272 /* 'alert' */ -#define DUK_STRIDX_PRINT 273 /* 'print' */ -#define DUK_STRIDX_UNESCAPE 274 /* 'unescape' */ -#define DUK_STRIDX_ESCAPE 275 /* 'escape' */ -#define DUK_STRIDX_ENCODE_URI_COMPONENT 276 /* 'encodeURIComponent' */ -#define DUK_STRIDX_ENCODE_URI 277 /* 'encodeURI' */ -#define DUK_STRIDX_DECODE_URI_COMPONENT 278 /* 'decodeURIComponent' */ -#define DUK_STRIDX_DECODE_URI 279 /* 'decodeURI' */ -#define DUK_STRIDX_IS_FINITE 280 /* 'isFinite' */ -#define DUK_STRIDX_IS_NAN 281 /* 'isNaN' */ -#define DUK_STRIDX_PARSE_FLOAT 282 /* 'parseFloat' */ -#define DUK_STRIDX_PARSE_INT 283 /* 'parseInt' */ -#define DUK_STRIDX_EVAL 284 /* 'eval' */ -#define DUK_STRIDX_URI_ERROR 285 /* 'URIError' */ -#define DUK_STRIDX_TYPE_ERROR 286 /* 'TypeError' */ -#define DUK_STRIDX_SYNTAX_ERROR 287 /* 'SyntaxError' */ -#define DUK_STRIDX_REFERENCE_ERROR 288 /* 'ReferenceError' */ -#define DUK_STRIDX_RANGE_ERROR 289 /* 'RangeError' */ -#define DUK_STRIDX_EVAL_ERROR 290 /* 'EvalError' */ -#define DUK_STRIDX_BREAK 291 /* 'break' */ -#define DUK_STRIDX_CASE 292 /* 'case' */ -#define DUK_STRIDX_CATCH 293 /* 'catch' */ -#define DUK_STRIDX_CONTINUE 294 /* 'continue' */ -#define DUK_STRIDX_DEBUGGER 295 /* 'debugger' */ -#define DUK_STRIDX_DEFAULT 296 /* 'default' */ -#define DUK_STRIDX_DELETE 297 /* 'delete' */ -#define DUK_STRIDX_DO 298 /* 'do' */ -#define DUK_STRIDX_ELSE 299 /* 'else' */ -#define DUK_STRIDX_FINALLY 300 /* 'finally' */ -#define DUK_STRIDX_FOR 301 /* 'for' */ -#define DUK_STRIDX_LC_FUNCTION 302 /* 'function' */ -#define DUK_STRIDX_IF 303 /* 'if' */ -#define DUK_STRIDX_IN 304 /* 'in' */ -#define DUK_STRIDX_INSTANCEOF 305 /* 'instanceof' */ -#define DUK_STRIDX_NEW 306 /* 'new' */ -#define DUK_STRIDX_RETURN 307 /* 'return' */ -#define DUK_STRIDX_SWITCH 308 /* 'switch' */ -#define DUK_STRIDX_THIS 309 /* 'this' */ -#define DUK_STRIDX_THROW 310 /* 'throw' */ -#define DUK_STRIDX_TRY 311 /* 'try' */ -#define DUK_STRIDX_TYPEOF 312 /* 'typeof' */ -#define DUK_STRIDX_VAR 313 /* 'var' */ -#define DUK_STRIDX_VOID 314 /* 'void' */ -#define DUK_STRIDX_WHILE 315 /* 'while' */ -#define DUK_STRIDX_WITH 316 /* 'with' */ -#define DUK_STRIDX_CLASS 317 /* 'class' */ -#define DUK_STRIDX_CONST 318 /* 'const' */ -#define DUK_STRIDX_ENUM 319 /* 'enum' */ -#define DUK_STRIDX_EXPORT 320 /* 'export' */ -#define DUK_STRIDX_EXTENDS 321 /* 'extends' */ -#define DUK_STRIDX_IMPORT 322 /* 'import' */ -#define DUK_STRIDX_SUPER 323 /* 'super' */ -#define DUK_STRIDX_LC_NULL 324 /* 'null' */ -#define DUK_STRIDX_TRUE 325 /* 'true' */ -#define DUK_STRIDX_FALSE 326 /* 'false' */ -#define DUK_STRIDX_IMPLEMENTS 327 /* 'implements' */ -#define DUK_STRIDX_INTERFACE 328 /* 'interface' */ -#define DUK_STRIDX_LET 329 /* 'let' */ -#define DUK_STRIDX_PACKAGE 330 /* 'package' */ -#define DUK_STRIDX_PRIVATE 331 /* 'private' */ -#define DUK_STRIDX_PROTECTED 332 /* 'protected' */ -#define DUK_STRIDX_PUBLIC 333 /* 'public' */ -#define DUK_STRIDX_STATIC 334 /* 'static' */ -#define DUK_STRIDX_YIELD 335 /* 'yield' */ +#define DUK_STRIDX_DEC_ENV 3 /* 'DecEnv' */ +#define DUK_STRIDX_OBJ_ENV 4 /* 'ObjEnv' */ +#define DUK_STRIDX_FLOAT64_ARRAY 5 /* 'Float64Array' */ +#define DUK_STRIDX_FLOAT32_ARRAY 6 /* 'Float32Array' */ +#define DUK_STRIDX_UINT32_ARRAY 7 /* 'Uint32Array' */ +#define DUK_STRIDX_INT32_ARRAY 8 /* 'Int32Array' */ +#define DUK_STRIDX_UINT16_ARRAY 9 /* 'Uint16Array' */ +#define DUK_STRIDX_INT16_ARRAY 10 /* 'Int16Array' */ +#define DUK_STRIDX_UINT8_CLAMPED_ARRAY 11 /* 'Uint8ClampedArray' */ +#define DUK_STRIDX_UINT8_ARRAY 12 /* 'Uint8Array' */ +#define DUK_STRIDX_INT8_ARRAY 13 /* 'Int8Array' */ +#define DUK_STRIDX_DATA_VIEW 14 /* 'DataView' */ +#define DUK_STRIDX_ARRAY_BUFFER 15 /* 'ArrayBuffer' */ +#define DUK_STRIDX_UC_BUFFER 16 /* 'Buffer' */ +#define DUK_STRIDX_EMPTY_STRING 17 /* '' */ +#define DUK_STRIDX_GLOBAL 18 /* 'global' */ +#define DUK_STRIDX_UC_ARGUMENTS 19 /* 'Arguments' */ +#define DUK_STRIDX_JSON 20 /* 'JSON' */ +#define DUK_STRIDX_MATH 21 /* 'Math' */ +#define DUK_STRIDX_UC_ERROR 22 /* 'Error' */ +#define DUK_STRIDX_REG_EXP 23 /* 'RegExp' */ +#define DUK_STRIDX_DATE 24 /* 'Date' */ +#define DUK_STRIDX_UC_NUMBER 25 /* 'Number' */ +#define DUK_STRIDX_UC_BOOLEAN 26 /* 'Boolean' */ +#define DUK_STRIDX_UC_STRING 27 /* 'String' */ +#define DUK_STRIDX_ARRAY 28 /* 'Array' */ +#define DUK_STRIDX_UC_FUNCTION 29 /* 'Function' */ +#define DUK_STRIDX_UC_OBJECT 30 /* 'Object' */ +#define DUK_STRIDX_UC_NULL 31 /* 'Null' */ +#define DUK_STRIDX_UC_UNDEFINED 32 /* 'Undefined' */ +#define DUK_STRIDX_JSON_EXT_FUNCTION2 33 /* '{_func:true}' */ +#define DUK_STRIDX_JSON_EXT_FUNCTION1 34 /* '{"_func":true}' */ +#define DUK_STRIDX_JSON_EXT_NEGINF 35 /* '{"_ninf":true}' */ +#define DUK_STRIDX_JSON_EXT_POSINF 36 /* '{"_inf":true}' */ +#define DUK_STRIDX_JSON_EXT_NAN 37 /* '{"_nan":true}' */ +#define DUK_STRIDX_JSON_EXT_UNDEFINED 38 /* '{"_undef":true}' */ +#define DUK_STRIDX_TO_LOG_STRING 39 /* 'toLogString' */ +#define DUK_STRIDX_CLOG 40 /* 'clog' */ +#define DUK_STRIDX_LC_L 41 /* 'l' */ +#define DUK_STRIDX_LC_N 42 /* 'n' */ +#define DUK_STRIDX_LC_FATAL 43 /* 'fatal' */ +#define DUK_STRIDX_LC_ERROR 44 /* 'error' */ +#define DUK_STRIDX_LC_WARN 45 /* 'warn' */ +#define DUK_STRIDX_LC_DEBUG 46 /* 'debug' */ +#define DUK_STRIDX_LC_TRACE 47 /* 'trace' */ +#define DUK_STRIDX_RAW 48 /* 'raw' */ +#define DUK_STRIDX_FMT 49 /* 'fmt' */ +#define DUK_STRIDX_CURRENT 50 /* 'current' */ +#define DUK_STRIDX_RESUME 51 /* 'resume' */ +#define DUK_STRIDX_COMPACT 52 /* 'compact' */ +#define DUK_STRIDX_JC 53 /* 'jc' */ +#define DUK_STRIDX_JX 54 /* 'jx' */ +#define DUK_STRIDX_BASE64 55 /* 'base64' */ +#define DUK_STRIDX_HEX 56 /* 'hex' */ +#define DUK_STRIDX_DEC 57 /* 'dec' */ +#define DUK_STRIDX_ENC 58 /* 'enc' */ +#define DUK_STRIDX_FIN 59 /* 'fin' */ +#define DUK_STRIDX_GC 60 /* 'gc' */ +#define DUK_STRIDX_ACT 61 /* 'act' */ +#define DUK_STRIDX_LC_INFO 62 /* 'info' */ +#define DUK_STRIDX_VERSION 63 /* 'version' */ +#define DUK_STRIDX_ENV 64 /* 'env' */ +#define DUK_STRIDX_MOD_LOADED 65 /* 'modLoaded' */ +#define DUK_STRIDX_MOD_SEARCH 66 /* 'modSearch' */ +#define DUK_STRIDX_ERR_THROW 67 /* 'errThrow' */ +#define DUK_STRIDX_ERR_CREATE 68 /* 'errCreate' */ +#define DUK_STRIDX_COMPILE 69 /* 'compile' */ +#define DUK_STRIDX_INT_REGBASE 70 /* '\x00Regbase' */ +#define DUK_STRIDX_INT_THREAD 71 /* '\x00Thread' */ +#define DUK_STRIDX_INT_HANDLER 72 /* '\x00Handler' */ +#define DUK_STRIDX_INT_FINALIZER 73 /* '\x00Finalizer' */ +#define DUK_STRIDX_INT_CALLEE 74 /* '\x00Callee' */ +#define DUK_STRIDX_INT_MAP 75 /* '\x00Map' */ +#define DUK_STRIDX_INT_ARGS 76 /* '\x00Args' */ +#define DUK_STRIDX_INT_THIS 77 /* '\x00This' */ +#define DUK_STRIDX_INT_PC2LINE 78 /* '\x00Pc2line' */ +#define DUK_STRIDX_INT_SOURCE 79 /* '\x00Source' */ +#define DUK_STRIDX_INT_VARENV 80 /* '\x00Varenv' */ +#define DUK_STRIDX_INT_LEXENV 81 /* '\x00Lexenv' */ +#define DUK_STRIDX_INT_VARMAP 82 /* '\x00Varmap' */ +#define DUK_STRIDX_INT_FORMALS 83 /* '\x00Formals' */ +#define DUK_STRIDX_INT_BYTECODE 84 /* '\x00Bytecode' */ +#define DUK_STRIDX_INT_NEXT 85 /* '\x00Next' */ +#define DUK_STRIDX_INT_TARGET 86 /* '\x00Target' */ +#define DUK_STRIDX_INT_VALUE 87 /* '\x00Value' */ +#define DUK_STRIDX_LC_POINTER 88 /* 'pointer' */ +#define DUK_STRIDX_INT_TRACEDATA 89 /* '\x00Tracedata' */ +#define DUK_STRIDX_LINE_NUMBER 90 /* 'lineNumber' */ +#define DUK_STRIDX_FILE_NAME 91 /* 'fileName' */ +#define DUK_STRIDX_PC 92 /* 'pc' */ +#define DUK_STRIDX_STACK 93 /* 'stack' */ +#define DUK_STRIDX_THROW_TYPE_ERROR 94 /* 'ThrowTypeError' */ +#define DUK_STRIDX_DUKTAPE 95 /* 'Duktape' */ +#define DUK_STRIDX_SET_FLOAT64 96 /* 'setFloat64' */ +#define DUK_STRIDX_SET_FLOAT32 97 /* 'setFloat32' */ +#define DUK_STRIDX_SET_UINT32 98 /* 'setUint32' */ +#define DUK_STRIDX_SET_INT32 99 /* 'setInt32' */ +#define DUK_STRIDX_SET_UINT16 100 /* 'setUint16' */ +#define DUK_STRIDX_SET_INT16 101 /* 'setInt16' */ +#define DUK_STRIDX_SET_UINT8 102 /* 'setUint8' */ +#define DUK_STRIDX_SET_INT8 103 /* 'setInt8' */ +#define DUK_STRIDX_GET_FLOAT64 104 /* 'getFloat64' */ +#define DUK_STRIDX_GET_FLOAT32 105 /* 'getFloat32' */ +#define DUK_STRIDX_GET_UINT32 106 /* 'getUint32' */ +#define DUK_STRIDX_GET_INT32 107 /* 'getInt32' */ +#define DUK_STRIDX_GET_UINT16 108 /* 'getUint16' */ +#define DUK_STRIDX_GET_INT16 109 /* 'getInt16' */ +#define DUK_STRIDX_GET_UINT8 110 /* 'getUint8' */ +#define DUK_STRIDX_GET_INT8 111 /* 'getInt8' */ +#define DUK_STRIDX_SUBARRAY 112 /* 'subarray' */ +#define DUK_STRIDX_BYTES_PER_ELEMENT 113 /* 'BYTES_PER_ELEMENT' */ +#define DUK_STRIDX_BYTE_OFFSET 114 /* 'byteOffset' */ +#define DUK_STRIDX_LC_BUFFER 115 /* 'buffer' */ +#define DUK_STRIDX_IS_VIEW 116 /* 'isView' */ +#define DUK_STRIDX_DATA 117 /* 'data' */ +#define DUK_STRIDX_TYPE 118 /* 'type' */ +#define DUK_STRIDX_WRITE_INT_BE 119 /* 'writeIntBE' */ +#define DUK_STRIDX_WRITE_INT_LE 120 /* 'writeIntLE' */ +#define DUK_STRIDX_WRITE_UINT_BE 121 /* 'writeUIntBE' */ +#define DUK_STRIDX_WRITE_UINT_LE 122 /* 'writeUIntLE' */ +#define DUK_STRIDX_WRITE_DOUBLE_BE 123 /* 'writeDoubleBE' */ +#define DUK_STRIDX_WRITE_DOUBLE_LE 124 /* 'writeDoubleLE' */ +#define DUK_STRIDX_WRITE_FLOAT_BE 125 /* 'writeFloatBE' */ +#define DUK_STRIDX_WRITE_FLOAT_LE 126 /* 'writeFloatLE' */ +#define DUK_STRIDX_WRITE_INT32_BE 127 /* 'writeInt32BE' */ +#define DUK_STRIDX_WRITE_INT32_LE 128 /* 'writeInt32LE' */ +#define DUK_STRIDX_WRITE_UINT32_BE 129 /* 'writeUInt32BE' */ +#define DUK_STRIDX_WRITE_UINT32_LE 130 /* 'writeUInt32LE' */ +#define DUK_STRIDX_WRITE_INT16_BE 131 /* 'writeInt16BE' */ +#define DUK_STRIDX_WRITE_INT16_LE 132 /* 'writeInt16LE' */ +#define DUK_STRIDX_WRITE_UINT16_BE 133 /* 'writeUInt16BE' */ +#define DUK_STRIDX_WRITE_UINT16_LE 134 /* 'writeUInt16LE' */ +#define DUK_STRIDX_WRITE_INT8 135 /* 'writeInt8' */ +#define DUK_STRIDX_WRITE_UINT8 136 /* 'writeUInt8' */ +#define DUK_STRIDX_READ_INT_BE 137 /* 'readIntBE' */ +#define DUK_STRIDX_READ_INT_LE 138 /* 'readIntLE' */ +#define DUK_STRIDX_READ_UINT_BE 139 /* 'readUIntBE' */ +#define DUK_STRIDX_READ_UINT_LE 140 /* 'readUIntLE' */ +#define DUK_STRIDX_READ_DOUBLE_BE 141 /* 'readDoubleBE' */ +#define DUK_STRIDX_READ_DOUBLE_LE 142 /* 'readDoubleLE' */ +#define DUK_STRIDX_READ_FLOAT_BE 143 /* 'readFloatBE' */ +#define DUK_STRIDX_READ_FLOAT_LE 144 /* 'readFloatLE' */ +#define DUK_STRIDX_READ_INT32_BE 145 /* 'readInt32BE' */ +#define DUK_STRIDX_READ_INT32_LE 146 /* 'readInt32LE' */ +#define DUK_STRIDX_READ_UINT32_BE 147 /* 'readUInt32BE' */ +#define DUK_STRIDX_READ_UINT32_LE 148 /* 'readUInt32LE' */ +#define DUK_STRIDX_READ_INT16_BE 149 /* 'readInt16BE' */ +#define DUK_STRIDX_READ_INT16_LE 150 /* 'readInt16LE' */ +#define DUK_STRIDX_READ_UINT16_BE 151 /* 'readUInt16BE' */ +#define DUK_STRIDX_READ_UINT16_LE 152 /* 'readUInt16LE' */ +#define DUK_STRIDX_READ_INT8 153 /* 'readInt8' */ +#define DUK_STRIDX_READ_UINT8 154 /* 'readUInt8' */ +#define DUK_STRIDX_COPY 155 /* 'copy' */ +#define DUK_STRIDX_EQUALS 156 /* 'equals' */ +#define DUK_STRIDX_FILL 157 /* 'fill' */ +#define DUK_STRIDX_WRITE 158 /* 'write' */ +#define DUK_STRIDX_COMPARE 159 /* 'compare' */ +#define DUK_STRIDX_BYTE_LENGTH 160 /* 'byteLength' */ +#define DUK_STRIDX_IS_BUFFER 161 /* 'isBuffer' */ +#define DUK_STRIDX_IS_ENCODING 162 /* 'isEncoding' */ +#define DUK_STRIDX_EXPORTS 163 /* 'exports' */ +#define DUK_STRIDX_ID 164 /* 'id' */ +#define DUK_STRIDX_REQUIRE 165 /* 'require' */ +#define DUK_STRIDX___PROTO__ 166 /* '__proto__' */ +#define DUK_STRIDX_SET_PROTOTYPE_OF 167 /* 'setPrototypeOf' */ +#define DUK_STRIDX_OWN_KEYS 168 /* 'ownKeys' */ +#define DUK_STRIDX_ENUMERATE 169 /* 'enumerate' */ +#define DUK_STRIDX_DELETE_PROPERTY 170 /* 'deleteProperty' */ +#define DUK_STRIDX_HAS 171 /* 'has' */ +#define DUK_STRIDX_PROXY 172 /* 'Proxy' */ +#define DUK_STRIDX_CALLEE 173 /* 'callee' */ +#define DUK_STRIDX_INVALID_DATE 174 /* 'Invalid Date' */ +#define DUK_STRIDX_BRACKETED_ELLIPSIS 175 /* '[...]' */ +#define DUK_STRIDX_NEWLINE_TAB 176 /* '\n\t' */ +#define DUK_STRIDX_SPACE 177 /* ' ' */ +#define DUK_STRIDX_COMMA 178 /* ',' */ +#define DUK_STRIDX_MINUS_ZERO 179 /* '-0' */ +#define DUK_STRIDX_PLUS_ZERO 180 /* '+0' */ +#define DUK_STRIDX_ZERO 181 /* '0' */ +#define DUK_STRIDX_MINUS_INFINITY 182 /* '-Infinity' */ +#define DUK_STRIDX_PLUS_INFINITY 183 /* '+Infinity' */ +#define DUK_STRIDX_INFINITY 184 /* 'Infinity' */ +#define DUK_STRIDX_LC_OBJECT 185 /* 'object' */ +#define DUK_STRIDX_LC_STRING 186 /* 'string' */ +#define DUK_STRIDX_LC_NUMBER 187 /* 'number' */ +#define DUK_STRIDX_LC_BOOLEAN 188 /* 'boolean' */ +#define DUK_STRIDX_LC_UNDEFINED 189 /* 'undefined' */ +#define DUK_STRIDX_STRINGIFY 190 /* 'stringify' */ +#define DUK_STRIDX_TAN 191 /* 'tan' */ +#define DUK_STRIDX_SQRT 192 /* 'sqrt' */ +#define DUK_STRIDX_SIN 193 /* 'sin' */ +#define DUK_STRIDX_ROUND 194 /* 'round' */ +#define DUK_STRIDX_RANDOM 195 /* 'random' */ +#define DUK_STRIDX_POW 196 /* 'pow' */ +#define DUK_STRIDX_MIN 197 /* 'min' */ +#define DUK_STRIDX_MAX 198 /* 'max' */ +#define DUK_STRIDX_LOG 199 /* 'log' */ +#define DUK_STRIDX_FLOOR 200 /* 'floor' */ +#define DUK_STRIDX_EXP 201 /* 'exp' */ +#define DUK_STRIDX_COS 202 /* 'cos' */ +#define DUK_STRIDX_CEIL 203 /* 'ceil' */ +#define DUK_STRIDX_ATAN2 204 /* 'atan2' */ +#define DUK_STRIDX_ATAN 205 /* 'atan' */ +#define DUK_STRIDX_ASIN 206 /* 'asin' */ +#define DUK_STRIDX_ACOS 207 /* 'acos' */ +#define DUK_STRIDX_ABS 208 /* 'abs' */ +#define DUK_STRIDX_SQRT2 209 /* 'SQRT2' */ +#define DUK_STRIDX_SQRT1_2 210 /* 'SQRT1_2' */ +#define DUK_STRIDX_PI 211 /* 'PI' */ +#define DUK_STRIDX_LOG10E 212 /* 'LOG10E' */ +#define DUK_STRIDX_LOG2E 213 /* 'LOG2E' */ +#define DUK_STRIDX_LN2 214 /* 'LN2' */ +#define DUK_STRIDX_LN10 215 /* 'LN10' */ +#define DUK_STRIDX_E 216 /* 'E' */ +#define DUK_STRIDX_MESSAGE 217 /* 'message' */ +#define DUK_STRIDX_NAME 218 /* 'name' */ +#define DUK_STRIDX_INPUT 219 /* 'input' */ +#define DUK_STRIDX_INDEX 220 /* 'index' */ +#define DUK_STRIDX_ESCAPED_EMPTY_REGEXP 221 /* '(?:)' */ +#define DUK_STRIDX_LAST_INDEX 222 /* 'lastIndex' */ +#define DUK_STRIDX_MULTILINE 223 /* 'multiline' */ +#define DUK_STRIDX_IGNORE_CASE 224 /* 'ignoreCase' */ +#define DUK_STRIDX_SOURCE 225 /* 'source' */ +#define DUK_STRIDX_TEST 226 /* 'test' */ +#define DUK_STRIDX_EXEC 227 /* 'exec' */ +#define DUK_STRIDX_TO_GMT_STRING 228 /* 'toGMTString' */ +#define DUK_STRIDX_SET_YEAR 229 /* 'setYear' */ +#define DUK_STRIDX_GET_YEAR 230 /* 'getYear' */ +#define DUK_STRIDX_TO_JSON 231 /* 'toJSON' */ +#define DUK_STRIDX_TO_ISO_STRING 232 /* 'toISOString' */ +#define DUK_STRIDX_TO_UTC_STRING 233 /* 'toUTCString' */ +#define DUK_STRIDX_SET_UTC_FULL_YEAR 234 /* 'setUTCFullYear' */ +#define DUK_STRIDX_SET_FULL_YEAR 235 /* 'setFullYear' */ +#define DUK_STRIDX_SET_UTC_MONTH 236 /* 'setUTCMonth' */ +#define DUK_STRIDX_SET_MONTH 237 /* 'setMonth' */ +#define DUK_STRIDX_SET_UTC_DATE 238 /* 'setUTCDate' */ +#define DUK_STRIDX_SET_DATE 239 /* 'setDate' */ +#define DUK_STRIDX_SET_UTC_HOURS 240 /* 'setUTCHours' */ +#define DUK_STRIDX_SET_HOURS 241 /* 'setHours' */ +#define DUK_STRIDX_SET_UTC_MINUTES 242 /* 'setUTCMinutes' */ +#define DUK_STRIDX_SET_MINUTES 243 /* 'setMinutes' */ +#define DUK_STRIDX_SET_UTC_SECONDS 244 /* 'setUTCSeconds' */ +#define DUK_STRIDX_SET_SECONDS 245 /* 'setSeconds' */ +#define DUK_STRIDX_SET_UTC_MILLISECONDS 246 /* 'setUTCMilliseconds' */ +#define DUK_STRIDX_SET_MILLISECONDS 247 /* 'setMilliseconds' */ +#define DUK_STRIDX_SET_TIME 248 /* 'setTime' */ +#define DUK_STRIDX_GET_TIMEZONE_OFFSET 249 /* 'getTimezoneOffset' */ +#define DUK_STRIDX_GET_UTC_MILLISECONDS 250 /* 'getUTCMilliseconds' */ +#define DUK_STRIDX_GET_MILLISECONDS 251 /* 'getMilliseconds' */ +#define DUK_STRIDX_GET_UTC_SECONDS 252 /* 'getUTCSeconds' */ +#define DUK_STRIDX_GET_SECONDS 253 /* 'getSeconds' */ +#define DUK_STRIDX_GET_UTC_MINUTES 254 /* 'getUTCMinutes' */ +#define DUK_STRIDX_GET_MINUTES 255 /* 'getMinutes' */ +#define DUK_STRIDX_GET_UTC_HOURS 256 /* 'getUTCHours' */ +#define DUK_STRIDX_GET_HOURS 257 /* 'getHours' */ +#define DUK_STRIDX_GET_UTC_DAY 258 /* 'getUTCDay' */ +#define DUK_STRIDX_GET_DAY 259 /* 'getDay' */ +#define DUK_STRIDX_GET_UTC_DATE 260 /* 'getUTCDate' */ +#define DUK_STRIDX_GET_DATE 261 /* 'getDate' */ +#define DUK_STRIDX_GET_UTC_MONTH 262 /* 'getUTCMonth' */ +#define DUK_STRIDX_GET_MONTH 263 /* 'getMonth' */ +#define DUK_STRIDX_GET_UTC_FULL_YEAR 264 /* 'getUTCFullYear' */ +#define DUK_STRIDX_GET_FULL_YEAR 265 /* 'getFullYear' */ +#define DUK_STRIDX_GET_TIME 266 /* 'getTime' */ +#define DUK_STRIDX_TO_LOCALE_TIME_STRING 267 /* 'toLocaleTimeString' */ +#define DUK_STRIDX_TO_LOCALE_DATE_STRING 268 /* 'toLocaleDateString' */ +#define DUK_STRIDX_TO_TIME_STRING 269 /* 'toTimeString' */ +#define DUK_STRIDX_TO_DATE_STRING 270 /* 'toDateString' */ +#define DUK_STRIDX_NOW 271 /* 'now' */ +#define DUK_STRIDX_UTC 272 /* 'UTC' */ +#define DUK_STRIDX_PARSE 273 /* 'parse' */ +#define DUK_STRIDX_TO_PRECISION 274 /* 'toPrecision' */ +#define DUK_STRIDX_TO_EXPONENTIAL 275 /* 'toExponential' */ +#define DUK_STRIDX_TO_FIXED 276 /* 'toFixed' */ +#define DUK_STRIDX_POSITIVE_INFINITY 277 /* 'POSITIVE_INFINITY' */ +#define DUK_STRIDX_NEGATIVE_INFINITY 278 /* 'NEGATIVE_INFINITY' */ +#define DUK_STRIDX_NAN 279 /* 'NaN' */ +#define DUK_STRIDX_MIN_VALUE 280 /* 'MIN_VALUE' */ +#define DUK_STRIDX_MAX_VALUE 281 /* 'MAX_VALUE' */ +#define DUK_STRIDX_SUBSTR 282 /* 'substr' */ +#define DUK_STRIDX_TRIM 283 /* 'trim' */ +#define DUK_STRIDX_TO_LOCALE_UPPER_CASE 284 /* 'toLocaleUpperCase' */ +#define DUK_STRIDX_TO_UPPER_CASE 285 /* 'toUpperCase' */ +#define DUK_STRIDX_TO_LOCALE_LOWER_CASE 286 /* 'toLocaleLowerCase' */ +#define DUK_STRIDX_TO_LOWER_CASE 287 /* 'toLowerCase' */ +#define DUK_STRIDX_SUBSTRING 288 /* 'substring' */ +#define DUK_STRIDX_SPLIT 289 /* 'split' */ +#define DUK_STRIDX_SEARCH 290 /* 'search' */ +#define DUK_STRIDX_REPLACE 291 /* 'replace' */ +#define DUK_STRIDX_MATCH 292 /* 'match' */ +#define DUK_STRIDX_LOCALE_COMPARE 293 /* 'localeCompare' */ +#define DUK_STRIDX_CHAR_CODE_AT 294 /* 'charCodeAt' */ +#define DUK_STRIDX_CHAR_AT 295 /* 'charAt' */ +#define DUK_STRIDX_FROM_CHAR_CODE 296 /* 'fromCharCode' */ +#define DUK_STRIDX_REDUCE_RIGHT 297 /* 'reduceRight' */ +#define DUK_STRIDX_REDUCE 298 /* 'reduce' */ +#define DUK_STRIDX_FILTER 299 /* 'filter' */ +#define DUK_STRIDX_MAP 300 /* 'map' */ +#define DUK_STRIDX_FOR_EACH 301 /* 'forEach' */ +#define DUK_STRIDX_SOME 302 /* 'some' */ +#define DUK_STRIDX_EVERY 303 /* 'every' */ +#define DUK_STRIDX_LAST_INDEX_OF 304 /* 'lastIndexOf' */ +#define DUK_STRIDX_INDEX_OF 305 /* 'indexOf' */ +#define DUK_STRIDX_UNSHIFT 306 /* 'unshift' */ +#define DUK_STRIDX_SPLICE 307 /* 'splice' */ +#define DUK_STRIDX_SORT 308 /* 'sort' */ +#define DUK_STRIDX_SLICE 309 /* 'slice' */ +#define DUK_STRIDX_SHIFT 310 /* 'shift' */ +#define DUK_STRIDX_REVERSE 311 /* 'reverse' */ +#define DUK_STRIDX_PUSH 312 /* 'push' */ +#define DUK_STRIDX_POP 313 /* 'pop' */ +#define DUK_STRIDX_JOIN 314 /* 'join' */ +#define DUK_STRIDX_CONCAT 315 /* 'concat' */ +#define DUK_STRIDX_IS_ARRAY 316 /* 'isArray' */ +#define DUK_STRIDX_LC_ARGUMENTS 317 /* 'arguments' */ +#define DUK_STRIDX_CALLER 318 /* 'caller' */ +#define DUK_STRIDX_BIND 319 /* 'bind' */ +#define DUK_STRIDX_CALL 320 /* 'call' */ +#define DUK_STRIDX_APPLY 321 /* 'apply' */ +#define DUK_STRIDX_PROPERTY_IS_ENUMERABLE 322 /* 'propertyIsEnumerable' */ +#define DUK_STRIDX_IS_PROTOTYPE_OF 323 /* 'isPrototypeOf' */ +#define DUK_STRIDX_HAS_OWN_PROPERTY 324 /* 'hasOwnProperty' */ +#define DUK_STRIDX_VALUE_OF 325 /* 'valueOf' */ +#define DUK_STRIDX_TO_LOCALE_STRING 326 /* 'toLocaleString' */ +#define DUK_STRIDX_TO_STRING 327 /* 'toString' */ +#define DUK_STRIDX_CONSTRUCTOR 328 /* 'constructor' */ +#define DUK_STRIDX_SET 329 /* 'set' */ +#define DUK_STRIDX_GET 330 /* 'get' */ +#define DUK_STRIDX_ENUMERABLE 331 /* 'enumerable' */ +#define DUK_STRIDX_CONFIGURABLE 332 /* 'configurable' */ +#define DUK_STRIDX_WRITABLE 333 /* 'writable' */ +#define DUK_STRIDX_VALUE 334 /* 'value' */ +#define DUK_STRIDX_KEYS 335 /* 'keys' */ +#define DUK_STRIDX_IS_EXTENSIBLE 336 /* 'isExtensible' */ +#define DUK_STRIDX_IS_FROZEN 337 /* 'isFrozen' */ +#define DUK_STRIDX_IS_SEALED 338 /* 'isSealed' */ +#define DUK_STRIDX_PREVENT_EXTENSIONS 339 /* 'preventExtensions' */ +#define DUK_STRIDX_FREEZE 340 /* 'freeze' */ +#define DUK_STRIDX_SEAL 341 /* 'seal' */ +#define DUK_STRIDX_DEFINE_PROPERTIES 342 /* 'defineProperties' */ +#define DUK_STRIDX_DEFINE_PROPERTY 343 /* 'defineProperty' */ +#define DUK_STRIDX_CREATE 344 /* 'create' */ +#define DUK_STRIDX_GET_OWN_PROPERTY_NAMES 345 /* 'getOwnPropertyNames' */ +#define DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR 346 /* 'getOwnPropertyDescriptor' */ +#define DUK_STRIDX_GET_PROTOTYPE_OF 347 /* 'getPrototypeOf' */ +#define DUK_STRIDX_PROTOTYPE 348 /* 'prototype' */ +#define DUK_STRIDX_LENGTH 349 /* 'length' */ +#define DUK_STRIDX_ALERT 350 /* 'alert' */ +#define DUK_STRIDX_PRINT 351 /* 'print' */ +#define DUK_STRIDX_UNESCAPE 352 /* 'unescape' */ +#define DUK_STRIDX_ESCAPE 353 /* 'escape' */ +#define DUK_STRIDX_ENCODE_URI_COMPONENT 354 /* 'encodeURIComponent' */ +#define DUK_STRIDX_ENCODE_URI 355 /* 'encodeURI' */ +#define DUK_STRIDX_DECODE_URI_COMPONENT 356 /* 'decodeURIComponent' */ +#define DUK_STRIDX_DECODE_URI 357 /* 'decodeURI' */ +#define DUK_STRIDX_IS_FINITE 358 /* 'isFinite' */ +#define DUK_STRIDX_IS_NAN 359 /* 'isNaN' */ +#define DUK_STRIDX_PARSE_FLOAT 360 /* 'parseFloat' */ +#define DUK_STRIDX_PARSE_INT 361 /* 'parseInt' */ +#define DUK_STRIDX_EVAL 362 /* 'eval' */ +#define DUK_STRIDX_URI_ERROR 363 /* 'URIError' */ +#define DUK_STRIDX_TYPE_ERROR 364 /* 'TypeError' */ +#define DUK_STRIDX_SYNTAX_ERROR 365 /* 'SyntaxError' */ +#define DUK_STRIDX_REFERENCE_ERROR 366 /* 'ReferenceError' */ +#define DUK_STRIDX_RANGE_ERROR 367 /* 'RangeError' */ +#define DUK_STRIDX_EVAL_ERROR 368 /* 'EvalError' */ +#define DUK_STRIDX_BREAK 369 /* 'break' */ +#define DUK_STRIDX_CASE 370 /* 'case' */ +#define DUK_STRIDX_CATCH 371 /* 'catch' */ +#define DUK_STRIDX_CONTINUE 372 /* 'continue' */ +#define DUK_STRIDX_DEBUGGER 373 /* 'debugger' */ +#define DUK_STRIDX_DEFAULT 374 /* 'default' */ +#define DUK_STRIDX_DELETE 375 /* 'delete' */ +#define DUK_STRIDX_DO 376 /* 'do' */ +#define DUK_STRIDX_ELSE 377 /* 'else' */ +#define DUK_STRIDX_FINALLY 378 /* 'finally' */ +#define DUK_STRIDX_FOR 379 /* 'for' */ +#define DUK_STRIDX_LC_FUNCTION 380 /* 'function' */ +#define DUK_STRIDX_IF 381 /* 'if' */ +#define DUK_STRIDX_IN 382 /* 'in' */ +#define DUK_STRIDX_INSTANCEOF 383 /* 'instanceof' */ +#define DUK_STRIDX_NEW 384 /* 'new' */ +#define DUK_STRIDX_RETURN 385 /* 'return' */ +#define DUK_STRIDX_SWITCH 386 /* 'switch' */ +#define DUK_STRIDX_THIS 387 /* 'this' */ +#define DUK_STRIDX_THROW 388 /* 'throw' */ +#define DUK_STRIDX_TRY 389 /* 'try' */ +#define DUK_STRIDX_TYPEOF 390 /* 'typeof' */ +#define DUK_STRIDX_VAR 391 /* 'var' */ +#define DUK_STRIDX_CONST 392 /* 'const' */ +#define DUK_STRIDX_VOID 393 /* 'void' */ +#define DUK_STRIDX_WHILE 394 /* 'while' */ +#define DUK_STRIDX_WITH 395 /* 'with' */ +#define DUK_STRIDX_CLASS 396 /* 'class' */ +#define DUK_STRIDX_ENUM 397 /* 'enum' */ +#define DUK_STRIDX_EXPORT 398 /* 'export' */ +#define DUK_STRIDX_EXTENDS 399 /* 'extends' */ +#define DUK_STRIDX_IMPORT 400 /* 'import' */ +#define DUK_STRIDX_SUPER 401 /* 'super' */ +#define DUK_STRIDX_LC_NULL 402 /* 'null' */ +#define DUK_STRIDX_TRUE 403 /* 'true' */ +#define DUK_STRIDX_FALSE 404 /* 'false' */ +#define DUK_STRIDX_IMPLEMENTS 405 /* 'implements' */ +#define DUK_STRIDX_INTERFACE 406 /* 'interface' */ +#define DUK_STRIDX_LET 407 /* 'let' */ +#define DUK_STRIDX_PACKAGE 408 /* 'package' */ +#define DUK_STRIDX_PRIVATE 409 /* 'private' */ +#define DUK_STRIDX_PROTECTED 410 /* 'protected' */ +#define DUK_STRIDX_PUBLIC 411 /* 'public' */ +#define DUK_STRIDX_STATIC 412 /* 'static' */ +#define DUK_STRIDX_YIELD 413 /* 'yield' */ #define DUK_HEAP_STRING_UC_LOGGER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_LOGGER) #define DUK_HTHREAD_STRING_UC_LOGGER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_LOGGER) @@ -1747,12 +2138,34 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; #define DUK_HTHREAD_STRING_UC_THREAD(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_THREAD) #define DUK_HEAP_STRING_UC_POINTER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_POINTER) #define DUK_HTHREAD_STRING_UC_POINTER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_POINTER) -#define DUK_HEAP_STRING_UC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BUFFER) -#define DUK_HTHREAD_STRING_UC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BUFFER) #define DUK_HEAP_STRING_DEC_ENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC_ENV) #define DUK_HTHREAD_STRING_DEC_ENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC_ENV) #define DUK_HEAP_STRING_OBJ_ENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OBJ_ENV) #define DUK_HTHREAD_STRING_OBJ_ENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OBJ_ENV) +#define DUK_HEAP_STRING_FLOAT64_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOAT64_ARRAY) +#define DUK_HTHREAD_STRING_FLOAT64_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOAT64_ARRAY) +#define DUK_HEAP_STRING_FLOAT32_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOAT32_ARRAY) +#define DUK_HTHREAD_STRING_FLOAT32_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOAT32_ARRAY) +#define DUK_HEAP_STRING_UINT32_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT32_ARRAY) +#define DUK_HTHREAD_STRING_UINT32_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT32_ARRAY) +#define DUK_HEAP_STRING_INT32_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT32_ARRAY) +#define DUK_HTHREAD_STRING_INT32_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT32_ARRAY) +#define DUK_HEAP_STRING_UINT16_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT16_ARRAY) +#define DUK_HTHREAD_STRING_UINT16_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT16_ARRAY) +#define DUK_HEAP_STRING_INT16_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT16_ARRAY) +#define DUK_HTHREAD_STRING_INT16_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT16_ARRAY) +#define DUK_HEAP_STRING_UINT8_CLAMPED_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT8_CLAMPED_ARRAY) +#define DUK_HTHREAD_STRING_UINT8_CLAMPED_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT8_CLAMPED_ARRAY) +#define DUK_HEAP_STRING_UINT8_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT8_ARRAY) +#define DUK_HTHREAD_STRING_UINT8_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT8_ARRAY) +#define DUK_HEAP_STRING_INT8_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT8_ARRAY) +#define DUK_HTHREAD_STRING_INT8_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT8_ARRAY) +#define DUK_HEAP_STRING_DATA_VIEW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATA_VIEW) +#define DUK_HTHREAD_STRING_DATA_VIEW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATA_VIEW) +#define DUK_HEAP_STRING_ARRAY_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY_BUFFER) +#define DUK_HTHREAD_STRING_ARRAY_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY_BUFFER) +#define DUK_HEAP_STRING_UC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BUFFER) +#define DUK_HTHREAD_STRING_UC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BUFFER) #define DUK_HEAP_STRING_EMPTY_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EMPTY_STRING) #define DUK_HTHREAD_STRING_EMPTY_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EMPTY_STRING) #define DUK_HEAP_STRING_GLOBAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GLOBAL) @@ -1897,8 +2310,6 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; #define DUK_HTHREAD_STRING_INT_VALUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VALUE) #define DUK_HEAP_STRING_LC_POINTER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_POINTER) #define DUK_HTHREAD_STRING_LC_POINTER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_POINTER) -#define DUK_HEAP_STRING_LC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BUFFER) -#define DUK_HTHREAD_STRING_LC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BUFFER) #define DUK_HEAP_STRING_INT_TRACEDATA(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TRACEDATA) #define DUK_HTHREAD_STRING_INT_TRACEDATA(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TRACEDATA) #define DUK_HEAP_STRING_LINE_NUMBER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LINE_NUMBER) @@ -1913,6 +2324,142 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; #define DUK_HTHREAD_STRING_THROW_TYPE_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW_TYPE_ERROR) #define DUK_HEAP_STRING_DUKTAPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DUKTAPE) #define DUK_HTHREAD_STRING_DUKTAPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DUKTAPE) +#define DUK_HEAP_STRING_SET_FLOAT64(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FLOAT64) +#define DUK_HTHREAD_STRING_SET_FLOAT64(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FLOAT64) +#define DUK_HEAP_STRING_SET_FLOAT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FLOAT32) +#define DUK_HTHREAD_STRING_SET_FLOAT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FLOAT32) +#define DUK_HEAP_STRING_SET_UINT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UINT32) +#define DUK_HTHREAD_STRING_SET_UINT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UINT32) +#define DUK_HEAP_STRING_SET_INT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_INT32) +#define DUK_HTHREAD_STRING_SET_INT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_INT32) +#define DUK_HEAP_STRING_SET_UINT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UINT16) +#define DUK_HTHREAD_STRING_SET_UINT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UINT16) +#define DUK_HEAP_STRING_SET_INT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_INT16) +#define DUK_HTHREAD_STRING_SET_INT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_INT16) +#define DUK_HEAP_STRING_SET_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UINT8) +#define DUK_HTHREAD_STRING_SET_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UINT8) +#define DUK_HEAP_STRING_SET_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_INT8) +#define DUK_HTHREAD_STRING_SET_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_INT8) +#define DUK_HEAP_STRING_GET_FLOAT64(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FLOAT64) +#define DUK_HTHREAD_STRING_GET_FLOAT64(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FLOAT64) +#define DUK_HEAP_STRING_GET_FLOAT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FLOAT32) +#define DUK_HTHREAD_STRING_GET_FLOAT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FLOAT32) +#define DUK_HEAP_STRING_GET_UINT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UINT32) +#define DUK_HTHREAD_STRING_GET_UINT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UINT32) +#define DUK_HEAP_STRING_GET_INT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_INT32) +#define DUK_HTHREAD_STRING_GET_INT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_INT32) +#define DUK_HEAP_STRING_GET_UINT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UINT16) +#define DUK_HTHREAD_STRING_GET_UINT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UINT16) +#define DUK_HEAP_STRING_GET_INT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_INT16) +#define DUK_HTHREAD_STRING_GET_INT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_INT16) +#define DUK_HEAP_STRING_GET_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UINT8) +#define DUK_HTHREAD_STRING_GET_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UINT8) +#define DUK_HEAP_STRING_GET_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_INT8) +#define DUK_HTHREAD_STRING_GET_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_INT8) +#define DUK_HEAP_STRING_SUBARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBARRAY) +#define DUK_HTHREAD_STRING_SUBARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBARRAY) +#define DUK_HEAP_STRING_BYTES_PER_ELEMENT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTES_PER_ELEMENT) +#define DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTES_PER_ELEMENT) +#define DUK_HEAP_STRING_BYTE_OFFSET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTE_OFFSET) +#define DUK_HTHREAD_STRING_BYTE_OFFSET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTE_OFFSET) +#define DUK_HEAP_STRING_LC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BUFFER) +#define DUK_HTHREAD_STRING_LC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BUFFER) +#define DUK_HEAP_STRING_IS_VIEW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_VIEW) +#define DUK_HTHREAD_STRING_IS_VIEW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_VIEW) +#define DUK_HEAP_STRING_DATA(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATA) +#define DUK_HTHREAD_STRING_DATA(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATA) +#define DUK_HEAP_STRING_TYPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPE) +#define DUK_HTHREAD_STRING_TYPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPE) +#define DUK_HEAP_STRING_WRITE_INT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT_BE) +#define DUK_HTHREAD_STRING_WRITE_INT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT_BE) +#define DUK_HEAP_STRING_WRITE_INT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT_LE) +#define DUK_HTHREAD_STRING_WRITE_INT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT_LE) +#define DUK_HEAP_STRING_WRITE_UINT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT_BE) +#define DUK_HTHREAD_STRING_WRITE_UINT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT_BE) +#define DUK_HEAP_STRING_WRITE_UINT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT_LE) +#define DUK_HTHREAD_STRING_WRITE_UINT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT_LE) +#define DUK_HEAP_STRING_WRITE_DOUBLE_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_DOUBLE_BE) +#define DUK_HTHREAD_STRING_WRITE_DOUBLE_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_DOUBLE_BE) +#define DUK_HEAP_STRING_WRITE_DOUBLE_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_DOUBLE_LE) +#define DUK_HTHREAD_STRING_WRITE_DOUBLE_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_DOUBLE_LE) +#define DUK_HEAP_STRING_WRITE_FLOAT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_FLOAT_BE) +#define DUK_HTHREAD_STRING_WRITE_FLOAT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_FLOAT_BE) +#define DUK_HEAP_STRING_WRITE_FLOAT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_FLOAT_LE) +#define DUK_HTHREAD_STRING_WRITE_FLOAT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_FLOAT_LE) +#define DUK_HEAP_STRING_WRITE_INT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT32_BE) +#define DUK_HTHREAD_STRING_WRITE_INT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT32_BE) +#define DUK_HEAP_STRING_WRITE_INT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT32_LE) +#define DUK_HTHREAD_STRING_WRITE_INT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT32_LE) +#define DUK_HEAP_STRING_WRITE_UINT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT32_BE) +#define DUK_HTHREAD_STRING_WRITE_UINT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT32_BE) +#define DUK_HEAP_STRING_WRITE_UINT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT32_LE) +#define DUK_HTHREAD_STRING_WRITE_UINT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT32_LE) +#define DUK_HEAP_STRING_WRITE_INT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT16_BE) +#define DUK_HTHREAD_STRING_WRITE_INT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT16_BE) +#define DUK_HEAP_STRING_WRITE_INT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT16_LE) +#define DUK_HTHREAD_STRING_WRITE_INT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT16_LE) +#define DUK_HEAP_STRING_WRITE_UINT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT16_BE) +#define DUK_HTHREAD_STRING_WRITE_UINT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT16_BE) +#define DUK_HEAP_STRING_WRITE_UINT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT16_LE) +#define DUK_HTHREAD_STRING_WRITE_UINT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT16_LE) +#define DUK_HEAP_STRING_WRITE_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT8) +#define DUK_HTHREAD_STRING_WRITE_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT8) +#define DUK_HEAP_STRING_WRITE_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT8) +#define DUK_HTHREAD_STRING_WRITE_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT8) +#define DUK_HEAP_STRING_READ_INT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT_BE) +#define DUK_HTHREAD_STRING_READ_INT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT_BE) +#define DUK_HEAP_STRING_READ_INT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT_LE) +#define DUK_HTHREAD_STRING_READ_INT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT_LE) +#define DUK_HEAP_STRING_READ_UINT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT_BE) +#define DUK_HTHREAD_STRING_READ_UINT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT_BE) +#define DUK_HEAP_STRING_READ_UINT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT_LE) +#define DUK_HTHREAD_STRING_READ_UINT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT_LE) +#define DUK_HEAP_STRING_READ_DOUBLE_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_DOUBLE_BE) +#define DUK_HTHREAD_STRING_READ_DOUBLE_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_DOUBLE_BE) +#define DUK_HEAP_STRING_READ_DOUBLE_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_DOUBLE_LE) +#define DUK_HTHREAD_STRING_READ_DOUBLE_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_DOUBLE_LE) +#define DUK_HEAP_STRING_READ_FLOAT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_FLOAT_BE) +#define DUK_HTHREAD_STRING_READ_FLOAT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_FLOAT_BE) +#define DUK_HEAP_STRING_READ_FLOAT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_FLOAT_LE) +#define DUK_HTHREAD_STRING_READ_FLOAT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_FLOAT_LE) +#define DUK_HEAP_STRING_READ_INT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT32_BE) +#define DUK_HTHREAD_STRING_READ_INT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT32_BE) +#define DUK_HEAP_STRING_READ_INT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT32_LE) +#define DUK_HTHREAD_STRING_READ_INT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT32_LE) +#define DUK_HEAP_STRING_READ_UINT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT32_BE) +#define DUK_HTHREAD_STRING_READ_UINT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT32_BE) +#define DUK_HEAP_STRING_READ_UINT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT32_LE) +#define DUK_HTHREAD_STRING_READ_UINT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT32_LE) +#define DUK_HEAP_STRING_READ_INT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT16_BE) +#define DUK_HTHREAD_STRING_READ_INT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT16_BE) +#define DUK_HEAP_STRING_READ_INT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT16_LE) +#define DUK_HTHREAD_STRING_READ_INT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT16_LE) +#define DUK_HEAP_STRING_READ_UINT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT16_BE) +#define DUK_HTHREAD_STRING_READ_UINT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT16_BE) +#define DUK_HEAP_STRING_READ_UINT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT16_LE) +#define DUK_HTHREAD_STRING_READ_UINT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT16_LE) +#define DUK_HEAP_STRING_READ_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT8) +#define DUK_HTHREAD_STRING_READ_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT8) +#define DUK_HEAP_STRING_READ_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT8) +#define DUK_HTHREAD_STRING_READ_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT8) +#define DUK_HEAP_STRING_COPY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COPY) +#define DUK_HTHREAD_STRING_COPY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COPY) +#define DUK_HEAP_STRING_EQUALS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EQUALS) +#define DUK_HTHREAD_STRING_EQUALS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EQUALS) +#define DUK_HEAP_STRING_FILL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILL) +#define DUK_HTHREAD_STRING_FILL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILL) +#define DUK_HEAP_STRING_WRITE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE) +#define DUK_HTHREAD_STRING_WRITE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE) +#define DUK_HEAP_STRING_COMPARE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPARE) +#define DUK_HTHREAD_STRING_COMPARE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPARE) +#define DUK_HEAP_STRING_BYTE_LENGTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTE_LENGTH) +#define DUK_HTHREAD_STRING_BYTE_LENGTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTE_LENGTH) +#define DUK_HEAP_STRING_IS_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_BUFFER) +#define DUK_HTHREAD_STRING_IS_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_BUFFER) +#define DUK_HEAP_STRING_IS_ENCODING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_ENCODING) +#define DUK_HTHREAD_STRING_IS_ENCODING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_ENCODING) +#define DUK_HEAP_STRING_EXPORTS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORTS) +#define DUK_HTHREAD_STRING_EXPORTS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORTS) #define DUK_HEAP_STRING_ID(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ID) #define DUK_HTHREAD_STRING_ID(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ID) #define DUK_HEAP_STRING_REQUIRE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REQUIRE) @@ -2369,6 +2916,8 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; #define DUK_HTHREAD_STRING_TYPEOF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPEOF) #define DUK_HEAP_STRING_VAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VAR) #define DUK_HTHREAD_STRING_VAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VAR) +#define DUK_HEAP_STRING_CONST(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONST) +#define DUK_HTHREAD_STRING_CONST(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONST) #define DUK_HEAP_STRING_VOID(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VOID) #define DUK_HTHREAD_STRING_VOID(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VOID) #define DUK_HEAP_STRING_WHILE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WHILE) @@ -2377,8 +2926,6 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; #define DUK_HTHREAD_STRING_WITH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WITH) #define DUK_HEAP_STRING_CLASS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLASS) #define DUK_HTHREAD_STRING_CLASS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLASS) -#define DUK_HEAP_STRING_CONST(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONST) -#define DUK_HTHREAD_STRING_CONST(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONST) #define DUK_HEAP_STRING_ENUM(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUM) #define DUK_HTHREAD_STRING_ENUM(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUM) #define DUK_HEAP_STRING_EXPORT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORT) @@ -2414,21 +2961,21 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; #define DUK_HEAP_STRING_YIELD(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_YIELD) #define DUK_HTHREAD_STRING_YIELD(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_YIELD) -#define DUK_HEAP_NUM_STRINGS 336 +#define DUK_HEAP_NUM_STRINGS 414 -#define DUK_STRIDX_START_RESERVED 291 -#define DUK_STRIDX_START_STRICT_RESERVED 327 -#define DUK_STRIDX_END_RESERVED 336 /* exclusive endpoint */ +#define DUK_STRIDX_START_RESERVED 369 +#define DUK_STRIDX_START_STRICT_RESERVED 405 +#define DUK_STRIDX_END_RESERVED 414 /* exclusive endpoint */ #if !defined(DUK_SINGLE_FILE) -DUK_INTERNAL_DECL const duk_c_function duk_bi_native_functions[128]; -DUK_INTERNAL_DECL const duk_uint8_t duk_builtins_data[1341]; +DUK_INTERNAL_DECL const duk_c_function duk_bi_native_functions[149]; +DUK_INTERNAL_DECL const duk_uint8_t duk_builtins_data[1955]; #ifdef DUK_USE_BUILTIN_INITJS DUK_INTERNAL_DECL const duk_uint8_t duk_initjs_data[187]; #endif /* DUK_USE_BUILTIN_INITJS */ #endif /* !DUK_SINGLE_FILE */ -#define DUK_BUILTINS_DATA_LENGTH 1341 +#define DUK_BUILTINS_DATA_LENGTH 1955 #ifdef DUK_USE_BUILTIN_INITJS #define DUK_BUILTIN_INITJS_DATA_LENGTH 187 #endif /* DUK_USE_BUILTIN_INITJS */ @@ -2479,353 +3026,456 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_initjs_data[187]; #define DUK_BIDX_LOGGER_CONSTRUCTOR 43 #define DUK_BIDX_LOGGER_PROTOTYPE 44 #define DUK_BIDX_DOUBLE_ERROR 45 +#define DUK_BIDX_ARRAYBUFFER_CONSTRUCTOR 46 +#define DUK_BIDX_ARRAYBUFFER_PROTOTYPE 47 +#define DUK_BIDX_DATAVIEW_CONSTRUCTOR 48 +#define DUK_BIDX_DATAVIEW_PROTOTYPE 49 +#define DUK_BIDX_TYPEDARRAY_PROTOTYPE 50 +#define DUK_BIDX_INT8ARRAY_CONSTRUCTOR 51 +#define DUK_BIDX_INT8ARRAY_PROTOTYPE 52 +#define DUK_BIDX_UINT8ARRAY_CONSTRUCTOR 53 +#define DUK_BIDX_UINT8ARRAY_PROTOTYPE 54 +#define DUK_BIDX_UINT8CLAMPEDARRAY_CONSTRUCTOR 55 +#define DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE 56 +#define DUK_BIDX_INT16ARRAY_CONSTRUCTOR 57 +#define DUK_BIDX_INT16ARRAY_PROTOTYPE 58 +#define DUK_BIDX_UINT16ARRAY_CONSTRUCTOR 59 +#define DUK_BIDX_UINT16ARRAY_PROTOTYPE 60 +#define DUK_BIDX_INT32ARRAY_CONSTRUCTOR 61 +#define DUK_BIDX_INT32ARRAY_PROTOTYPE 62 +#define DUK_BIDX_UINT32ARRAY_CONSTRUCTOR 63 +#define DUK_BIDX_UINT32ARRAY_PROTOTYPE 64 +#define DUK_BIDX_FLOAT32ARRAY_CONSTRUCTOR 65 +#define DUK_BIDX_FLOAT32ARRAY_PROTOTYPE 66 +#define DUK_BIDX_FLOAT64ARRAY_CONSTRUCTOR 67 +#define DUK_BIDX_FLOAT64ARRAY_PROTOTYPE 68 +#define DUK_BIDX_NODEJS_BUFFER_CONSTRUCTOR 69 +#define DUK_BIDX_NODEJS_BUFFER_PROTOTYPE 70 -#define DUK_NUM_BUILTINS 46 +#define DUK_NUM_BUILTINS 71 #elif defined(DUK_USE_DOUBLE_ME) #if !defined(DUK_SINGLE_FILE) -DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; +DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[2624]; #endif /* !DUK_SINGLE_FILE */ -#define DUK_STRDATA_DATA_LENGTH 1943 +#define DUK_STRDATA_DATA_LENGTH 2624 #define DUK_STRDATA_MAX_STRLEN 24 #define DUK_STRIDX_UC_LOGGER 0 /* 'Logger' */ #define DUK_STRIDX_UC_THREAD 1 /* 'Thread' */ #define DUK_STRIDX_UC_POINTER 2 /* 'Pointer' */ -#define DUK_STRIDX_UC_BUFFER 3 /* 'Buffer' */ -#define DUK_STRIDX_DEC_ENV 4 /* 'DecEnv' */ -#define DUK_STRIDX_OBJ_ENV 5 /* 'ObjEnv' */ -#define DUK_STRIDX_EMPTY_STRING 6 /* '' */ -#define DUK_STRIDX_GLOBAL 7 /* 'global' */ -#define DUK_STRIDX_UC_ARGUMENTS 8 /* 'Arguments' */ -#define DUK_STRIDX_JSON 9 /* 'JSON' */ -#define DUK_STRIDX_MATH 10 /* 'Math' */ -#define DUK_STRIDX_UC_ERROR 11 /* 'Error' */ -#define DUK_STRIDX_REG_EXP 12 /* 'RegExp' */ -#define DUK_STRIDX_DATE 13 /* 'Date' */ -#define DUK_STRIDX_UC_NUMBER 14 /* 'Number' */ -#define DUK_STRIDX_UC_BOOLEAN 15 /* 'Boolean' */ -#define DUK_STRIDX_UC_STRING 16 /* 'String' */ -#define DUK_STRIDX_ARRAY 17 /* 'Array' */ -#define DUK_STRIDX_UC_FUNCTION 18 /* 'Function' */ -#define DUK_STRIDX_UC_OBJECT 19 /* 'Object' */ -#define DUK_STRIDX_UC_NULL 20 /* 'Null' */ -#define DUK_STRIDX_UC_UNDEFINED 21 /* 'Undefined' */ -#define DUK_STRIDX_JSON_EXT_FUNCTION2 22 /* '{_func:true}' */ -#define DUK_STRIDX_JSON_EXT_FUNCTION1 23 /* '{"_func":true}' */ -#define DUK_STRIDX_JSON_EXT_NEGINF 24 /* '{"_ninf":true}' */ -#define DUK_STRIDX_JSON_EXT_POSINF 25 /* '{"_inf":true}' */ -#define DUK_STRIDX_JSON_EXT_NAN 26 /* '{"_nan":true}' */ -#define DUK_STRIDX_JSON_EXT_UNDEFINED 27 /* '{"_undef":true}' */ -#define DUK_STRIDX_TO_LOG_STRING 28 /* 'toLogString' */ -#define DUK_STRIDX_CLOG 29 /* 'clog' */ -#define DUK_STRIDX_LC_L 30 /* 'l' */ -#define DUK_STRIDX_LC_N 31 /* 'n' */ -#define DUK_STRIDX_LC_FATAL 32 /* 'fatal' */ -#define DUK_STRIDX_LC_ERROR 33 /* 'error' */ -#define DUK_STRIDX_LC_WARN 34 /* 'warn' */ -#define DUK_STRIDX_LC_DEBUG 35 /* 'debug' */ -#define DUK_STRIDX_LC_TRACE 36 /* 'trace' */ -#define DUK_STRIDX_RAW 37 /* 'raw' */ -#define DUK_STRIDX_FMT 38 /* 'fmt' */ -#define DUK_STRIDX_CURRENT 39 /* 'current' */ -#define DUK_STRIDX_RESUME 40 /* 'resume' */ -#define DUK_STRIDX_COMPACT 41 /* 'compact' */ -#define DUK_STRIDX_JC 42 /* 'jc' */ -#define DUK_STRIDX_JX 43 /* 'jx' */ -#define DUK_STRIDX_BASE64 44 /* 'base64' */ -#define DUK_STRIDX_HEX 45 /* 'hex' */ -#define DUK_STRIDX_DEC 46 /* 'dec' */ -#define DUK_STRIDX_ENC 47 /* 'enc' */ -#define DUK_STRIDX_FIN 48 /* 'fin' */ -#define DUK_STRIDX_GC 49 /* 'gc' */ -#define DUK_STRIDX_ACT 50 /* 'act' */ -#define DUK_STRIDX_LC_INFO 51 /* 'info' */ -#define DUK_STRIDX_VERSION 52 /* 'version' */ -#define DUK_STRIDX_ENV 53 /* 'env' */ -#define DUK_STRIDX_MOD_LOADED 54 /* 'modLoaded' */ -#define DUK_STRIDX_MOD_SEARCH 55 /* 'modSearch' */ -#define DUK_STRIDX_ERR_THROW 56 /* 'errThrow' */ -#define DUK_STRIDX_ERR_CREATE 57 /* 'errCreate' */ -#define DUK_STRIDX_COMPILE 58 /* 'compile' */ -#define DUK_STRIDX_INT_REGBASE 59 /* '\x00Regbase' */ -#define DUK_STRIDX_INT_THREAD 60 /* '\x00Thread' */ -#define DUK_STRIDX_INT_HANDLER 61 /* '\x00Handler' */ -#define DUK_STRIDX_INT_FINALIZER 62 /* '\x00Finalizer' */ -#define DUK_STRIDX_INT_CALLEE 63 /* '\x00Callee' */ -#define DUK_STRIDX_INT_MAP 64 /* '\x00Map' */ -#define DUK_STRIDX_INT_ARGS 65 /* '\x00Args' */ -#define DUK_STRIDX_INT_THIS 66 /* '\x00This' */ -#define DUK_STRIDX_INT_PC2LINE 67 /* '\x00Pc2line' */ -#define DUK_STRIDX_INT_SOURCE 68 /* '\x00Source' */ -#define DUK_STRIDX_INT_VARENV 69 /* '\x00Varenv' */ -#define DUK_STRIDX_INT_LEXENV 70 /* '\x00Lexenv' */ -#define DUK_STRIDX_INT_VARMAP 71 /* '\x00Varmap' */ -#define DUK_STRIDX_INT_FORMALS 72 /* '\x00Formals' */ -#define DUK_STRIDX_INT_BYTECODE 73 /* '\x00Bytecode' */ -#define DUK_STRIDX_INT_NEXT 74 /* '\x00Next' */ -#define DUK_STRIDX_INT_TARGET 75 /* '\x00Target' */ -#define DUK_STRIDX_INT_VALUE 76 /* '\x00Value' */ -#define DUK_STRIDX_LC_POINTER 77 /* 'pointer' */ -#define DUK_STRIDX_LC_BUFFER 78 /* 'buffer' */ -#define DUK_STRIDX_INT_TRACEDATA 79 /* '\x00Tracedata' */ -#define DUK_STRIDX_LINE_NUMBER 80 /* 'lineNumber' */ -#define DUK_STRIDX_FILE_NAME 81 /* 'fileName' */ -#define DUK_STRIDX_PC 82 /* 'pc' */ -#define DUK_STRIDX_STACK 83 /* 'stack' */ -#define DUK_STRIDX_THROW_TYPE_ERROR 84 /* 'ThrowTypeError' */ -#define DUK_STRIDX_DUKTAPE 85 /* 'Duktape' */ -#define DUK_STRIDX_ID 86 /* 'id' */ -#define DUK_STRIDX_REQUIRE 87 /* 'require' */ -#define DUK_STRIDX___PROTO__ 88 /* '__proto__' */ -#define DUK_STRIDX_SET_PROTOTYPE_OF 89 /* 'setPrototypeOf' */ -#define DUK_STRIDX_OWN_KEYS 90 /* 'ownKeys' */ -#define DUK_STRIDX_ENUMERATE 91 /* 'enumerate' */ -#define DUK_STRIDX_DELETE_PROPERTY 92 /* 'deleteProperty' */ -#define DUK_STRIDX_HAS 93 /* 'has' */ -#define DUK_STRIDX_PROXY 94 /* 'Proxy' */ -#define DUK_STRIDX_CALLEE 95 /* 'callee' */ -#define DUK_STRIDX_INVALID_DATE 96 /* 'Invalid Date' */ -#define DUK_STRIDX_BRACKETED_ELLIPSIS 97 /* '[...]' */ -#define DUK_STRIDX_NEWLINE_TAB 98 /* '\n\t' */ -#define DUK_STRIDX_SPACE 99 /* ' ' */ -#define DUK_STRIDX_COMMA 100 /* ',' */ -#define DUK_STRIDX_MINUS_ZERO 101 /* '-0' */ -#define DUK_STRIDX_PLUS_ZERO 102 /* '+0' */ -#define DUK_STRIDX_ZERO 103 /* '0' */ -#define DUK_STRIDX_MINUS_INFINITY 104 /* '-Infinity' */ -#define DUK_STRIDX_PLUS_INFINITY 105 /* '+Infinity' */ -#define DUK_STRIDX_INFINITY 106 /* 'Infinity' */ -#define DUK_STRIDX_LC_OBJECT 107 /* 'object' */ -#define DUK_STRIDX_LC_STRING 108 /* 'string' */ -#define DUK_STRIDX_LC_NUMBER 109 /* 'number' */ -#define DUK_STRIDX_LC_BOOLEAN 110 /* 'boolean' */ -#define DUK_STRIDX_LC_UNDEFINED 111 /* 'undefined' */ -#define DUK_STRIDX_STRINGIFY 112 /* 'stringify' */ -#define DUK_STRIDX_TAN 113 /* 'tan' */ -#define DUK_STRIDX_SQRT 114 /* 'sqrt' */ -#define DUK_STRIDX_SIN 115 /* 'sin' */ -#define DUK_STRIDX_ROUND 116 /* 'round' */ -#define DUK_STRIDX_RANDOM 117 /* 'random' */ -#define DUK_STRIDX_POW 118 /* 'pow' */ -#define DUK_STRIDX_MIN 119 /* 'min' */ -#define DUK_STRIDX_MAX 120 /* 'max' */ -#define DUK_STRIDX_LOG 121 /* 'log' */ -#define DUK_STRIDX_FLOOR 122 /* 'floor' */ -#define DUK_STRIDX_EXP 123 /* 'exp' */ -#define DUK_STRIDX_COS 124 /* 'cos' */ -#define DUK_STRIDX_CEIL 125 /* 'ceil' */ -#define DUK_STRIDX_ATAN2 126 /* 'atan2' */ -#define DUK_STRIDX_ATAN 127 /* 'atan' */ -#define DUK_STRIDX_ASIN 128 /* 'asin' */ -#define DUK_STRIDX_ACOS 129 /* 'acos' */ -#define DUK_STRIDX_ABS 130 /* 'abs' */ -#define DUK_STRIDX_SQRT2 131 /* 'SQRT2' */ -#define DUK_STRIDX_SQRT1_2 132 /* 'SQRT1_2' */ -#define DUK_STRIDX_PI 133 /* 'PI' */ -#define DUK_STRIDX_LOG10E 134 /* 'LOG10E' */ -#define DUK_STRIDX_LOG2E 135 /* 'LOG2E' */ -#define DUK_STRIDX_LN2 136 /* 'LN2' */ -#define DUK_STRIDX_LN10 137 /* 'LN10' */ -#define DUK_STRIDX_E 138 /* 'E' */ -#define DUK_STRIDX_MESSAGE 139 /* 'message' */ -#define DUK_STRIDX_NAME 140 /* 'name' */ -#define DUK_STRIDX_INPUT 141 /* 'input' */ -#define DUK_STRIDX_INDEX 142 /* 'index' */ -#define DUK_STRIDX_ESCAPED_EMPTY_REGEXP 143 /* '(?:)' */ -#define DUK_STRIDX_LAST_INDEX 144 /* 'lastIndex' */ -#define DUK_STRIDX_MULTILINE 145 /* 'multiline' */ -#define DUK_STRIDX_IGNORE_CASE 146 /* 'ignoreCase' */ -#define DUK_STRIDX_SOURCE 147 /* 'source' */ -#define DUK_STRIDX_TEST 148 /* 'test' */ -#define DUK_STRIDX_EXEC 149 /* 'exec' */ -#define DUK_STRIDX_TO_GMT_STRING 150 /* 'toGMTString' */ -#define DUK_STRIDX_SET_YEAR 151 /* 'setYear' */ -#define DUK_STRIDX_GET_YEAR 152 /* 'getYear' */ -#define DUK_STRIDX_TO_JSON 153 /* 'toJSON' */ -#define DUK_STRIDX_TO_ISO_STRING 154 /* 'toISOString' */ -#define DUK_STRIDX_TO_UTC_STRING 155 /* 'toUTCString' */ -#define DUK_STRIDX_SET_UTC_FULL_YEAR 156 /* 'setUTCFullYear' */ -#define DUK_STRIDX_SET_FULL_YEAR 157 /* 'setFullYear' */ -#define DUK_STRIDX_SET_UTC_MONTH 158 /* 'setUTCMonth' */ -#define DUK_STRIDX_SET_MONTH 159 /* 'setMonth' */ -#define DUK_STRIDX_SET_UTC_DATE 160 /* 'setUTCDate' */ -#define DUK_STRIDX_SET_DATE 161 /* 'setDate' */ -#define DUK_STRIDX_SET_UTC_HOURS 162 /* 'setUTCHours' */ -#define DUK_STRIDX_SET_HOURS 163 /* 'setHours' */ -#define DUK_STRIDX_SET_UTC_MINUTES 164 /* 'setUTCMinutes' */ -#define DUK_STRIDX_SET_MINUTES 165 /* 'setMinutes' */ -#define DUK_STRIDX_SET_UTC_SECONDS 166 /* 'setUTCSeconds' */ -#define DUK_STRIDX_SET_SECONDS 167 /* 'setSeconds' */ -#define DUK_STRIDX_SET_UTC_MILLISECONDS 168 /* 'setUTCMilliseconds' */ -#define DUK_STRIDX_SET_MILLISECONDS 169 /* 'setMilliseconds' */ -#define DUK_STRIDX_SET_TIME 170 /* 'setTime' */ -#define DUK_STRIDX_GET_TIMEZONE_OFFSET 171 /* 'getTimezoneOffset' */ -#define DUK_STRIDX_GET_UTC_MILLISECONDS 172 /* 'getUTCMilliseconds' */ -#define DUK_STRIDX_GET_MILLISECONDS 173 /* 'getMilliseconds' */ -#define DUK_STRIDX_GET_UTC_SECONDS 174 /* 'getUTCSeconds' */ -#define DUK_STRIDX_GET_SECONDS 175 /* 'getSeconds' */ -#define DUK_STRIDX_GET_UTC_MINUTES 176 /* 'getUTCMinutes' */ -#define DUK_STRIDX_GET_MINUTES 177 /* 'getMinutes' */ -#define DUK_STRIDX_GET_UTC_HOURS 178 /* 'getUTCHours' */ -#define DUK_STRIDX_GET_HOURS 179 /* 'getHours' */ -#define DUK_STRIDX_GET_UTC_DAY 180 /* 'getUTCDay' */ -#define DUK_STRIDX_GET_DAY 181 /* 'getDay' */ -#define DUK_STRIDX_GET_UTC_DATE 182 /* 'getUTCDate' */ -#define DUK_STRIDX_GET_DATE 183 /* 'getDate' */ -#define DUK_STRIDX_GET_UTC_MONTH 184 /* 'getUTCMonth' */ -#define DUK_STRIDX_GET_MONTH 185 /* 'getMonth' */ -#define DUK_STRIDX_GET_UTC_FULL_YEAR 186 /* 'getUTCFullYear' */ -#define DUK_STRIDX_GET_FULL_YEAR 187 /* 'getFullYear' */ -#define DUK_STRIDX_GET_TIME 188 /* 'getTime' */ -#define DUK_STRIDX_TO_LOCALE_TIME_STRING 189 /* 'toLocaleTimeString' */ -#define DUK_STRIDX_TO_LOCALE_DATE_STRING 190 /* 'toLocaleDateString' */ -#define DUK_STRIDX_TO_TIME_STRING 191 /* 'toTimeString' */ -#define DUK_STRIDX_TO_DATE_STRING 192 /* 'toDateString' */ -#define DUK_STRIDX_NOW 193 /* 'now' */ -#define DUK_STRIDX_UTC 194 /* 'UTC' */ -#define DUK_STRIDX_PARSE 195 /* 'parse' */ -#define DUK_STRIDX_TO_PRECISION 196 /* 'toPrecision' */ -#define DUK_STRIDX_TO_EXPONENTIAL 197 /* 'toExponential' */ -#define DUK_STRIDX_TO_FIXED 198 /* 'toFixed' */ -#define DUK_STRIDX_POSITIVE_INFINITY 199 /* 'POSITIVE_INFINITY' */ -#define DUK_STRIDX_NEGATIVE_INFINITY 200 /* 'NEGATIVE_INFINITY' */ -#define DUK_STRIDX_NAN 201 /* 'NaN' */ -#define DUK_STRIDX_MIN_VALUE 202 /* 'MIN_VALUE' */ -#define DUK_STRIDX_MAX_VALUE 203 /* 'MAX_VALUE' */ -#define DUK_STRIDX_SUBSTR 204 /* 'substr' */ -#define DUK_STRIDX_TRIM 205 /* 'trim' */ -#define DUK_STRIDX_TO_LOCALE_UPPER_CASE 206 /* 'toLocaleUpperCase' */ -#define DUK_STRIDX_TO_UPPER_CASE 207 /* 'toUpperCase' */ -#define DUK_STRIDX_TO_LOCALE_LOWER_CASE 208 /* 'toLocaleLowerCase' */ -#define DUK_STRIDX_TO_LOWER_CASE 209 /* 'toLowerCase' */ -#define DUK_STRIDX_SUBSTRING 210 /* 'substring' */ -#define DUK_STRIDX_SPLIT 211 /* 'split' */ -#define DUK_STRIDX_SEARCH 212 /* 'search' */ -#define DUK_STRIDX_REPLACE 213 /* 'replace' */ -#define DUK_STRIDX_MATCH 214 /* 'match' */ -#define DUK_STRIDX_LOCALE_COMPARE 215 /* 'localeCompare' */ -#define DUK_STRIDX_CHAR_CODE_AT 216 /* 'charCodeAt' */ -#define DUK_STRIDX_CHAR_AT 217 /* 'charAt' */ -#define DUK_STRIDX_FROM_CHAR_CODE 218 /* 'fromCharCode' */ -#define DUK_STRIDX_REDUCE_RIGHT 219 /* 'reduceRight' */ -#define DUK_STRIDX_REDUCE 220 /* 'reduce' */ -#define DUK_STRIDX_FILTER 221 /* 'filter' */ -#define DUK_STRIDX_MAP 222 /* 'map' */ -#define DUK_STRIDX_FOR_EACH 223 /* 'forEach' */ -#define DUK_STRIDX_SOME 224 /* 'some' */ -#define DUK_STRIDX_EVERY 225 /* 'every' */ -#define DUK_STRIDX_LAST_INDEX_OF 226 /* 'lastIndexOf' */ -#define DUK_STRIDX_INDEX_OF 227 /* 'indexOf' */ -#define DUK_STRIDX_UNSHIFT 228 /* 'unshift' */ -#define DUK_STRIDX_SPLICE 229 /* 'splice' */ -#define DUK_STRIDX_SORT 230 /* 'sort' */ -#define DUK_STRIDX_SLICE 231 /* 'slice' */ -#define DUK_STRIDX_SHIFT 232 /* 'shift' */ -#define DUK_STRIDX_REVERSE 233 /* 'reverse' */ -#define DUK_STRIDX_PUSH 234 /* 'push' */ -#define DUK_STRIDX_POP 235 /* 'pop' */ -#define DUK_STRIDX_JOIN 236 /* 'join' */ -#define DUK_STRIDX_CONCAT 237 /* 'concat' */ -#define DUK_STRIDX_IS_ARRAY 238 /* 'isArray' */ -#define DUK_STRIDX_LC_ARGUMENTS 239 /* 'arguments' */ -#define DUK_STRIDX_CALLER 240 /* 'caller' */ -#define DUK_STRIDX_BIND 241 /* 'bind' */ -#define DUK_STRIDX_CALL 242 /* 'call' */ -#define DUK_STRIDX_APPLY 243 /* 'apply' */ -#define DUK_STRIDX_PROPERTY_IS_ENUMERABLE 244 /* 'propertyIsEnumerable' */ -#define DUK_STRIDX_IS_PROTOTYPE_OF 245 /* 'isPrototypeOf' */ -#define DUK_STRIDX_HAS_OWN_PROPERTY 246 /* 'hasOwnProperty' */ -#define DUK_STRIDX_VALUE_OF 247 /* 'valueOf' */ -#define DUK_STRIDX_TO_LOCALE_STRING 248 /* 'toLocaleString' */ -#define DUK_STRIDX_TO_STRING 249 /* 'toString' */ -#define DUK_STRIDX_CONSTRUCTOR 250 /* 'constructor' */ -#define DUK_STRIDX_SET 251 /* 'set' */ -#define DUK_STRIDX_GET 252 /* 'get' */ -#define DUK_STRIDX_ENUMERABLE 253 /* 'enumerable' */ -#define DUK_STRIDX_CONFIGURABLE 254 /* 'configurable' */ -#define DUK_STRIDX_WRITABLE 255 /* 'writable' */ -#define DUK_STRIDX_VALUE 256 /* 'value' */ -#define DUK_STRIDX_KEYS 257 /* 'keys' */ -#define DUK_STRIDX_IS_EXTENSIBLE 258 /* 'isExtensible' */ -#define DUK_STRIDX_IS_FROZEN 259 /* 'isFrozen' */ -#define DUK_STRIDX_IS_SEALED 260 /* 'isSealed' */ -#define DUK_STRIDX_PREVENT_EXTENSIONS 261 /* 'preventExtensions' */ -#define DUK_STRIDX_FREEZE 262 /* 'freeze' */ -#define DUK_STRIDX_SEAL 263 /* 'seal' */ -#define DUK_STRIDX_DEFINE_PROPERTIES 264 /* 'defineProperties' */ -#define DUK_STRIDX_DEFINE_PROPERTY 265 /* 'defineProperty' */ -#define DUK_STRIDX_CREATE 266 /* 'create' */ -#define DUK_STRIDX_GET_OWN_PROPERTY_NAMES 267 /* 'getOwnPropertyNames' */ -#define DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR 268 /* 'getOwnPropertyDescriptor' */ -#define DUK_STRIDX_GET_PROTOTYPE_OF 269 /* 'getPrototypeOf' */ -#define DUK_STRIDX_PROTOTYPE 270 /* 'prototype' */ -#define DUK_STRIDX_LENGTH 271 /* 'length' */ -#define DUK_STRIDX_ALERT 272 /* 'alert' */ -#define DUK_STRIDX_PRINT 273 /* 'print' */ -#define DUK_STRIDX_UNESCAPE 274 /* 'unescape' */ -#define DUK_STRIDX_ESCAPE 275 /* 'escape' */ -#define DUK_STRIDX_ENCODE_URI_COMPONENT 276 /* 'encodeURIComponent' */ -#define DUK_STRIDX_ENCODE_URI 277 /* 'encodeURI' */ -#define DUK_STRIDX_DECODE_URI_COMPONENT 278 /* 'decodeURIComponent' */ -#define DUK_STRIDX_DECODE_URI 279 /* 'decodeURI' */ -#define DUK_STRIDX_IS_FINITE 280 /* 'isFinite' */ -#define DUK_STRIDX_IS_NAN 281 /* 'isNaN' */ -#define DUK_STRIDX_PARSE_FLOAT 282 /* 'parseFloat' */ -#define DUK_STRIDX_PARSE_INT 283 /* 'parseInt' */ -#define DUK_STRIDX_EVAL 284 /* 'eval' */ -#define DUK_STRIDX_URI_ERROR 285 /* 'URIError' */ -#define DUK_STRIDX_TYPE_ERROR 286 /* 'TypeError' */ -#define DUK_STRIDX_SYNTAX_ERROR 287 /* 'SyntaxError' */ -#define DUK_STRIDX_REFERENCE_ERROR 288 /* 'ReferenceError' */ -#define DUK_STRIDX_RANGE_ERROR 289 /* 'RangeError' */ -#define DUK_STRIDX_EVAL_ERROR 290 /* 'EvalError' */ -#define DUK_STRIDX_BREAK 291 /* 'break' */ -#define DUK_STRIDX_CASE 292 /* 'case' */ -#define DUK_STRIDX_CATCH 293 /* 'catch' */ -#define DUK_STRIDX_CONTINUE 294 /* 'continue' */ -#define DUK_STRIDX_DEBUGGER 295 /* 'debugger' */ -#define DUK_STRIDX_DEFAULT 296 /* 'default' */ -#define DUK_STRIDX_DELETE 297 /* 'delete' */ -#define DUK_STRIDX_DO 298 /* 'do' */ -#define DUK_STRIDX_ELSE 299 /* 'else' */ -#define DUK_STRIDX_FINALLY 300 /* 'finally' */ -#define DUK_STRIDX_FOR 301 /* 'for' */ -#define DUK_STRIDX_LC_FUNCTION 302 /* 'function' */ -#define DUK_STRIDX_IF 303 /* 'if' */ -#define DUK_STRIDX_IN 304 /* 'in' */ -#define DUK_STRIDX_INSTANCEOF 305 /* 'instanceof' */ -#define DUK_STRIDX_NEW 306 /* 'new' */ -#define DUK_STRIDX_RETURN 307 /* 'return' */ -#define DUK_STRIDX_SWITCH 308 /* 'switch' */ -#define DUK_STRIDX_THIS 309 /* 'this' */ -#define DUK_STRIDX_THROW 310 /* 'throw' */ -#define DUK_STRIDX_TRY 311 /* 'try' */ -#define DUK_STRIDX_TYPEOF 312 /* 'typeof' */ -#define DUK_STRIDX_VAR 313 /* 'var' */ -#define DUK_STRIDX_VOID 314 /* 'void' */ -#define DUK_STRIDX_WHILE 315 /* 'while' */ -#define DUK_STRIDX_WITH 316 /* 'with' */ -#define DUK_STRIDX_CLASS 317 /* 'class' */ -#define DUK_STRIDX_CONST 318 /* 'const' */ -#define DUK_STRIDX_ENUM 319 /* 'enum' */ -#define DUK_STRIDX_EXPORT 320 /* 'export' */ -#define DUK_STRIDX_EXTENDS 321 /* 'extends' */ -#define DUK_STRIDX_IMPORT 322 /* 'import' */ -#define DUK_STRIDX_SUPER 323 /* 'super' */ -#define DUK_STRIDX_LC_NULL 324 /* 'null' */ -#define DUK_STRIDX_TRUE 325 /* 'true' */ -#define DUK_STRIDX_FALSE 326 /* 'false' */ -#define DUK_STRIDX_IMPLEMENTS 327 /* 'implements' */ -#define DUK_STRIDX_INTERFACE 328 /* 'interface' */ -#define DUK_STRIDX_LET 329 /* 'let' */ -#define DUK_STRIDX_PACKAGE 330 /* 'package' */ -#define DUK_STRIDX_PRIVATE 331 /* 'private' */ -#define DUK_STRIDX_PROTECTED 332 /* 'protected' */ -#define DUK_STRIDX_PUBLIC 333 /* 'public' */ -#define DUK_STRIDX_STATIC 334 /* 'static' */ -#define DUK_STRIDX_YIELD 335 /* 'yield' */ +#define DUK_STRIDX_DEC_ENV 3 /* 'DecEnv' */ +#define DUK_STRIDX_OBJ_ENV 4 /* 'ObjEnv' */ +#define DUK_STRIDX_FLOAT64_ARRAY 5 /* 'Float64Array' */ +#define DUK_STRIDX_FLOAT32_ARRAY 6 /* 'Float32Array' */ +#define DUK_STRIDX_UINT32_ARRAY 7 /* 'Uint32Array' */ +#define DUK_STRIDX_INT32_ARRAY 8 /* 'Int32Array' */ +#define DUK_STRIDX_UINT16_ARRAY 9 /* 'Uint16Array' */ +#define DUK_STRIDX_INT16_ARRAY 10 /* 'Int16Array' */ +#define DUK_STRIDX_UINT8_CLAMPED_ARRAY 11 /* 'Uint8ClampedArray' */ +#define DUK_STRIDX_UINT8_ARRAY 12 /* 'Uint8Array' */ +#define DUK_STRIDX_INT8_ARRAY 13 /* 'Int8Array' */ +#define DUK_STRIDX_DATA_VIEW 14 /* 'DataView' */ +#define DUK_STRIDX_ARRAY_BUFFER 15 /* 'ArrayBuffer' */ +#define DUK_STRIDX_UC_BUFFER 16 /* 'Buffer' */ +#define DUK_STRIDX_EMPTY_STRING 17 /* '' */ +#define DUK_STRIDX_GLOBAL 18 /* 'global' */ +#define DUK_STRIDX_UC_ARGUMENTS 19 /* 'Arguments' */ +#define DUK_STRIDX_JSON 20 /* 'JSON' */ +#define DUK_STRIDX_MATH 21 /* 'Math' */ +#define DUK_STRIDX_UC_ERROR 22 /* 'Error' */ +#define DUK_STRIDX_REG_EXP 23 /* 'RegExp' */ +#define DUK_STRIDX_DATE 24 /* 'Date' */ +#define DUK_STRIDX_UC_NUMBER 25 /* 'Number' */ +#define DUK_STRIDX_UC_BOOLEAN 26 /* 'Boolean' */ +#define DUK_STRIDX_UC_STRING 27 /* 'String' */ +#define DUK_STRIDX_ARRAY 28 /* 'Array' */ +#define DUK_STRIDX_UC_FUNCTION 29 /* 'Function' */ +#define DUK_STRIDX_UC_OBJECT 30 /* 'Object' */ +#define DUK_STRIDX_UC_NULL 31 /* 'Null' */ +#define DUK_STRIDX_UC_UNDEFINED 32 /* 'Undefined' */ +#define DUK_STRIDX_JSON_EXT_FUNCTION2 33 /* '{_func:true}' */ +#define DUK_STRIDX_JSON_EXT_FUNCTION1 34 /* '{"_func":true}' */ +#define DUK_STRIDX_JSON_EXT_NEGINF 35 /* '{"_ninf":true}' */ +#define DUK_STRIDX_JSON_EXT_POSINF 36 /* '{"_inf":true}' */ +#define DUK_STRIDX_JSON_EXT_NAN 37 /* '{"_nan":true}' */ +#define DUK_STRIDX_JSON_EXT_UNDEFINED 38 /* '{"_undef":true}' */ +#define DUK_STRIDX_TO_LOG_STRING 39 /* 'toLogString' */ +#define DUK_STRIDX_CLOG 40 /* 'clog' */ +#define DUK_STRIDX_LC_L 41 /* 'l' */ +#define DUK_STRIDX_LC_N 42 /* 'n' */ +#define DUK_STRIDX_LC_FATAL 43 /* 'fatal' */ +#define DUK_STRIDX_LC_ERROR 44 /* 'error' */ +#define DUK_STRIDX_LC_WARN 45 /* 'warn' */ +#define DUK_STRIDX_LC_DEBUG 46 /* 'debug' */ +#define DUK_STRIDX_LC_TRACE 47 /* 'trace' */ +#define DUK_STRIDX_RAW 48 /* 'raw' */ +#define DUK_STRIDX_FMT 49 /* 'fmt' */ +#define DUK_STRIDX_CURRENT 50 /* 'current' */ +#define DUK_STRIDX_RESUME 51 /* 'resume' */ +#define DUK_STRIDX_COMPACT 52 /* 'compact' */ +#define DUK_STRIDX_JC 53 /* 'jc' */ +#define DUK_STRIDX_JX 54 /* 'jx' */ +#define DUK_STRIDX_BASE64 55 /* 'base64' */ +#define DUK_STRIDX_HEX 56 /* 'hex' */ +#define DUK_STRIDX_DEC 57 /* 'dec' */ +#define DUK_STRIDX_ENC 58 /* 'enc' */ +#define DUK_STRIDX_FIN 59 /* 'fin' */ +#define DUK_STRIDX_GC 60 /* 'gc' */ +#define DUK_STRIDX_ACT 61 /* 'act' */ +#define DUK_STRIDX_LC_INFO 62 /* 'info' */ +#define DUK_STRIDX_VERSION 63 /* 'version' */ +#define DUK_STRIDX_ENV 64 /* 'env' */ +#define DUK_STRIDX_MOD_LOADED 65 /* 'modLoaded' */ +#define DUK_STRIDX_MOD_SEARCH 66 /* 'modSearch' */ +#define DUK_STRIDX_ERR_THROW 67 /* 'errThrow' */ +#define DUK_STRIDX_ERR_CREATE 68 /* 'errCreate' */ +#define DUK_STRIDX_COMPILE 69 /* 'compile' */ +#define DUK_STRIDX_INT_REGBASE 70 /* '\x00Regbase' */ +#define DUK_STRIDX_INT_THREAD 71 /* '\x00Thread' */ +#define DUK_STRIDX_INT_HANDLER 72 /* '\x00Handler' */ +#define DUK_STRIDX_INT_FINALIZER 73 /* '\x00Finalizer' */ +#define DUK_STRIDX_INT_CALLEE 74 /* '\x00Callee' */ +#define DUK_STRIDX_INT_MAP 75 /* '\x00Map' */ +#define DUK_STRIDX_INT_ARGS 76 /* '\x00Args' */ +#define DUK_STRIDX_INT_THIS 77 /* '\x00This' */ +#define DUK_STRIDX_INT_PC2LINE 78 /* '\x00Pc2line' */ +#define DUK_STRIDX_INT_SOURCE 79 /* '\x00Source' */ +#define DUK_STRIDX_INT_VARENV 80 /* '\x00Varenv' */ +#define DUK_STRIDX_INT_LEXENV 81 /* '\x00Lexenv' */ +#define DUK_STRIDX_INT_VARMAP 82 /* '\x00Varmap' */ +#define DUK_STRIDX_INT_FORMALS 83 /* '\x00Formals' */ +#define DUK_STRIDX_INT_BYTECODE 84 /* '\x00Bytecode' */ +#define DUK_STRIDX_INT_NEXT 85 /* '\x00Next' */ +#define DUK_STRIDX_INT_TARGET 86 /* '\x00Target' */ +#define DUK_STRIDX_INT_VALUE 87 /* '\x00Value' */ +#define DUK_STRIDX_LC_POINTER 88 /* 'pointer' */ +#define DUK_STRIDX_INT_TRACEDATA 89 /* '\x00Tracedata' */ +#define DUK_STRIDX_LINE_NUMBER 90 /* 'lineNumber' */ +#define DUK_STRIDX_FILE_NAME 91 /* 'fileName' */ +#define DUK_STRIDX_PC 92 /* 'pc' */ +#define DUK_STRIDX_STACK 93 /* 'stack' */ +#define DUK_STRIDX_THROW_TYPE_ERROR 94 /* 'ThrowTypeError' */ +#define DUK_STRIDX_DUKTAPE 95 /* 'Duktape' */ +#define DUK_STRIDX_SET_FLOAT64 96 /* 'setFloat64' */ +#define DUK_STRIDX_SET_FLOAT32 97 /* 'setFloat32' */ +#define DUK_STRIDX_SET_UINT32 98 /* 'setUint32' */ +#define DUK_STRIDX_SET_INT32 99 /* 'setInt32' */ +#define DUK_STRIDX_SET_UINT16 100 /* 'setUint16' */ +#define DUK_STRIDX_SET_INT16 101 /* 'setInt16' */ +#define DUK_STRIDX_SET_UINT8 102 /* 'setUint8' */ +#define DUK_STRIDX_SET_INT8 103 /* 'setInt8' */ +#define DUK_STRIDX_GET_FLOAT64 104 /* 'getFloat64' */ +#define DUK_STRIDX_GET_FLOAT32 105 /* 'getFloat32' */ +#define DUK_STRIDX_GET_UINT32 106 /* 'getUint32' */ +#define DUK_STRIDX_GET_INT32 107 /* 'getInt32' */ +#define DUK_STRIDX_GET_UINT16 108 /* 'getUint16' */ +#define DUK_STRIDX_GET_INT16 109 /* 'getInt16' */ +#define DUK_STRIDX_GET_UINT8 110 /* 'getUint8' */ +#define DUK_STRIDX_GET_INT8 111 /* 'getInt8' */ +#define DUK_STRIDX_SUBARRAY 112 /* 'subarray' */ +#define DUK_STRIDX_BYTES_PER_ELEMENT 113 /* 'BYTES_PER_ELEMENT' */ +#define DUK_STRIDX_BYTE_OFFSET 114 /* 'byteOffset' */ +#define DUK_STRIDX_LC_BUFFER 115 /* 'buffer' */ +#define DUK_STRIDX_IS_VIEW 116 /* 'isView' */ +#define DUK_STRIDX_DATA 117 /* 'data' */ +#define DUK_STRIDX_TYPE 118 /* 'type' */ +#define DUK_STRIDX_WRITE_INT_BE 119 /* 'writeIntBE' */ +#define DUK_STRIDX_WRITE_INT_LE 120 /* 'writeIntLE' */ +#define DUK_STRIDX_WRITE_UINT_BE 121 /* 'writeUIntBE' */ +#define DUK_STRIDX_WRITE_UINT_LE 122 /* 'writeUIntLE' */ +#define DUK_STRIDX_WRITE_DOUBLE_BE 123 /* 'writeDoubleBE' */ +#define DUK_STRIDX_WRITE_DOUBLE_LE 124 /* 'writeDoubleLE' */ +#define DUK_STRIDX_WRITE_FLOAT_BE 125 /* 'writeFloatBE' */ +#define DUK_STRIDX_WRITE_FLOAT_LE 126 /* 'writeFloatLE' */ +#define DUK_STRIDX_WRITE_INT32_BE 127 /* 'writeInt32BE' */ +#define DUK_STRIDX_WRITE_INT32_LE 128 /* 'writeInt32LE' */ +#define DUK_STRIDX_WRITE_UINT32_BE 129 /* 'writeUInt32BE' */ +#define DUK_STRIDX_WRITE_UINT32_LE 130 /* 'writeUInt32LE' */ +#define DUK_STRIDX_WRITE_INT16_BE 131 /* 'writeInt16BE' */ +#define DUK_STRIDX_WRITE_INT16_LE 132 /* 'writeInt16LE' */ +#define DUK_STRIDX_WRITE_UINT16_BE 133 /* 'writeUInt16BE' */ +#define DUK_STRIDX_WRITE_UINT16_LE 134 /* 'writeUInt16LE' */ +#define DUK_STRIDX_WRITE_INT8 135 /* 'writeInt8' */ +#define DUK_STRIDX_WRITE_UINT8 136 /* 'writeUInt8' */ +#define DUK_STRIDX_READ_INT_BE 137 /* 'readIntBE' */ +#define DUK_STRIDX_READ_INT_LE 138 /* 'readIntLE' */ +#define DUK_STRIDX_READ_UINT_BE 139 /* 'readUIntBE' */ +#define DUK_STRIDX_READ_UINT_LE 140 /* 'readUIntLE' */ +#define DUK_STRIDX_READ_DOUBLE_BE 141 /* 'readDoubleBE' */ +#define DUK_STRIDX_READ_DOUBLE_LE 142 /* 'readDoubleLE' */ +#define DUK_STRIDX_READ_FLOAT_BE 143 /* 'readFloatBE' */ +#define DUK_STRIDX_READ_FLOAT_LE 144 /* 'readFloatLE' */ +#define DUK_STRIDX_READ_INT32_BE 145 /* 'readInt32BE' */ +#define DUK_STRIDX_READ_INT32_LE 146 /* 'readInt32LE' */ +#define DUK_STRIDX_READ_UINT32_BE 147 /* 'readUInt32BE' */ +#define DUK_STRIDX_READ_UINT32_LE 148 /* 'readUInt32LE' */ +#define DUK_STRIDX_READ_INT16_BE 149 /* 'readInt16BE' */ +#define DUK_STRIDX_READ_INT16_LE 150 /* 'readInt16LE' */ +#define DUK_STRIDX_READ_UINT16_BE 151 /* 'readUInt16BE' */ +#define DUK_STRIDX_READ_UINT16_LE 152 /* 'readUInt16LE' */ +#define DUK_STRIDX_READ_INT8 153 /* 'readInt8' */ +#define DUK_STRIDX_READ_UINT8 154 /* 'readUInt8' */ +#define DUK_STRIDX_COPY 155 /* 'copy' */ +#define DUK_STRIDX_EQUALS 156 /* 'equals' */ +#define DUK_STRIDX_FILL 157 /* 'fill' */ +#define DUK_STRIDX_WRITE 158 /* 'write' */ +#define DUK_STRIDX_COMPARE 159 /* 'compare' */ +#define DUK_STRIDX_BYTE_LENGTH 160 /* 'byteLength' */ +#define DUK_STRIDX_IS_BUFFER 161 /* 'isBuffer' */ +#define DUK_STRIDX_IS_ENCODING 162 /* 'isEncoding' */ +#define DUK_STRIDX_EXPORTS 163 /* 'exports' */ +#define DUK_STRIDX_ID 164 /* 'id' */ +#define DUK_STRIDX_REQUIRE 165 /* 'require' */ +#define DUK_STRIDX___PROTO__ 166 /* '__proto__' */ +#define DUK_STRIDX_SET_PROTOTYPE_OF 167 /* 'setPrototypeOf' */ +#define DUK_STRIDX_OWN_KEYS 168 /* 'ownKeys' */ +#define DUK_STRIDX_ENUMERATE 169 /* 'enumerate' */ +#define DUK_STRIDX_DELETE_PROPERTY 170 /* 'deleteProperty' */ +#define DUK_STRIDX_HAS 171 /* 'has' */ +#define DUK_STRIDX_PROXY 172 /* 'Proxy' */ +#define DUK_STRIDX_CALLEE 173 /* 'callee' */ +#define DUK_STRIDX_INVALID_DATE 174 /* 'Invalid Date' */ +#define DUK_STRIDX_BRACKETED_ELLIPSIS 175 /* '[...]' */ +#define DUK_STRIDX_NEWLINE_TAB 176 /* '\n\t' */ +#define DUK_STRIDX_SPACE 177 /* ' ' */ +#define DUK_STRIDX_COMMA 178 /* ',' */ +#define DUK_STRIDX_MINUS_ZERO 179 /* '-0' */ +#define DUK_STRIDX_PLUS_ZERO 180 /* '+0' */ +#define DUK_STRIDX_ZERO 181 /* '0' */ +#define DUK_STRIDX_MINUS_INFINITY 182 /* '-Infinity' */ +#define DUK_STRIDX_PLUS_INFINITY 183 /* '+Infinity' */ +#define DUK_STRIDX_INFINITY 184 /* 'Infinity' */ +#define DUK_STRIDX_LC_OBJECT 185 /* 'object' */ +#define DUK_STRIDX_LC_STRING 186 /* 'string' */ +#define DUK_STRIDX_LC_NUMBER 187 /* 'number' */ +#define DUK_STRIDX_LC_BOOLEAN 188 /* 'boolean' */ +#define DUK_STRIDX_LC_UNDEFINED 189 /* 'undefined' */ +#define DUK_STRIDX_STRINGIFY 190 /* 'stringify' */ +#define DUK_STRIDX_TAN 191 /* 'tan' */ +#define DUK_STRIDX_SQRT 192 /* 'sqrt' */ +#define DUK_STRIDX_SIN 193 /* 'sin' */ +#define DUK_STRIDX_ROUND 194 /* 'round' */ +#define DUK_STRIDX_RANDOM 195 /* 'random' */ +#define DUK_STRIDX_POW 196 /* 'pow' */ +#define DUK_STRIDX_MIN 197 /* 'min' */ +#define DUK_STRIDX_MAX 198 /* 'max' */ +#define DUK_STRIDX_LOG 199 /* 'log' */ +#define DUK_STRIDX_FLOOR 200 /* 'floor' */ +#define DUK_STRIDX_EXP 201 /* 'exp' */ +#define DUK_STRIDX_COS 202 /* 'cos' */ +#define DUK_STRIDX_CEIL 203 /* 'ceil' */ +#define DUK_STRIDX_ATAN2 204 /* 'atan2' */ +#define DUK_STRIDX_ATAN 205 /* 'atan' */ +#define DUK_STRIDX_ASIN 206 /* 'asin' */ +#define DUK_STRIDX_ACOS 207 /* 'acos' */ +#define DUK_STRIDX_ABS 208 /* 'abs' */ +#define DUK_STRIDX_SQRT2 209 /* 'SQRT2' */ +#define DUK_STRIDX_SQRT1_2 210 /* 'SQRT1_2' */ +#define DUK_STRIDX_PI 211 /* 'PI' */ +#define DUK_STRIDX_LOG10E 212 /* 'LOG10E' */ +#define DUK_STRIDX_LOG2E 213 /* 'LOG2E' */ +#define DUK_STRIDX_LN2 214 /* 'LN2' */ +#define DUK_STRIDX_LN10 215 /* 'LN10' */ +#define DUK_STRIDX_E 216 /* 'E' */ +#define DUK_STRIDX_MESSAGE 217 /* 'message' */ +#define DUK_STRIDX_NAME 218 /* 'name' */ +#define DUK_STRIDX_INPUT 219 /* 'input' */ +#define DUK_STRIDX_INDEX 220 /* 'index' */ +#define DUK_STRIDX_ESCAPED_EMPTY_REGEXP 221 /* '(?:)' */ +#define DUK_STRIDX_LAST_INDEX 222 /* 'lastIndex' */ +#define DUK_STRIDX_MULTILINE 223 /* 'multiline' */ +#define DUK_STRIDX_IGNORE_CASE 224 /* 'ignoreCase' */ +#define DUK_STRIDX_SOURCE 225 /* 'source' */ +#define DUK_STRIDX_TEST 226 /* 'test' */ +#define DUK_STRIDX_EXEC 227 /* 'exec' */ +#define DUK_STRIDX_TO_GMT_STRING 228 /* 'toGMTString' */ +#define DUK_STRIDX_SET_YEAR 229 /* 'setYear' */ +#define DUK_STRIDX_GET_YEAR 230 /* 'getYear' */ +#define DUK_STRIDX_TO_JSON 231 /* 'toJSON' */ +#define DUK_STRIDX_TO_ISO_STRING 232 /* 'toISOString' */ +#define DUK_STRIDX_TO_UTC_STRING 233 /* 'toUTCString' */ +#define DUK_STRIDX_SET_UTC_FULL_YEAR 234 /* 'setUTCFullYear' */ +#define DUK_STRIDX_SET_FULL_YEAR 235 /* 'setFullYear' */ +#define DUK_STRIDX_SET_UTC_MONTH 236 /* 'setUTCMonth' */ +#define DUK_STRIDX_SET_MONTH 237 /* 'setMonth' */ +#define DUK_STRIDX_SET_UTC_DATE 238 /* 'setUTCDate' */ +#define DUK_STRIDX_SET_DATE 239 /* 'setDate' */ +#define DUK_STRIDX_SET_UTC_HOURS 240 /* 'setUTCHours' */ +#define DUK_STRIDX_SET_HOURS 241 /* 'setHours' */ +#define DUK_STRIDX_SET_UTC_MINUTES 242 /* 'setUTCMinutes' */ +#define DUK_STRIDX_SET_MINUTES 243 /* 'setMinutes' */ +#define DUK_STRIDX_SET_UTC_SECONDS 244 /* 'setUTCSeconds' */ +#define DUK_STRIDX_SET_SECONDS 245 /* 'setSeconds' */ +#define DUK_STRIDX_SET_UTC_MILLISECONDS 246 /* 'setUTCMilliseconds' */ +#define DUK_STRIDX_SET_MILLISECONDS 247 /* 'setMilliseconds' */ +#define DUK_STRIDX_SET_TIME 248 /* 'setTime' */ +#define DUK_STRIDX_GET_TIMEZONE_OFFSET 249 /* 'getTimezoneOffset' */ +#define DUK_STRIDX_GET_UTC_MILLISECONDS 250 /* 'getUTCMilliseconds' */ +#define DUK_STRIDX_GET_MILLISECONDS 251 /* 'getMilliseconds' */ +#define DUK_STRIDX_GET_UTC_SECONDS 252 /* 'getUTCSeconds' */ +#define DUK_STRIDX_GET_SECONDS 253 /* 'getSeconds' */ +#define DUK_STRIDX_GET_UTC_MINUTES 254 /* 'getUTCMinutes' */ +#define DUK_STRIDX_GET_MINUTES 255 /* 'getMinutes' */ +#define DUK_STRIDX_GET_UTC_HOURS 256 /* 'getUTCHours' */ +#define DUK_STRIDX_GET_HOURS 257 /* 'getHours' */ +#define DUK_STRIDX_GET_UTC_DAY 258 /* 'getUTCDay' */ +#define DUK_STRIDX_GET_DAY 259 /* 'getDay' */ +#define DUK_STRIDX_GET_UTC_DATE 260 /* 'getUTCDate' */ +#define DUK_STRIDX_GET_DATE 261 /* 'getDate' */ +#define DUK_STRIDX_GET_UTC_MONTH 262 /* 'getUTCMonth' */ +#define DUK_STRIDX_GET_MONTH 263 /* 'getMonth' */ +#define DUK_STRIDX_GET_UTC_FULL_YEAR 264 /* 'getUTCFullYear' */ +#define DUK_STRIDX_GET_FULL_YEAR 265 /* 'getFullYear' */ +#define DUK_STRIDX_GET_TIME 266 /* 'getTime' */ +#define DUK_STRIDX_TO_LOCALE_TIME_STRING 267 /* 'toLocaleTimeString' */ +#define DUK_STRIDX_TO_LOCALE_DATE_STRING 268 /* 'toLocaleDateString' */ +#define DUK_STRIDX_TO_TIME_STRING 269 /* 'toTimeString' */ +#define DUK_STRIDX_TO_DATE_STRING 270 /* 'toDateString' */ +#define DUK_STRIDX_NOW 271 /* 'now' */ +#define DUK_STRIDX_UTC 272 /* 'UTC' */ +#define DUK_STRIDX_PARSE 273 /* 'parse' */ +#define DUK_STRIDX_TO_PRECISION 274 /* 'toPrecision' */ +#define DUK_STRIDX_TO_EXPONENTIAL 275 /* 'toExponential' */ +#define DUK_STRIDX_TO_FIXED 276 /* 'toFixed' */ +#define DUK_STRIDX_POSITIVE_INFINITY 277 /* 'POSITIVE_INFINITY' */ +#define DUK_STRIDX_NEGATIVE_INFINITY 278 /* 'NEGATIVE_INFINITY' */ +#define DUK_STRIDX_NAN 279 /* 'NaN' */ +#define DUK_STRIDX_MIN_VALUE 280 /* 'MIN_VALUE' */ +#define DUK_STRIDX_MAX_VALUE 281 /* 'MAX_VALUE' */ +#define DUK_STRIDX_SUBSTR 282 /* 'substr' */ +#define DUK_STRIDX_TRIM 283 /* 'trim' */ +#define DUK_STRIDX_TO_LOCALE_UPPER_CASE 284 /* 'toLocaleUpperCase' */ +#define DUK_STRIDX_TO_UPPER_CASE 285 /* 'toUpperCase' */ +#define DUK_STRIDX_TO_LOCALE_LOWER_CASE 286 /* 'toLocaleLowerCase' */ +#define DUK_STRIDX_TO_LOWER_CASE 287 /* 'toLowerCase' */ +#define DUK_STRIDX_SUBSTRING 288 /* 'substring' */ +#define DUK_STRIDX_SPLIT 289 /* 'split' */ +#define DUK_STRIDX_SEARCH 290 /* 'search' */ +#define DUK_STRIDX_REPLACE 291 /* 'replace' */ +#define DUK_STRIDX_MATCH 292 /* 'match' */ +#define DUK_STRIDX_LOCALE_COMPARE 293 /* 'localeCompare' */ +#define DUK_STRIDX_CHAR_CODE_AT 294 /* 'charCodeAt' */ +#define DUK_STRIDX_CHAR_AT 295 /* 'charAt' */ +#define DUK_STRIDX_FROM_CHAR_CODE 296 /* 'fromCharCode' */ +#define DUK_STRIDX_REDUCE_RIGHT 297 /* 'reduceRight' */ +#define DUK_STRIDX_REDUCE 298 /* 'reduce' */ +#define DUK_STRIDX_FILTER 299 /* 'filter' */ +#define DUK_STRIDX_MAP 300 /* 'map' */ +#define DUK_STRIDX_FOR_EACH 301 /* 'forEach' */ +#define DUK_STRIDX_SOME 302 /* 'some' */ +#define DUK_STRIDX_EVERY 303 /* 'every' */ +#define DUK_STRIDX_LAST_INDEX_OF 304 /* 'lastIndexOf' */ +#define DUK_STRIDX_INDEX_OF 305 /* 'indexOf' */ +#define DUK_STRIDX_UNSHIFT 306 /* 'unshift' */ +#define DUK_STRIDX_SPLICE 307 /* 'splice' */ +#define DUK_STRIDX_SORT 308 /* 'sort' */ +#define DUK_STRIDX_SLICE 309 /* 'slice' */ +#define DUK_STRIDX_SHIFT 310 /* 'shift' */ +#define DUK_STRIDX_REVERSE 311 /* 'reverse' */ +#define DUK_STRIDX_PUSH 312 /* 'push' */ +#define DUK_STRIDX_POP 313 /* 'pop' */ +#define DUK_STRIDX_JOIN 314 /* 'join' */ +#define DUK_STRIDX_CONCAT 315 /* 'concat' */ +#define DUK_STRIDX_IS_ARRAY 316 /* 'isArray' */ +#define DUK_STRIDX_LC_ARGUMENTS 317 /* 'arguments' */ +#define DUK_STRIDX_CALLER 318 /* 'caller' */ +#define DUK_STRIDX_BIND 319 /* 'bind' */ +#define DUK_STRIDX_CALL 320 /* 'call' */ +#define DUK_STRIDX_APPLY 321 /* 'apply' */ +#define DUK_STRIDX_PROPERTY_IS_ENUMERABLE 322 /* 'propertyIsEnumerable' */ +#define DUK_STRIDX_IS_PROTOTYPE_OF 323 /* 'isPrototypeOf' */ +#define DUK_STRIDX_HAS_OWN_PROPERTY 324 /* 'hasOwnProperty' */ +#define DUK_STRIDX_VALUE_OF 325 /* 'valueOf' */ +#define DUK_STRIDX_TO_LOCALE_STRING 326 /* 'toLocaleString' */ +#define DUK_STRIDX_TO_STRING 327 /* 'toString' */ +#define DUK_STRIDX_CONSTRUCTOR 328 /* 'constructor' */ +#define DUK_STRIDX_SET 329 /* 'set' */ +#define DUK_STRIDX_GET 330 /* 'get' */ +#define DUK_STRIDX_ENUMERABLE 331 /* 'enumerable' */ +#define DUK_STRIDX_CONFIGURABLE 332 /* 'configurable' */ +#define DUK_STRIDX_WRITABLE 333 /* 'writable' */ +#define DUK_STRIDX_VALUE 334 /* 'value' */ +#define DUK_STRIDX_KEYS 335 /* 'keys' */ +#define DUK_STRIDX_IS_EXTENSIBLE 336 /* 'isExtensible' */ +#define DUK_STRIDX_IS_FROZEN 337 /* 'isFrozen' */ +#define DUK_STRIDX_IS_SEALED 338 /* 'isSealed' */ +#define DUK_STRIDX_PREVENT_EXTENSIONS 339 /* 'preventExtensions' */ +#define DUK_STRIDX_FREEZE 340 /* 'freeze' */ +#define DUK_STRIDX_SEAL 341 /* 'seal' */ +#define DUK_STRIDX_DEFINE_PROPERTIES 342 /* 'defineProperties' */ +#define DUK_STRIDX_DEFINE_PROPERTY 343 /* 'defineProperty' */ +#define DUK_STRIDX_CREATE 344 /* 'create' */ +#define DUK_STRIDX_GET_OWN_PROPERTY_NAMES 345 /* 'getOwnPropertyNames' */ +#define DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR 346 /* 'getOwnPropertyDescriptor' */ +#define DUK_STRIDX_GET_PROTOTYPE_OF 347 /* 'getPrototypeOf' */ +#define DUK_STRIDX_PROTOTYPE 348 /* 'prototype' */ +#define DUK_STRIDX_LENGTH 349 /* 'length' */ +#define DUK_STRIDX_ALERT 350 /* 'alert' */ +#define DUK_STRIDX_PRINT 351 /* 'print' */ +#define DUK_STRIDX_UNESCAPE 352 /* 'unescape' */ +#define DUK_STRIDX_ESCAPE 353 /* 'escape' */ +#define DUK_STRIDX_ENCODE_URI_COMPONENT 354 /* 'encodeURIComponent' */ +#define DUK_STRIDX_ENCODE_URI 355 /* 'encodeURI' */ +#define DUK_STRIDX_DECODE_URI_COMPONENT 356 /* 'decodeURIComponent' */ +#define DUK_STRIDX_DECODE_URI 357 /* 'decodeURI' */ +#define DUK_STRIDX_IS_FINITE 358 /* 'isFinite' */ +#define DUK_STRIDX_IS_NAN 359 /* 'isNaN' */ +#define DUK_STRIDX_PARSE_FLOAT 360 /* 'parseFloat' */ +#define DUK_STRIDX_PARSE_INT 361 /* 'parseInt' */ +#define DUK_STRIDX_EVAL 362 /* 'eval' */ +#define DUK_STRIDX_URI_ERROR 363 /* 'URIError' */ +#define DUK_STRIDX_TYPE_ERROR 364 /* 'TypeError' */ +#define DUK_STRIDX_SYNTAX_ERROR 365 /* 'SyntaxError' */ +#define DUK_STRIDX_REFERENCE_ERROR 366 /* 'ReferenceError' */ +#define DUK_STRIDX_RANGE_ERROR 367 /* 'RangeError' */ +#define DUK_STRIDX_EVAL_ERROR 368 /* 'EvalError' */ +#define DUK_STRIDX_BREAK 369 /* 'break' */ +#define DUK_STRIDX_CASE 370 /* 'case' */ +#define DUK_STRIDX_CATCH 371 /* 'catch' */ +#define DUK_STRIDX_CONTINUE 372 /* 'continue' */ +#define DUK_STRIDX_DEBUGGER 373 /* 'debugger' */ +#define DUK_STRIDX_DEFAULT 374 /* 'default' */ +#define DUK_STRIDX_DELETE 375 /* 'delete' */ +#define DUK_STRIDX_DO 376 /* 'do' */ +#define DUK_STRIDX_ELSE 377 /* 'else' */ +#define DUK_STRIDX_FINALLY 378 /* 'finally' */ +#define DUK_STRIDX_FOR 379 /* 'for' */ +#define DUK_STRIDX_LC_FUNCTION 380 /* 'function' */ +#define DUK_STRIDX_IF 381 /* 'if' */ +#define DUK_STRIDX_IN 382 /* 'in' */ +#define DUK_STRIDX_INSTANCEOF 383 /* 'instanceof' */ +#define DUK_STRIDX_NEW 384 /* 'new' */ +#define DUK_STRIDX_RETURN 385 /* 'return' */ +#define DUK_STRIDX_SWITCH 386 /* 'switch' */ +#define DUK_STRIDX_THIS 387 /* 'this' */ +#define DUK_STRIDX_THROW 388 /* 'throw' */ +#define DUK_STRIDX_TRY 389 /* 'try' */ +#define DUK_STRIDX_TYPEOF 390 /* 'typeof' */ +#define DUK_STRIDX_VAR 391 /* 'var' */ +#define DUK_STRIDX_CONST 392 /* 'const' */ +#define DUK_STRIDX_VOID 393 /* 'void' */ +#define DUK_STRIDX_WHILE 394 /* 'while' */ +#define DUK_STRIDX_WITH 395 /* 'with' */ +#define DUK_STRIDX_CLASS 396 /* 'class' */ +#define DUK_STRIDX_ENUM 397 /* 'enum' */ +#define DUK_STRIDX_EXPORT 398 /* 'export' */ +#define DUK_STRIDX_EXTENDS 399 /* 'extends' */ +#define DUK_STRIDX_IMPORT 400 /* 'import' */ +#define DUK_STRIDX_SUPER 401 /* 'super' */ +#define DUK_STRIDX_LC_NULL 402 /* 'null' */ +#define DUK_STRIDX_TRUE 403 /* 'true' */ +#define DUK_STRIDX_FALSE 404 /* 'false' */ +#define DUK_STRIDX_IMPLEMENTS 405 /* 'implements' */ +#define DUK_STRIDX_INTERFACE 406 /* 'interface' */ +#define DUK_STRIDX_LET 407 /* 'let' */ +#define DUK_STRIDX_PACKAGE 408 /* 'package' */ +#define DUK_STRIDX_PRIVATE 409 /* 'private' */ +#define DUK_STRIDX_PROTECTED 410 /* 'protected' */ +#define DUK_STRIDX_PUBLIC 411 /* 'public' */ +#define DUK_STRIDX_STATIC 412 /* 'static' */ +#define DUK_STRIDX_YIELD 413 /* 'yield' */ #define DUK_HEAP_STRING_UC_LOGGER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_LOGGER) #define DUK_HTHREAD_STRING_UC_LOGGER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_LOGGER) @@ -2833,12 +3483,34 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; #define DUK_HTHREAD_STRING_UC_THREAD(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_THREAD) #define DUK_HEAP_STRING_UC_POINTER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_POINTER) #define DUK_HTHREAD_STRING_UC_POINTER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_POINTER) -#define DUK_HEAP_STRING_UC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BUFFER) -#define DUK_HTHREAD_STRING_UC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BUFFER) #define DUK_HEAP_STRING_DEC_ENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC_ENV) #define DUK_HTHREAD_STRING_DEC_ENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC_ENV) #define DUK_HEAP_STRING_OBJ_ENV(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OBJ_ENV) #define DUK_HTHREAD_STRING_OBJ_ENV(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OBJ_ENV) +#define DUK_HEAP_STRING_FLOAT64_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOAT64_ARRAY) +#define DUK_HTHREAD_STRING_FLOAT64_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOAT64_ARRAY) +#define DUK_HEAP_STRING_FLOAT32_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOAT32_ARRAY) +#define DUK_HTHREAD_STRING_FLOAT32_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOAT32_ARRAY) +#define DUK_HEAP_STRING_UINT32_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT32_ARRAY) +#define DUK_HTHREAD_STRING_UINT32_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT32_ARRAY) +#define DUK_HEAP_STRING_INT32_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT32_ARRAY) +#define DUK_HTHREAD_STRING_INT32_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT32_ARRAY) +#define DUK_HEAP_STRING_UINT16_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT16_ARRAY) +#define DUK_HTHREAD_STRING_UINT16_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT16_ARRAY) +#define DUK_HEAP_STRING_INT16_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT16_ARRAY) +#define DUK_HTHREAD_STRING_INT16_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT16_ARRAY) +#define DUK_HEAP_STRING_UINT8_CLAMPED_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT8_CLAMPED_ARRAY) +#define DUK_HTHREAD_STRING_UINT8_CLAMPED_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT8_CLAMPED_ARRAY) +#define DUK_HEAP_STRING_UINT8_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UINT8_ARRAY) +#define DUK_HTHREAD_STRING_UINT8_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UINT8_ARRAY) +#define DUK_HEAP_STRING_INT8_ARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT8_ARRAY) +#define DUK_HTHREAD_STRING_INT8_ARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT8_ARRAY) +#define DUK_HEAP_STRING_DATA_VIEW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATA_VIEW) +#define DUK_HTHREAD_STRING_DATA_VIEW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATA_VIEW) +#define DUK_HEAP_STRING_ARRAY_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY_BUFFER) +#define DUK_HTHREAD_STRING_ARRAY_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY_BUFFER) +#define DUK_HEAP_STRING_UC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BUFFER) +#define DUK_HTHREAD_STRING_UC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BUFFER) #define DUK_HEAP_STRING_EMPTY_STRING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EMPTY_STRING) #define DUK_HTHREAD_STRING_EMPTY_STRING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EMPTY_STRING) #define DUK_HEAP_STRING_GLOBAL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GLOBAL) @@ -2983,8 +3655,6 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; #define DUK_HTHREAD_STRING_INT_VALUE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VALUE) #define DUK_HEAP_STRING_LC_POINTER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_POINTER) #define DUK_HTHREAD_STRING_LC_POINTER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_POINTER) -#define DUK_HEAP_STRING_LC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BUFFER) -#define DUK_HTHREAD_STRING_LC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BUFFER) #define DUK_HEAP_STRING_INT_TRACEDATA(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TRACEDATA) #define DUK_HTHREAD_STRING_INT_TRACEDATA(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TRACEDATA) #define DUK_HEAP_STRING_LINE_NUMBER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LINE_NUMBER) @@ -2999,6 +3669,142 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; #define DUK_HTHREAD_STRING_THROW_TYPE_ERROR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW_TYPE_ERROR) #define DUK_HEAP_STRING_DUKTAPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DUKTAPE) #define DUK_HTHREAD_STRING_DUKTAPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DUKTAPE) +#define DUK_HEAP_STRING_SET_FLOAT64(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FLOAT64) +#define DUK_HTHREAD_STRING_SET_FLOAT64(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FLOAT64) +#define DUK_HEAP_STRING_SET_FLOAT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FLOAT32) +#define DUK_HTHREAD_STRING_SET_FLOAT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FLOAT32) +#define DUK_HEAP_STRING_SET_UINT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UINT32) +#define DUK_HTHREAD_STRING_SET_UINT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UINT32) +#define DUK_HEAP_STRING_SET_INT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_INT32) +#define DUK_HTHREAD_STRING_SET_INT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_INT32) +#define DUK_HEAP_STRING_SET_UINT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UINT16) +#define DUK_HTHREAD_STRING_SET_UINT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UINT16) +#define DUK_HEAP_STRING_SET_INT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_INT16) +#define DUK_HTHREAD_STRING_SET_INT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_INT16) +#define DUK_HEAP_STRING_SET_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UINT8) +#define DUK_HTHREAD_STRING_SET_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UINT8) +#define DUK_HEAP_STRING_SET_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_INT8) +#define DUK_HTHREAD_STRING_SET_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_INT8) +#define DUK_HEAP_STRING_GET_FLOAT64(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FLOAT64) +#define DUK_HTHREAD_STRING_GET_FLOAT64(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FLOAT64) +#define DUK_HEAP_STRING_GET_FLOAT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FLOAT32) +#define DUK_HTHREAD_STRING_GET_FLOAT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FLOAT32) +#define DUK_HEAP_STRING_GET_UINT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UINT32) +#define DUK_HTHREAD_STRING_GET_UINT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UINT32) +#define DUK_HEAP_STRING_GET_INT32(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_INT32) +#define DUK_HTHREAD_STRING_GET_INT32(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_INT32) +#define DUK_HEAP_STRING_GET_UINT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UINT16) +#define DUK_HTHREAD_STRING_GET_UINT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UINT16) +#define DUK_HEAP_STRING_GET_INT16(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_INT16) +#define DUK_HTHREAD_STRING_GET_INT16(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_INT16) +#define DUK_HEAP_STRING_GET_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UINT8) +#define DUK_HTHREAD_STRING_GET_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UINT8) +#define DUK_HEAP_STRING_GET_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_INT8) +#define DUK_HTHREAD_STRING_GET_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_INT8) +#define DUK_HEAP_STRING_SUBARRAY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBARRAY) +#define DUK_HTHREAD_STRING_SUBARRAY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBARRAY) +#define DUK_HEAP_STRING_BYTES_PER_ELEMENT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTES_PER_ELEMENT) +#define DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTES_PER_ELEMENT) +#define DUK_HEAP_STRING_BYTE_OFFSET(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTE_OFFSET) +#define DUK_HTHREAD_STRING_BYTE_OFFSET(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTE_OFFSET) +#define DUK_HEAP_STRING_LC_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BUFFER) +#define DUK_HTHREAD_STRING_LC_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BUFFER) +#define DUK_HEAP_STRING_IS_VIEW(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_VIEW) +#define DUK_HTHREAD_STRING_IS_VIEW(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_VIEW) +#define DUK_HEAP_STRING_DATA(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATA) +#define DUK_HTHREAD_STRING_DATA(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATA) +#define DUK_HEAP_STRING_TYPE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPE) +#define DUK_HTHREAD_STRING_TYPE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPE) +#define DUK_HEAP_STRING_WRITE_INT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT_BE) +#define DUK_HTHREAD_STRING_WRITE_INT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT_BE) +#define DUK_HEAP_STRING_WRITE_INT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT_LE) +#define DUK_HTHREAD_STRING_WRITE_INT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT_LE) +#define DUK_HEAP_STRING_WRITE_UINT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT_BE) +#define DUK_HTHREAD_STRING_WRITE_UINT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT_BE) +#define DUK_HEAP_STRING_WRITE_UINT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT_LE) +#define DUK_HTHREAD_STRING_WRITE_UINT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT_LE) +#define DUK_HEAP_STRING_WRITE_DOUBLE_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_DOUBLE_BE) +#define DUK_HTHREAD_STRING_WRITE_DOUBLE_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_DOUBLE_BE) +#define DUK_HEAP_STRING_WRITE_DOUBLE_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_DOUBLE_LE) +#define DUK_HTHREAD_STRING_WRITE_DOUBLE_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_DOUBLE_LE) +#define DUK_HEAP_STRING_WRITE_FLOAT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_FLOAT_BE) +#define DUK_HTHREAD_STRING_WRITE_FLOAT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_FLOAT_BE) +#define DUK_HEAP_STRING_WRITE_FLOAT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_FLOAT_LE) +#define DUK_HTHREAD_STRING_WRITE_FLOAT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_FLOAT_LE) +#define DUK_HEAP_STRING_WRITE_INT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT32_BE) +#define DUK_HTHREAD_STRING_WRITE_INT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT32_BE) +#define DUK_HEAP_STRING_WRITE_INT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT32_LE) +#define DUK_HTHREAD_STRING_WRITE_INT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT32_LE) +#define DUK_HEAP_STRING_WRITE_UINT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT32_BE) +#define DUK_HTHREAD_STRING_WRITE_UINT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT32_BE) +#define DUK_HEAP_STRING_WRITE_UINT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT32_LE) +#define DUK_HTHREAD_STRING_WRITE_UINT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT32_LE) +#define DUK_HEAP_STRING_WRITE_INT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT16_BE) +#define DUK_HTHREAD_STRING_WRITE_INT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT16_BE) +#define DUK_HEAP_STRING_WRITE_INT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT16_LE) +#define DUK_HTHREAD_STRING_WRITE_INT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT16_LE) +#define DUK_HEAP_STRING_WRITE_UINT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT16_BE) +#define DUK_HTHREAD_STRING_WRITE_UINT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT16_BE) +#define DUK_HEAP_STRING_WRITE_UINT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT16_LE) +#define DUK_HTHREAD_STRING_WRITE_UINT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT16_LE) +#define DUK_HEAP_STRING_WRITE_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_INT8) +#define DUK_HTHREAD_STRING_WRITE_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_INT8) +#define DUK_HEAP_STRING_WRITE_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE_UINT8) +#define DUK_HTHREAD_STRING_WRITE_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE_UINT8) +#define DUK_HEAP_STRING_READ_INT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT_BE) +#define DUK_HTHREAD_STRING_READ_INT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT_BE) +#define DUK_HEAP_STRING_READ_INT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT_LE) +#define DUK_HTHREAD_STRING_READ_INT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT_LE) +#define DUK_HEAP_STRING_READ_UINT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT_BE) +#define DUK_HTHREAD_STRING_READ_UINT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT_BE) +#define DUK_HEAP_STRING_READ_UINT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT_LE) +#define DUK_HTHREAD_STRING_READ_UINT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT_LE) +#define DUK_HEAP_STRING_READ_DOUBLE_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_DOUBLE_BE) +#define DUK_HTHREAD_STRING_READ_DOUBLE_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_DOUBLE_BE) +#define DUK_HEAP_STRING_READ_DOUBLE_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_DOUBLE_LE) +#define DUK_HTHREAD_STRING_READ_DOUBLE_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_DOUBLE_LE) +#define DUK_HEAP_STRING_READ_FLOAT_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_FLOAT_BE) +#define DUK_HTHREAD_STRING_READ_FLOAT_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_FLOAT_BE) +#define DUK_HEAP_STRING_READ_FLOAT_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_FLOAT_LE) +#define DUK_HTHREAD_STRING_READ_FLOAT_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_FLOAT_LE) +#define DUK_HEAP_STRING_READ_INT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT32_BE) +#define DUK_HTHREAD_STRING_READ_INT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT32_BE) +#define DUK_HEAP_STRING_READ_INT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT32_LE) +#define DUK_HTHREAD_STRING_READ_INT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT32_LE) +#define DUK_HEAP_STRING_READ_UINT32_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT32_BE) +#define DUK_HTHREAD_STRING_READ_UINT32_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT32_BE) +#define DUK_HEAP_STRING_READ_UINT32_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT32_LE) +#define DUK_HTHREAD_STRING_READ_UINT32_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT32_LE) +#define DUK_HEAP_STRING_READ_INT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT16_BE) +#define DUK_HTHREAD_STRING_READ_INT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT16_BE) +#define DUK_HEAP_STRING_READ_INT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT16_LE) +#define DUK_HTHREAD_STRING_READ_INT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT16_LE) +#define DUK_HEAP_STRING_READ_UINT16_BE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT16_BE) +#define DUK_HTHREAD_STRING_READ_UINT16_BE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT16_BE) +#define DUK_HEAP_STRING_READ_UINT16_LE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT16_LE) +#define DUK_HTHREAD_STRING_READ_UINT16_LE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT16_LE) +#define DUK_HEAP_STRING_READ_INT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_INT8) +#define DUK_HTHREAD_STRING_READ_INT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_INT8) +#define DUK_HEAP_STRING_READ_UINT8(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_READ_UINT8) +#define DUK_HTHREAD_STRING_READ_UINT8(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_READ_UINT8) +#define DUK_HEAP_STRING_COPY(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COPY) +#define DUK_HTHREAD_STRING_COPY(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COPY) +#define DUK_HEAP_STRING_EQUALS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EQUALS) +#define DUK_HTHREAD_STRING_EQUALS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EQUALS) +#define DUK_HEAP_STRING_FILL(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILL) +#define DUK_HTHREAD_STRING_FILL(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILL) +#define DUK_HEAP_STRING_WRITE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITE) +#define DUK_HTHREAD_STRING_WRITE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITE) +#define DUK_HEAP_STRING_COMPARE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPARE) +#define DUK_HTHREAD_STRING_COMPARE(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPARE) +#define DUK_HEAP_STRING_BYTE_LENGTH(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BYTE_LENGTH) +#define DUK_HTHREAD_STRING_BYTE_LENGTH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BYTE_LENGTH) +#define DUK_HEAP_STRING_IS_BUFFER(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_BUFFER) +#define DUK_HTHREAD_STRING_IS_BUFFER(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_BUFFER) +#define DUK_HEAP_STRING_IS_ENCODING(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_ENCODING) +#define DUK_HTHREAD_STRING_IS_ENCODING(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_ENCODING) +#define DUK_HEAP_STRING_EXPORTS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORTS) +#define DUK_HTHREAD_STRING_EXPORTS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORTS) #define DUK_HEAP_STRING_ID(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ID) #define DUK_HTHREAD_STRING_ID(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ID) #define DUK_HEAP_STRING_REQUIRE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REQUIRE) @@ -3455,6 +4261,8 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; #define DUK_HTHREAD_STRING_TYPEOF(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPEOF) #define DUK_HEAP_STRING_VAR(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VAR) #define DUK_HTHREAD_STRING_VAR(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VAR) +#define DUK_HEAP_STRING_CONST(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONST) +#define DUK_HTHREAD_STRING_CONST(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONST) #define DUK_HEAP_STRING_VOID(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VOID) #define DUK_HTHREAD_STRING_VOID(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VOID) #define DUK_HEAP_STRING_WHILE(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WHILE) @@ -3463,8 +4271,6 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; #define DUK_HTHREAD_STRING_WITH(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WITH) #define DUK_HEAP_STRING_CLASS(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLASS) #define DUK_HTHREAD_STRING_CLASS(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLASS) -#define DUK_HEAP_STRING_CONST(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONST) -#define DUK_HTHREAD_STRING_CONST(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONST) #define DUK_HEAP_STRING_ENUM(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUM) #define DUK_HTHREAD_STRING_ENUM(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUM) #define DUK_HEAP_STRING_EXPORT(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORT) @@ -3500,21 +4306,21 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943]; #define DUK_HEAP_STRING_YIELD(heap) DUK_HEAP_GET_STRING((heap),DUK_STRIDX_YIELD) #define DUK_HTHREAD_STRING_YIELD(thr) DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_YIELD) -#define DUK_HEAP_NUM_STRINGS 336 +#define DUK_HEAP_NUM_STRINGS 414 -#define DUK_STRIDX_START_RESERVED 291 -#define DUK_STRIDX_START_STRICT_RESERVED 327 -#define DUK_STRIDX_END_RESERVED 336 /* exclusive endpoint */ +#define DUK_STRIDX_START_RESERVED 369 +#define DUK_STRIDX_START_STRICT_RESERVED 405 +#define DUK_STRIDX_END_RESERVED 414 /* exclusive endpoint */ #if !defined(DUK_SINGLE_FILE) -DUK_INTERNAL_DECL const duk_c_function duk_bi_native_functions[128]; -DUK_INTERNAL_DECL const duk_uint8_t duk_builtins_data[1341]; +DUK_INTERNAL_DECL const duk_c_function duk_bi_native_functions[149]; +DUK_INTERNAL_DECL const duk_uint8_t duk_builtins_data[1955]; #ifdef DUK_USE_BUILTIN_INITJS DUK_INTERNAL_DECL const duk_uint8_t duk_initjs_data[187]; #endif /* DUK_USE_BUILTIN_INITJS */ #endif /* !DUK_SINGLE_FILE */ -#define DUK_BUILTINS_DATA_LENGTH 1341 +#define DUK_BUILTINS_DATA_LENGTH 1955 #ifdef DUK_USE_BUILTIN_INITJS #define DUK_BUILTIN_INITJS_DATA_LENGTH 187 #endif /* DUK_USE_BUILTIN_INITJS */ @@ -3565,15 +4371,571 @@ DUK_INTERNAL_DECL const duk_uint8_t duk_initjs_data[187]; #define DUK_BIDX_LOGGER_CONSTRUCTOR 43 #define DUK_BIDX_LOGGER_PROTOTYPE 44 #define DUK_BIDX_DOUBLE_ERROR 45 +#define DUK_BIDX_ARRAYBUFFER_CONSTRUCTOR 46 +#define DUK_BIDX_ARRAYBUFFER_PROTOTYPE 47 +#define DUK_BIDX_DATAVIEW_CONSTRUCTOR 48 +#define DUK_BIDX_DATAVIEW_PROTOTYPE 49 +#define DUK_BIDX_TYPEDARRAY_PROTOTYPE 50 +#define DUK_BIDX_INT8ARRAY_CONSTRUCTOR 51 +#define DUK_BIDX_INT8ARRAY_PROTOTYPE 52 +#define DUK_BIDX_UINT8ARRAY_CONSTRUCTOR 53 +#define DUK_BIDX_UINT8ARRAY_PROTOTYPE 54 +#define DUK_BIDX_UINT8CLAMPEDARRAY_CONSTRUCTOR 55 +#define DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE 56 +#define DUK_BIDX_INT16ARRAY_CONSTRUCTOR 57 +#define DUK_BIDX_INT16ARRAY_PROTOTYPE 58 +#define DUK_BIDX_UINT16ARRAY_CONSTRUCTOR 59 +#define DUK_BIDX_UINT16ARRAY_PROTOTYPE 60 +#define DUK_BIDX_INT32ARRAY_CONSTRUCTOR 61 +#define DUK_BIDX_INT32ARRAY_PROTOTYPE 62 +#define DUK_BIDX_UINT32ARRAY_CONSTRUCTOR 63 +#define DUK_BIDX_UINT32ARRAY_PROTOTYPE 64 +#define DUK_BIDX_FLOAT32ARRAY_CONSTRUCTOR 65 +#define DUK_BIDX_FLOAT32ARRAY_PROTOTYPE 66 +#define DUK_BIDX_FLOAT64ARRAY_CONSTRUCTOR 67 +#define DUK_BIDX_FLOAT64ARRAY_PROTOTYPE 68 +#define DUK_BIDX_NODEJS_BUFFER_CONSTRUCTOR 69 +#define DUK_BIDX_NODEJS_BUFFER_PROTOTYPE 70 -#define DUK_NUM_BUILTINS 46 +#define DUK_NUM_BUILTINS 71 #else #error invalid endianness defines #endif #endif /* DUK_BUILTINS_H_INCLUDED */ -#line 50 "duk_internal.h" +#line 51 "duk_internal.h" +#line 1 "duk_util.h" +/* + * Utilities + */ + +#ifndef DUK_UTIL_H_INCLUDED +#define DUK_UTIL_H_INCLUDED + +#define DUK_UTIL_MIN_HASH_PRIME 17 /* must match genhashsizes.py */ + +#define DUK_UTIL_GET_HASH_PROBE_STEP(hash) (duk_util_probe_steps[(hash) & 0x1f]) + +/* + * Endian conversion + */ + +#if defined(DUK_USE_INTEGER_LE) +#define DUK_HTON32(x) DUK_BSWAP32((x)) +#define DUK_NTOH32(x) DUK_BSWAP32((x)) +#define DUK_HTON16(x) DUK_BSWAP16((x)) +#define DUK_NTOH16(x) DUK_BSWAP16((x)) +#elif defined(DUK_USE_INTEGER_BE) +#define DUK_HTON32(x) (x) +#define DUK_NTOH32(x) (x) +#define DUK_HTON16(x) (x) +#define DUK_NTOH16(x) (x) +#else +#error internal error, endianness defines broken +#endif + +/* + * Bitstream decoder + */ + +struct duk_bitdecoder_ctx { + const duk_uint8_t *data; + duk_size_t offset; + duk_size_t length; + duk_uint32_t currval; + duk_small_int_t currbits; +}; + +/* + * Bitstream encoder + */ + +struct duk_bitencoder_ctx { + duk_uint8_t *data; + duk_size_t offset; + duk_size_t length; + duk_uint32_t currval; + duk_small_int_t currbits; + duk_small_int_t truncated; +}; + +/* + * Raw write/read macros for big endian, unaligned basic values. + * Caller ensures there's enough space. The macros update the pointer + * argument automatically on resizes. The idiom seems a bit odd, but + * leads to compact code. + */ + +#define DUK_RAW_WRITE_U8(ptr,val) do { \ + *(ptr)++ = (duk_uint8_t) (val); \ + } while (0) +#define DUK_RAW_WRITE_U16_BE(ptr,val) duk_raw_write_u16_be(&(ptr), (duk_uint16_t) (val)) +#define DUK_RAW_WRITE_U32_BE(ptr,val) duk_raw_write_u32_be(&(ptr), (duk_uint32_t) (val)) +#define DUK_RAW_WRITE_DOUBLE_BE(ptr,val) duk_raw_write_double_be(&(ptr), (duk_double_t) (val)) +#define DUK_RAW_WRITE_XUTF8(ptr,val) do { \ + /* 'ptr' is evaluated both as LHS and RHS. */ \ + duk_uint8_t *duk__ptr; \ + duk_small_int_t duk__len; \ + duk__ptr = (duk_uint8_t *) (ptr); \ + duk__len = duk_unicode_encode_xutf8((duk_ucodepoint_t) (val), duk__ptr); \ + duk__ptr += duk__len; \ + (ptr) = duk__ptr; \ + } while (0) +#define DUK_RAW_WRITE_CESU8(ptr,val) do { \ + /* 'ptr' is evaluated both as LHS and RHS. */ \ + duk_uint8_t *duk__ptr; \ + duk_small_int_t duk__len; \ + duk__ptr = (duk_uint8_t *) (ptr); \ + duk__len = duk_unicode_encode_cesu8((duk_ucodepoint_t) (val), duk__ptr); \ + duk__ptr += duk__len; \ + (ptr) = duk__ptr; \ + } while (0) + +#define DUK_RAW_READ_U8(ptr) ((duk_uint8_t) (*(ptr)++)) +#define DUK_RAW_READ_U16_BE(ptr) duk_raw_read_u16_be(&(ptr)); +#define DUK_RAW_READ_U32_BE(ptr) duk_raw_read_u32_be(&(ptr)); +#define DUK_RAW_READ_DOUBLE_BE(ptr) duk_raw_read_double_be(&(ptr)); + +/* + * Buffer writer (dynamic buffer only) + * + * Helper for writing to a dynamic buffer with a concept of a "spare" area + * to reduce resizes. You can ensure there is enough space beforehand and + * then write for a while without further checks, relying on a stable data + * pointer. Spare handling is automatic so call sites only indicate how + * much data they need right now. + * + * There are several ways to write using bufwriter. The best approach + * depends mainly on how much performance matters over code footprint. + * The key issues are (1) ensuring there is space and (2) keeping the + * pointers consistent. Fast code should ensure space for multiple writes + * with one ensure call. Fastest inner loop code can temporarily borrow + * the 'p' pointer but must write it back eventually. + * + * Be careful to ensure all macro arguments (other than static pointers like + * 'thr' and 'bw_ctx') are evaluated exactly once, using temporaries if + * necessary (if that's not possible, there should be a note near the macro). + * Buffer write arguments often contain arithmetic etc so this is + * particularly important here. + */ + +/* XXX: Migrate bufwriter and other read/write helpers to its own header? */ + +struct duk_bufwriter_ctx { + duk_uint8_t *p; + duk_uint8_t *p_base; + duk_uint8_t *p_limit; + duk_hbuffer_dynamic *buf; +}; + +#define DUK_BW_SPARE_ADD 64 +#define DUK_BW_SPARE_SHIFT 4 /* 2^4 -> 1/16 = 6.25% spare */ + +/* Initialization and finalization (compaction), converting to other types. */ + +#define DUK_BW_INIT_PUSHBUF(thr,bw_ctx,sz) do { \ + duk_bw_init_pushbuf((thr), (bw_ctx), (sz)); \ + } while (0) +#define DUK_BW_INIT_WITHBUF(thr,bw_ctx,buf) do { \ + duk_bw_init((thr), (bw_ctx), (buf)); \ + } while (0) +#define DUK_BW_COMPACT(thr,bw_ctx) do { \ + /* Make underlying buffer compact to match DUK_BW_GET_SIZE(). */ \ + duk_bw_compact((thr), (bw_ctx)); \ + } while (0) +#define DUK_BW_PUSH_AS_STRING(thr,bw_ctx) do { \ + duk_push_lstring((duk_context *) (thr), \ + (const char *) (bw_ctx)->p_base, \ + (duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)); \ + } while (0) +/* Pointers may be NULL for a while when 'buf' size is zero and before any + * ENSURE calls have been made. Once an ENSURE has been made, the pointers + * are required to be non-NULL so that it's always valid to use memcpy() and + * memmove(), even for zero size. + */ +#define DUK_BW_ASSERT_VALID_EXPR(thr,bw_ctx) \ + DUK_ASSERT_EXPR((bw_ctx) != NULL && \ + (bw_ctx)->buf != NULL && \ + ((DUK_HBUFFER_DYNAMIC_GET_SIZE((bw_ctx)->buf) == 0) || \ + ((bw_ctx)->p != NULL && \ + (bw_ctx)->p_base != NULL && \ + (bw_ctx)->p_limit != NULL && \ + (bw_ctx)->p_limit >= (bw_ctx)->p_base && \ + (bw_ctx)->p >= (bw_ctx)->p_base && \ + (bw_ctx)->p <= (bw_ctx)->p_limit))) +#define DUK_BW_ASSERT_VALID(thr,bw_ctx) do { \ + DUK_BW_ASSERT_VALID_EXPR((thr), (bw_ctx)); \ + } while (0) + +/* Working with the pointer and current size. */ + +#define DUK_BW_GET_PTR(thr,bw_ctx) \ + ((bw_ctx)->p) +#define DUK_BW_SET_PTR(thr,bw_ctx,ptr) do { \ + (bw_ctx)->p = (ptr); \ + } while (0) +#define DUK_BW_ADD_PTR(thr,bw_ctx,delta) do { \ + (bw_ctx)->p += (delta); \ + } while (0) +#define DUK_BW_GET_BASEPTR(thr,bw_ctx) \ + ((bw_ctx)->p_base) +#define DUK_BW_GET_LIMITPTR(thr,bw_ctx) \ + ((bw_ctx)->p_limit) +#define DUK_BW_GET_SIZE(thr,bw_ctx) \ + ((duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)) +#define DUK_BW_SET_SIZE(thr,bw_ctx,sz) do { \ + DUK_ASSERT((duk_size_t) (sz) <= (duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)); \ + (bw_ctx)->p = (bw_ctx)->p_base + (sz); \ + } while (0) +#define DUK_BW_RESET_SIZE(thr,bw_ctx) do { \ + /* Reset to zero size, keep current limit. */ \ + (bw_ctx)->p = (bw_ctx)->p_base; \ + } while (0) +#define DUK_BW_GET_BUFFER(thr,bw_ctx) \ + ((bw_ctx)->buf) + +/* Ensuring (reserving) space. */ + +#define DUK_BW_ENSURE(thr,bw_ctx,sz) do { \ + duk_size_t duk__sz, duk__space; \ + DUK_BW_ASSERT_VALID((thr), (bw_ctx)); \ + duk__sz = (sz); \ + duk__space = (duk_size_t) ((bw_ctx)->p_limit - (bw_ctx)->p); \ + if (duk__space < duk__sz) { \ + (void) duk_bw_resize((thr), (bw_ctx), duk__sz); \ + } \ + } while (0) +/* NOTE: Multiple evaluation of 'ptr' in this macro. */ +/* XXX: Rework to use an always-inline function? */ +#define DUK_BW_ENSURE_RAW(thr,bw_ctx,sz,ptr) \ + (((duk_size_t) ((bw_ctx)->p_limit - (ptr)) >= (sz)) ? \ + (ptr) : \ + ((bw_ctx)->p = (ptr), duk_bw_resize((thr),(bw_ctx),(sz)))) +#define DUK_BW_ENSURE_GETPTR(thr,bw_ctx,sz) \ + DUK_BW_ENSURE_RAW((thr), (bw_ctx), (sz), (bw_ctx)->p) +#define DUK_BW_ASSERT_SPACE_EXPR(thr,bw_ctx,sz) \ + (DUK_BW_ASSERT_VALID_EXPR((thr), (bw_ctx)), \ + DUK_ASSERT_EXPR((duk_size_t) ((bw_ctx)->p_limit - (bw_ctx)->p) >= (duk_size_t) (sz))) +#define DUK_BW_ASSERT_SPACE(thr,bw_ctx,sz) do { \ + DUK_BW_ASSERT_SPACE_EXPR((thr), (bw_ctx), (sz)); \ + } while (0) + +/* Miscellaneous. */ + +#define DUK_BW_SETPTR_AND_COMPACT(thr,bw_ctx,ptr) do { \ + (bw_ctx)->p = (ptr); \ + duk_bw_compact((thr), (bw_ctx)); \ + } while (0) + +/* Fast write calls which assume you control the spare beforehand. + * Multibyte write variants exist and use a temporary write pointer + * because byte writes alias with anything: with a stored pointer + * explicit pointer load/stores get generated (e.g. gcc -Os). + */ + +#define DUK_BW_WRITE_RAW_U8(thr,bw_ctx,val) do { \ + DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 1); \ + *(bw_ctx)->p++ = (duk_uint8_t) (val); \ + } while (0) +#define DUK_BW_WRITE_RAW_U8_2(thr,bw_ctx,val1,val2) do { \ + duk_uint8_t *duk__p; \ + DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 2); \ + duk__p = (bw_ctx)->p; \ + *duk__p++ = (duk_uint8_t) (val1); \ + *duk__p++ = (duk_uint8_t) (val2); \ + (bw_ctx)->p = duk__p; \ + } while (0) +#define DUK_BW_WRITE_RAW_U8_3(thr,bw_ctx,val1,val2,val3) do { \ + duk_uint8_t *duk__p; \ + DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 3); \ + duk__p = (bw_ctx)->p; \ + *duk__p++ = (duk_uint8_t) (val1); \ + *duk__p++ = (duk_uint8_t) (val2); \ + *duk__p++ = (duk_uint8_t) (val3); \ + (bw_ctx)->p = duk__p; \ + } while (0) +#define DUK_BW_WRITE_RAW_U8_4(thr,bw_ctx,val1,val2,val3,val4) do { \ + duk_uint8_t *duk__p; \ + DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 4); \ + duk__p = (bw_ctx)->p; \ + *duk__p++ = (duk_uint8_t) (val1); \ + *duk__p++ = (duk_uint8_t) (val2); \ + *duk__p++ = (duk_uint8_t) (val3); \ + *duk__p++ = (duk_uint8_t) (val4); \ + (bw_ctx)->p = duk__p; \ + } while (0) +#define DUK_BW_WRITE_RAW_U8_5(thr,bw_ctx,val1,val2,val3,val4,val5) do { \ + duk_uint8_t *duk__p; \ + DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 5); \ + duk__p = (bw_ctx)->p; \ + *duk__p++ = (duk_uint8_t) (val1); \ + *duk__p++ = (duk_uint8_t) (val2); \ + *duk__p++ = (duk_uint8_t) (val3); \ + *duk__p++ = (duk_uint8_t) (val4); \ + *duk__p++ = (duk_uint8_t) (val5); \ + (bw_ctx)->p = duk__p; \ + } while (0) +#define DUK_BW_WRITE_RAW_U8_6(thr,bw_ctx,val1,val2,val3,val4,val5,val6) do { \ + duk_uint8_t *duk__p; \ + DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 6); \ + duk__p = (bw_ctx)->p; \ + *duk__p++ = (duk_uint8_t) (val1); \ + *duk__p++ = (duk_uint8_t) (val2); \ + *duk__p++ = (duk_uint8_t) (val3); \ + *duk__p++ = (duk_uint8_t) (val4); \ + *duk__p++ = (duk_uint8_t) (val5); \ + *duk__p++ = (duk_uint8_t) (val6); \ + (bw_ctx)->p = duk__p; \ + } while (0) +#define DUK_BW_WRITE_RAW_XUTF8(thr,bw_ctx,cp) do { \ + duk_ucodepoint_t duk__cp; \ + duk_small_int_t duk__enc_len; \ + duk__cp = (cp); \ + DUK_BW_ASSERT_SPACE((thr), (bw_ctx), duk_unicode_get_xutf8_length(duk__cp)); \ + duk__enc_len = duk_unicode_encode_xutf8(duk__cp, (bw_ctx)->p); \ + (bw_ctx)->p += duk__enc_len; \ + } while (0) +#define DUK_BW_WRITE_RAW_CESU8(thr,bw_ctx,cp) do { \ + duk_ucodepoint_t duk__cp; \ + duk_small_int_t duk__enc_len; \ + duk__cp = (duk_ucodepoint_t) (cp); \ + DUK_BW_ASSERT_SPACE((thr), (bw_ctx), duk_unicode_get_cesu8_length(duk__cp)); \ + duk__enc_len = duk_unicode_encode_cesu8(duk__cp, (bw_ctx)->p); \ + (bw_ctx)->p += duk__enc_len; \ + } while (0) +/* XXX: add temporary duk__p pointer here too; sharing */ +#define DUK_BW_WRITE_RAW_BYTES(thr,bw_ctx,valptr,valsz) do { \ + const void *duk__valptr; \ + duk_size_t duk__valsz; \ + duk__valptr = (const void *) (valptr); \ + duk__valsz = (duk_size_t) (valsz); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), duk__valptr, duk__valsz); \ + (bw_ctx)->p += duk__valsz; \ + } while (0) +#define DUK_BW_WRITE_RAW_CSTRING(thr,bw_ctx,val) do { \ + const duk_uint8_t *duk__val; \ + duk_size_t duk__val_len; \ + duk__val = (const duk_uint8_t *) (val); \ + duk__val_len = DUK_STRLEN((const char *) duk__val); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) duk__val, duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) +#define DUK_BW_WRITE_RAW_HSTRING(thr,bw_ctx,val) do { \ + duk_size_t duk__val_len; \ + duk__val_len = DUK_HSTRING_GET_BYTELEN((val)); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HSTRING_GET_DATA((val)), duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) +#define DUK_BW_WRITE_RAW_HBUFFER(thr,bw_ctx,val) do { \ + duk_size_t duk__val_len; \ + duk__val_len = DUK_HBUFFER_GET_SIZE((val)); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) +#define DUK_BW_WRITE_RAW_HBUFFER_FIXED(thr,bw_ctx,val) do { \ + duk_size_t duk__val_len; \ + duk__val_len = DUK_HBUFFER_FIXED_GET_SIZE((val)); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_FIXED_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) +#define DUK_BW_WRITE_RAW_HBUFFER_DYNAMIC(thr,bw_ctx,val) do { \ + duk_size_t duk__val_len; \ + duk__val_len = DUK_HBUFFER_DYNAMIC_GET_SIZE((val)); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) + +/* Append bytes from a slice already in the buffer. */ +#define DUK_BW_WRITE_RAW_SLICE(thr,bw,dst_off,dst_len) \ + duk_bw_write_raw_slice((thr), (bw), (dst_off), (dst_len)) + +/* Insert bytes in the middle of the buffer from an external buffer. */ +#define DUK_BW_INSERT_RAW_BYTES(thr,bw,dst_off,buf,len) \ + duk_bw_insert_raw_bytes((thr), (bw), (dst_off), (buf), (len)) + +/* Insert bytes in the middle of the buffer from a slice already + * in the buffer. Source offset is interpreted "before" the operation. + */ +#define DUK_BW_INSERT_RAW_SLICE(thr,bw,dst_off,src_off,len) \ + duk_bw_insert_raw_slice((thr), (bw), (dst_off), (src_off), (len)) + +/* Insert a reserved area somewhere in the buffer; caller fills it. + * Evaluates to a (duk_uint_t *) pointing to the start of the reserved + * area for convenience. + */ +#define DUK_BW_INSERT_RAW_AREA(thr,bw,off,len) \ + duk_bw_insert_raw_area((thr), (bw), (off), (len)) + +/* Remove a slice from inside buffer. */ +#define DUK_BW_REMOVE_RAW_SLICE(thr,bw,off,len) \ + duk_bw_remove_raw_slice((thr), (bw), (off), (len)) + +/* Safe write calls which will ensure space first. */ + +#define DUK_BW_WRITE_ENSURE_U8(thr,bw_ctx,val) do { \ + DUK_BW_ENSURE((thr), (bw_ctx), 1); \ + DUK_BW_WRITE_RAW_U8((thr), (bw_ctx), (val)); \ + } while (0) +#define DUK_BW_WRITE_ENSURE_U8_2(thr,bw_ctx,val1,val2) do { \ + DUK_BW_ENSURE((thr), (bw_ctx), 2); \ + DUK_BW_WRITE_RAW_U8_2((thr), (bw_ctx), (val1), (val2)); \ + } while (0) +#define DUK_BW_WRITE_ENSURE_U8_3(thr,bw_ctx,val1,val2,val3) do { \ + DUK_BW_ENSURE((thr), (bw_ctx), 3); \ + DUK_BW_WRITE_RAW_U8_3((thr), (bw_ctx), (val1), (val2), (val3)); \ + } while (0) +#define DUK_BW_WRITE_ENSURE_U8_4(thr,bw_ctx,val1,val2,val3,val4) do { \ + DUK_BW_ENSURE((thr), (bw_ctx), 4); \ + DUK_BW_WRITE_RAW_U8_4((thr), (bw_ctx), (val1), (val2), (val3), (val4)); \ + } while (0) +#define DUK_BW_WRITE_ENSURE_U8_5(thr,bw_ctx,val1,val2,val3,val4,val5) do { \ + DUK_BW_ENSURE((thr), (bw_ctx), 5); \ + DUK_BW_WRITE_RAW_U8_5((thr), (bw_ctx), (val1), (val2), (val3), (val4), (val5)); \ + } while (0) +#define DUK_BW_WRITE_ENSURE_U8_6(thr,bw_ctx,val1,val2,val3,val4,val5,val6) do { \ + DUK_BW_ENSURE((thr), (bw_ctx), 6); \ + DUK_BW_WRITE_RAW_U8_6((thr), (bw_ctx), (val1), (val2), (val3), (val4), (val5), (val6)); \ + } while (0) +#define DUK_BW_WRITE_ENSURE_XUTF8(thr,bw_ctx,cp) do { \ + DUK_BW_ENSURE((thr), (bw_ctx), DUK_UNICODE_MAX_XUTF8_LENGTH); \ + DUK_BW_WRITE_RAW_XUTF8((thr), (bw_ctx), (cp)); \ + } while (0) +#define DUK_BW_WRITE_ENSURE_CESU8(thr,bw_ctx,cp) do { \ + DUK_BW_ENSURE((thr), (bw_ctx), DUK_UNICODE_MAX_CESU8_LENGTH); \ + DUK_BW_WRITE_RAW_CESU8((thr), (bw_ctx), (cp)); \ + } while (0) +/* XXX: add temporary duk__p pointer here too; sharing */ +#define DUK_BW_WRITE_ENSURE_BYTES(thr,bw_ctx,valptr,valsz) do { \ + const void *duk__valptr; \ + duk_size_t duk__valsz; \ + duk__valptr = (const void *) (valptr); \ + duk__valsz = (duk_size_t) (valsz); \ + DUK_BW_ENSURE((thr), (bw_ctx), duk__valsz); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), duk__valptr, duk__valsz); \ + (bw_ctx)->p += duk__valsz; \ + } while (0) +#define DUK_BW_WRITE_ENSURE_CSTRING(thr,bw_ctx,val) do { \ + const duk_uint8_t *duk__val; \ + duk_size_t duk__val_len; \ + duk__val = (const duk_uint8_t *) (val); \ + duk__val_len = DUK_STRLEN((const char *) duk__val); \ + DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) duk__val, duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) +#define DUK_BW_WRITE_ENSURE_HSTRING(thr,bw_ctx,val) do { \ + duk_size_t duk__val_len; \ + duk__val_len = DUK_HSTRING_GET_BYTELEN((val)); \ + DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HSTRING_GET_DATA((val)), duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) +#define DUK_BW_WRITE_ENSURE_HBUFFER(thr,bw_ctx,val) do { \ + duk_size_t duk__val_len; \ + duk__val_len = DUK_HBUFFER_GET_SIZE((val)); \ + DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) +#define DUK_BW_WRITE_ENSURE_HBUFFER_FIXED(thr,bw_ctx,val) do { \ + duk_size_t duk__val_len; \ + duk__val_len = DUK_HBUFFER_FIXED_GET_SIZE((val)); \ + DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_FIXED_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) +#define DUK_BW_WRITE_ENSURE_HBUFFER_DYNAMIC(thr,bw_ctx,val) do { \ + duk_size_t duk__val_len; \ + duk__val_len = DUK_HBUFFER_DYNAMIC_GET_SIZE((val)); \ + DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \ + DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \ + (bw_ctx)->p += duk__val_len; \ + } while (0) + +#define DUK_BW_WRITE_ENSURE_SLICE(thr,bw,dst_off,dst_len) \ + duk_bw_write_ensure_slice((thr), (bw), (dst_off), (dst_len)) +#define DUK_BW_INSERT_ENSURE_BYTES(thr,bw,dst_off,buf,len) \ + duk_bw_insert_ensure_bytes((thr), (bw), (dst_off), (buf), (len)) +#define DUK_BW_INSERT_ENSURE_SLICE(thr,bw,dst_off,src_off,len) \ + duk_bw_insert_ensure_slice((thr), (bw), (dst_off), (src_off), (len)) +#define DUK_BW_INSERT_ENSURE_AREA(thr,bw,off,len) \ + /* Evaluates to (duk_uint8_t *) pointing to start of area. */ \ + duk_bw_insert_ensure_area((thr), (bw), (off), (len)) +#define DUK_BW_REMOVE_ENSURE_SLICE(thr,bw,off,len) \ + /* No difference between raw/ensure because the buffer shrinks. */ \ + DUK_BW_REMOVE_RAW_SLICE((thr), (bw), (off), (len)) + +/* + * Externs and prototypes + */ + +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL const duk_uint8_t duk_lc_digits[36]; +DUK_INTERNAL_DECL const duk_uint8_t duk_uc_nybbles[16]; +DUK_INTERNAL_DECL const duk_int8_t duk_hex_dectab[256]; +#if defined(DUK_USE_HEX_FASTPATH) +DUK_INTERNAL_DECL const duk_int16_t duk_hex_dectab_shift4[256]; +DUK_INTERNAL_DECL const duk_uint16_t duk_hex_enctab[256]; +#endif +#if defined(DUK_USE_BASE64_FASTPATH) +DUK_INTERNAL_DECL const duk_uint8_t duk_base64_enctab[64]; +DUK_INTERNAL_DECL const duk_int8_t duk_base64_dectab[256]; +#endif +#endif /* !DUK_SINGLE_FILE */ + +/* Note: assumes that duk_util_probe_steps size is 32 */ +#if defined(DUK_USE_HOBJECT_HASH_PART) || defined(DUK_USE_STRTAB_PROBE) +#if !defined(DUK_SINGLE_FILE) +DUK_INTERNAL_DECL duk_uint8_t duk_util_probe_steps[32]; +#endif /* !DUK_SINGLE_FILE */ +#endif + +#if defined(DUK_USE_STRHASH_DENSE) +DUK_INTERNAL_DECL duk_uint32_t duk_util_hashbytes(const duk_uint8_t *data, duk_size_t len, duk_uint32_t seed); +#endif + +#if defined(DUK_USE_HOBJECT_HASH_PART) || defined(DUK_USE_STRTAB_PROBE) +DUK_INTERNAL_DECL duk_uint32_t duk_util_get_hash_prime(duk_uint32_t size); +#endif + +DUK_INTERNAL_DECL duk_int32_t duk_bd_decode(duk_bitdecoder_ctx *ctx, duk_small_int_t bits); +DUK_INTERNAL_DECL duk_small_int_t duk_bd_decode_flag(duk_bitdecoder_ctx *ctx); +DUK_INTERNAL_DECL duk_int32_t duk_bd_decode_flagged(duk_bitdecoder_ctx *ctx, duk_small_int_t bits, duk_int32_t def_value); + +DUK_INTERNAL_DECL void duk_be_encode(duk_bitencoder_ctx *ctx, duk_uint32_t data, duk_small_int_t bits); +DUK_INTERNAL_DECL void duk_be_finish(duk_bitencoder_ctx *ctx); + +DUK_INTERNAL_DECL duk_uint32_t duk_util_tinyrandom_get_bits(duk_hthread *thr, duk_small_int_t n); +DUK_INTERNAL_DECL duk_double_t duk_util_tinyrandom_get_double(duk_hthread *thr); + +DUK_INTERNAL_DECL void duk_bw_init(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_hbuffer_dynamic *h_buf); +DUK_INTERNAL_DECL void duk_bw_init_pushbuf(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t buf_size); +DUK_INTERNAL_DECL duk_uint8_t *duk_bw_resize(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t sz); +DUK_INTERNAL_DECL void duk_bw_compact(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx); +DUK_INTERNAL_DECL void duk_bw_write_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t src_off, duk_size_t len); +DUK_INTERNAL_DECL void duk_bw_write_ensure_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t src_off, duk_size_t len); +DUK_INTERNAL_DECL void duk_bw_insert_raw_bytes(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, const duk_uint8_t *buf, duk_size_t len); +DUK_INTERNAL_DECL void duk_bw_insert_ensure_bytes(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, const duk_uint8_t *buf, duk_size_t len); +DUK_INTERNAL_DECL void duk_bw_insert_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, duk_size_t src_off, duk_size_t len); +DUK_INTERNAL_DECL void duk_bw_insert_ensure_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, duk_size_t src_off, duk_size_t len); +DUK_INTERNAL_DECL duk_uint8_t *duk_bw_insert_raw_area(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len); +DUK_INTERNAL_DECL duk_uint8_t *duk_bw_insert_ensure_area(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len); +DUK_INTERNAL_DECL void duk_bw_remove_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len); +/* No duk_bw_remove_ensure_slice(), functionality would be identical. */ + +DUK_INTERNAL_DECL duk_uint16_t duk_raw_read_u16_be(duk_uint8_t **p); +DUK_INTERNAL_DECL duk_uint32_t duk_raw_read_u32_be(duk_uint8_t **p); +DUK_INTERNAL_DECL duk_double_t duk_raw_read_double_be(duk_uint8_t **p); +DUK_INTERNAL_DECL void duk_raw_write_u16_be(duk_uint8_t **p, duk_uint16_t val); +DUK_INTERNAL_DECL void duk_raw_write_u32_be(duk_uint8_t **p, duk_uint32_t val); +DUK_INTERNAL_DECL void duk_raw_write_double_be(duk_uint8_t **p, duk_double_t val); + +#if defined(DUK_USE_DEBUGGER_SUPPORT) /* For now only needed by the debugger. */ +DUK_INTERNAL void duk_byteswap_bytes(duk_uint8_t *p, duk_small_uint_t len); +#endif + +#endif /* DUK_UTIL_H_INCLUDED */ #line 1 "duk_strings.h" /* * Shared error messages: declarations and macros @@ -3619,80 +4981,62 @@ DUK_INTERNAL_DECL const char *duk_str_not_configurable; #endif /* !DUK_SINGLE_FILE */ #define DUK_STR_INVALID_CONTEXT duk_str_invalid_context -#define DUK_STR_INVALID_INDEX duk_str_invalid_index +#define DUK_STR_INVALID_INDEX duk_str_invalid_call_args #define DUK_STR_PUSH_BEYOND_ALLOC_STACK duk_str_push_beyond_alloc_stack -#define DUK_STR_NOT_UNDEFINED duk_str_not_undefined -#define DUK_STR_NOT_NULL duk_str_not_null -#define DUK_STR_NOT_BOOLEAN duk_str_not_boolean -#define DUK_STR_NOT_NUMBER duk_str_not_number -#define DUK_STR_NOT_STRING duk_str_not_string -#define DUK_STR_NOT_POINTER duk_str_not_pointer -#define DUK_STR_NOT_BUFFER duk_str_not_buffer +#define DUK_STR_NOT_UNDEFINED duk_str_unexpected_type +#define DUK_STR_NOT_NULL duk_str_unexpected_type +#define DUK_STR_NOT_BOOLEAN duk_str_unexpected_type +#define DUK_STR_NOT_NUMBER duk_str_unexpected_type +#define DUK_STR_NOT_STRING duk_str_unexpected_type +#define DUK_STR_NOT_OBJECT duk_str_unexpected_type +#define DUK_STR_NOT_POINTER duk_str_unexpected_type +#define DUK_STR_NOT_BUFFER duk_str_not_buffer /* still in use with verbose messages */ #define DUK_STR_UNEXPECTED_TYPE duk_str_unexpected_type -#define DUK_STR_NOT_THREAD duk_str_not_thread -#if 0 /*unused*/ -#define DUK_STR_NOT_COMPILEDFUNCTION duk_str_not_compiledfunction -#endif -#define DUK_STR_NOT_NATIVEFUNCTION duk_str_not_nativefunction -#define DUK_STR_NOT_C_FUNCTION duk_str_not_c_function +#define DUK_STR_NOT_THREAD duk_str_unexpected_type +#define DUK_STR_NOT_COMPILEDFUNCTION duk_str_unexpected_type +#define DUK_STR_NOT_NATIVEFUNCTION duk_str_unexpected_type +#define DUK_STR_NOT_C_FUNCTION duk_str_unexpected_type +#define DUK_STR_NOT_FUNCTION duk_str_unexpected_type +#define DUK_STR_NOT_REGEXP duk_str_unexpected_type #define DUK_STR_DEFAULTVALUE_COERCE_FAILED duk_str_defaultvalue_coerce_failed #define DUK_STR_NUMBER_OUTSIDE_RANGE duk_str_number_outside_range #define DUK_STR_NOT_OBJECT_COERCIBLE duk_str_not_object_coercible #define DUK_STR_STRING_TOO_LONG duk_str_string_too_long #define DUK_STR_BUFFER_TOO_LONG duk_str_buffer_too_long #define DUK_STR_SPRINTF_TOO_LONG duk_str_sprintf_too_long -#define DUK_STR_OBJECT_ALLOC_FAILED duk_str_object_alloc_failed -#define DUK_STR_THREAD_ALLOC_FAILED duk_str_thread_alloc_failed -#define DUK_STR_FUNC_ALLOC_FAILED duk_str_func_alloc_failed -#define DUK_STR_BUFFER_ALLOC_FAILED duk_str_buffer_alloc_failed +#define DUK_STR_ALLOC_FAILED duk_str_alloc_failed #define DUK_STR_POP_TOO_MANY duk_str_pop_too_many -#define DUK_STR_BUFFER_NOT_DYNAMIC duk_str_buffer_not_dynamic +#define DUK_STR_WRONG_BUFFER_TYPE duk_str_wrong_buffer_type #define DUK_STR_FAILED_TO_EXTEND_VALSTACK duk_str_failed_to_extend_valstack -#define DUK_STR_BASE64_ENCODE_FAILED duk_str_base64_encode_failed -#define DUK_STR_BASE64_DECODE_FAILED duk_str_base64_decode_failed -#define DUK_STR_HEX_DECODE_FAILED duk_str_hex_decode_failed +#define DUK_STR_ENCODE_FAILED duk_str_encode_failed +#define DUK_STR_DECODE_FAILED duk_str_decode_failed #define DUK_STR_NO_SOURCECODE duk_str_no_sourcecode #define DUK_STR_CONCAT_RESULT_TOO_LONG duk_str_concat_result_too_long #define DUK_STR_UNIMPLEMENTED duk_str_unimplemented +#define DUK_STR_UNSUPPORTED duk_str_unsupported #define DUK_STR_ARRAY_LENGTH_OVER_2G duk_str_array_length_over_2g #if !defined(DUK_SINGLE_FILE) DUK_INTERNAL_DECL const char *duk_str_invalid_context; -DUK_INTERNAL_DECL const char *duk_str_invalid_index; DUK_INTERNAL_DECL const char *duk_str_push_beyond_alloc_stack; -DUK_INTERNAL_DECL const char *duk_str_not_undefined; -DUK_INTERNAL_DECL const char *duk_str_not_null; -DUK_INTERNAL_DECL const char *duk_str_not_boolean; -DUK_INTERNAL_DECL const char *duk_str_not_number; -DUK_INTERNAL_DECL const char *duk_str_not_string; -DUK_INTERNAL_DECL const char *duk_str_not_pointer; DUK_INTERNAL_DECL const char *duk_str_not_buffer; DUK_INTERNAL_DECL const char *duk_str_unexpected_type; -DUK_INTERNAL_DECL const char *duk_str_not_thread; -#if 0 /*unused*/ -DUK_INTERNAL_DECL const char *duk_str_not_compiledfunction; -#endif -DUK_INTERNAL_DECL const char *duk_str_not_nativefunction; -DUK_INTERNAL_DECL const char *duk_str_not_c_function; DUK_INTERNAL_DECL const char *duk_str_defaultvalue_coerce_failed; DUK_INTERNAL_DECL const char *duk_str_number_outside_range; DUK_INTERNAL_DECL const char *duk_str_not_object_coercible; DUK_INTERNAL_DECL const char *duk_str_string_too_long; DUK_INTERNAL_DECL const char *duk_str_buffer_too_long; DUK_INTERNAL_DECL const char *duk_str_sprintf_too_long; -DUK_INTERNAL_DECL const char *duk_str_object_alloc_failed; -DUK_INTERNAL_DECL const char *duk_str_thread_alloc_failed; -DUK_INTERNAL_DECL const char *duk_str_func_alloc_failed; -DUK_INTERNAL_DECL const char *duk_str_buffer_alloc_failed; +DUK_INTERNAL_DECL const char *duk_str_alloc_failed; DUK_INTERNAL_DECL const char *duk_str_pop_too_many; -DUK_INTERNAL_DECL const char *duk_str_buffer_not_dynamic; +DUK_INTERNAL_DECL const char *duk_str_wrong_buffer_type; DUK_INTERNAL_DECL const char *duk_str_failed_to_extend_valstack; -DUK_INTERNAL_DECL const char *duk_str_base64_encode_failed; -DUK_INTERNAL_DECL const char *duk_str_base64_decode_failed; -DUK_INTERNAL_DECL const char *duk_str_hex_decode_failed; +DUK_INTERNAL_DECL const char *duk_str_encode_failed; +DUK_INTERNAL_DECL const char *duk_str_decode_failed; DUK_INTERNAL_DECL const char *duk_str_no_sourcecode; DUK_INTERNAL_DECL const char *duk_str_concat_result_too_long; DUK_INTERNAL_DECL const char *duk_str_unimplemented; +DUK_INTERNAL_DECL const char *duk_str_unsupported; DUK_INTERNAL_DECL const char *duk_str_array_length_over_2g; #endif /* !DUK_SINGLE_FILE */ @@ -4047,11 +5391,6 @@ typedef duk_uint32_t duk_instr_t; #define DUK_EXTRAOP_LABEL 32 #define DUK_EXTRAOP_ENDLABEL 33 -/* DUK_OP_EXTRA for debugging */ -#define DUK_EXTRAOP_DUMPREG 128 -#define DUK_EXTRAOP_DUMPREGS 129 -#define DUK_EXTRAOP_LOGMARK 130 - /* DUK_OP_CALL flags in A */ #define DUK_BC_CALL_FLAG_TAILCALL (1 << 0) #define DUK_BC_CALL_FLAG_EVALCALL (1 << 1) @@ -4063,8 +5402,7 @@ typedef duk_uint32_t duk_instr_t; #define DUK_BC_TRYCATCH_FLAG_WITH_BINDING (1 << 3) /* DUK_OP_RETURN flags in A */ -#define DUK_BC_RETURN_FLAG_FAST (1 << 0) -#define DUK_BC_RETURN_FLAG_HAVE_RETVAL (1 << 1) +#define DUK_BC_RETURN_FLAG_HAVE_RETVAL (1 << 0) /* DUK_OP_DECLVAR flags in A; bottom bits are reserved for propdesc flags (DUK_PROPDESC_FLAG_XXX) */ #define DUK_BC_DECLVAR_FLAG_UNDEF_VALUE (1 << 4) /* use 'undefined' for value automatically */ @@ -4112,149 +5450,146 @@ typedef void (*duk_re_range_callback)(void *user, duk_codepoint_t r1, duk_codepo #define DUK_LEXER_SETPOINT(ctx,pt) duk_lexer_setpoint((ctx), (pt)) -#define DUK_LEXER_GETPOINT(ctx,pt) do { (pt)->offset = (ctx)->offsets[0]; \ - (pt)->line = (ctx)->lines[0]; } while (0) +#define DUK_LEXER_GETPOINT(ctx,pt) do { (pt)->offset = (ctx)->window[0].offset; \ + (pt)->line = (ctx)->window[0].line; } while (0) /* currently 6 characters of lookup are actually needed (duk_lexer.c) */ -#define DUK_LEXER_WINDOW_SIZE 8 +#define DUK_LEXER_WINDOW_SIZE 6 +#if defined(DUK_USE_LEXER_SLIDING_WINDOW) +#define DUK_LEXER_BUFFER_SIZE 64 +#endif #define DUK_TOK_MINVAL 0 /* returned after EOF (infinite amount) */ #define DUK_TOK_EOF 0 -/* line terminator or multi-line comment with internal lineterm (E5 Sections 7.3, 7.4) */ -#define DUK_TOK_LINETERM 1 - -/* single-line comment or multi-line comment without internal lineterm (E5 Section 7.4) */ -#define DUK_TOK_COMMENT 2 - /* identifier names (E5 Section 7.6) */ -#define DUK_TOK_IDENTIFIER 3 +#define DUK_TOK_IDENTIFIER 1 /* reserved words: keywords */ -#define DUK_TOK_START_RESERVED 4 -#define DUK_TOK_BREAK 4 -#define DUK_TOK_CASE 5 -#define DUK_TOK_CATCH 6 -#define DUK_TOK_CONTINUE 7 -#define DUK_TOK_DEBUGGER 8 -#define DUK_TOK_DEFAULT 9 -#define DUK_TOK_DELETE 10 -#define DUK_TOK_DO 11 -#define DUK_TOK_ELSE 12 -#define DUK_TOK_FINALLY 13 -#define DUK_TOK_FOR 14 -#define DUK_TOK_FUNCTION 15 -#define DUK_TOK_IF 16 -#define DUK_TOK_IN 17 -#define DUK_TOK_INSTANCEOF 18 -#define DUK_TOK_NEW 19 -#define DUK_TOK_RETURN 20 -#define DUK_TOK_SWITCH 21 -#define DUK_TOK_THIS 22 -#define DUK_TOK_THROW 23 -#define DUK_TOK_TRY 24 -#define DUK_TOK_TYPEOF 25 -#define DUK_TOK_VAR 26 -#define DUK_TOK_VOID 27 -#define DUK_TOK_WHILE 28 -#define DUK_TOK_WITH 29 +#define DUK_TOK_START_RESERVED 2 +#define DUK_TOK_BREAK 2 +#define DUK_TOK_CASE 3 +#define DUK_TOK_CATCH 4 +#define DUK_TOK_CONTINUE 5 +#define DUK_TOK_DEBUGGER 6 +#define DUK_TOK_DEFAULT 7 +#define DUK_TOK_DELETE 8 +#define DUK_TOK_DO 9 +#define DUK_TOK_ELSE 10 +#define DUK_TOK_FINALLY 11 +#define DUK_TOK_FOR 12 +#define DUK_TOK_FUNCTION 13 +#define DUK_TOK_IF 14 +#define DUK_TOK_IN 15 +#define DUK_TOK_INSTANCEOF 16 +#define DUK_TOK_NEW 17 +#define DUK_TOK_RETURN 18 +#define DUK_TOK_SWITCH 19 +#define DUK_TOK_THIS 20 +#define DUK_TOK_THROW 21 +#define DUK_TOK_TRY 22 +#define DUK_TOK_TYPEOF 23 +#define DUK_TOK_VAR 24 +#define DUK_TOK_CONST 25 +#define DUK_TOK_VOID 26 +#define DUK_TOK_WHILE 27 +#define DUK_TOK_WITH 28 /* reserved words: future reserved words */ -#define DUK_TOK_CLASS 30 -#define DUK_TOK_CONST 31 -#define DUK_TOK_ENUM 32 -#define DUK_TOK_EXPORT 33 -#define DUK_TOK_EXTENDS 34 -#define DUK_TOK_IMPORT 35 -#define DUK_TOK_SUPER 36 +#define DUK_TOK_CLASS 29 +#define DUK_TOK_ENUM 30 +#define DUK_TOK_EXPORT 31 +#define DUK_TOK_EXTENDS 32 +#define DUK_TOK_IMPORT 33 +#define DUK_TOK_SUPER 34 /* "null", "true", and "false" are always reserved words. * Note that "get" and "set" are not! */ -#define DUK_TOK_NULL 37 -#define DUK_TOK_TRUE 38 -#define DUK_TOK_FALSE 39 +#define DUK_TOK_NULL 35 +#define DUK_TOK_TRUE 36 +#define DUK_TOK_FALSE 37 /* reserved words: additional future reserved words in strict mode */ -#define DUK_TOK_START_STRICT_RESERVED 40 /* inclusive */ -#define DUK_TOK_IMPLEMENTS 40 -#define DUK_TOK_INTERFACE 41 -#define DUK_TOK_LET 42 -#define DUK_TOK_PACKAGE 43 -#define DUK_TOK_PRIVATE 44 -#define DUK_TOK_PROTECTED 45 -#define DUK_TOK_PUBLIC 46 -#define DUK_TOK_STATIC 47 -#define DUK_TOK_YIELD 48 +#define DUK_TOK_START_STRICT_RESERVED 38 /* inclusive */ +#define DUK_TOK_IMPLEMENTS 38 +#define DUK_TOK_INTERFACE 39 +#define DUK_TOK_LET 40 +#define DUK_TOK_PACKAGE 41 +#define DUK_TOK_PRIVATE 42 +#define DUK_TOK_PROTECTED 43 +#define DUK_TOK_PUBLIC 44 +#define DUK_TOK_STATIC 45 +#define DUK_TOK_YIELD 46 -#define DUK_TOK_END_RESERVED 49 /* exclusive */ +#define DUK_TOK_END_RESERVED 47 /* exclusive */ /* "get" and "set" are tokens but NOT ReservedWords. They are currently * parsed and identifiers and these defines are actually now unused. */ -#define DUK_TOK_GET 49 -#define DUK_TOK_SET 50 +#define DUK_TOK_GET 47 +#define DUK_TOK_SET 48 /* punctuators (unlike the spec, also includes "/" and "/=") */ -#define DUK_TOK_LCURLY 51 -#define DUK_TOK_RCURLY 52 -#define DUK_TOK_LBRACKET 53 -#define DUK_TOK_RBRACKET 54 -#define DUK_TOK_LPAREN 55 -#define DUK_TOK_RPAREN 56 -#define DUK_TOK_PERIOD 57 -#define DUK_TOK_SEMICOLON 58 -#define DUK_TOK_COMMA 59 -#define DUK_TOK_LT 60 -#define DUK_TOK_GT 61 -#define DUK_TOK_LE 62 -#define DUK_TOK_GE 63 -#define DUK_TOK_EQ 64 -#define DUK_TOK_NEQ 65 -#define DUK_TOK_SEQ 66 -#define DUK_TOK_SNEQ 67 -#define DUK_TOK_ADD 68 -#define DUK_TOK_SUB 69 -#define DUK_TOK_MUL 70 -#define DUK_TOK_DIV 71 -#define DUK_TOK_MOD 72 -#define DUK_TOK_INCREMENT 73 -#define DUK_TOK_DECREMENT 74 -#define DUK_TOK_ALSHIFT 75 /* named "arithmetic" because result is signed */ -#define DUK_TOK_ARSHIFT 76 -#define DUK_TOK_RSHIFT 77 -#define DUK_TOK_BAND 78 -#define DUK_TOK_BOR 79 -#define DUK_TOK_BXOR 80 -#define DUK_TOK_LNOT 81 -#define DUK_TOK_BNOT 82 -#define DUK_TOK_LAND 83 -#define DUK_TOK_LOR 84 -#define DUK_TOK_QUESTION 85 -#define DUK_TOK_COLON 86 -#define DUK_TOK_EQUALSIGN 87 -#define DUK_TOK_ADD_EQ 88 -#define DUK_TOK_SUB_EQ 89 -#define DUK_TOK_MUL_EQ 90 -#define DUK_TOK_DIV_EQ 91 -#define DUK_TOK_MOD_EQ 92 -#define DUK_TOK_ALSHIFT_EQ 93 -#define DUK_TOK_ARSHIFT_EQ 94 -#define DUK_TOK_RSHIFT_EQ 95 -#define DUK_TOK_BAND_EQ 96 -#define DUK_TOK_BOR_EQ 97 -#define DUK_TOK_BXOR_EQ 98 +#define DUK_TOK_LCURLY 49 +#define DUK_TOK_RCURLY 50 +#define DUK_TOK_LBRACKET 51 +#define DUK_TOK_RBRACKET 52 +#define DUK_TOK_LPAREN 53 +#define DUK_TOK_RPAREN 54 +#define DUK_TOK_PERIOD 55 +#define DUK_TOK_SEMICOLON 56 +#define DUK_TOK_COMMA 57 +#define DUK_TOK_LT 58 +#define DUK_TOK_GT 59 +#define DUK_TOK_LE 60 +#define DUK_TOK_GE 61 +#define DUK_TOK_EQ 62 +#define DUK_TOK_NEQ 63 +#define DUK_TOK_SEQ 64 +#define DUK_TOK_SNEQ 65 +#define DUK_TOK_ADD 66 +#define DUK_TOK_SUB 67 +#define DUK_TOK_MUL 68 +#define DUK_TOK_DIV 69 +#define DUK_TOK_MOD 70 +#define DUK_TOK_INCREMENT 71 +#define DUK_TOK_DECREMENT 72 +#define DUK_TOK_ALSHIFT 73 /* named "arithmetic" because result is signed */ +#define DUK_TOK_ARSHIFT 74 +#define DUK_TOK_RSHIFT 75 +#define DUK_TOK_BAND 76 +#define DUK_TOK_BOR 77 +#define DUK_TOK_BXOR 78 +#define DUK_TOK_LNOT 79 +#define DUK_TOK_BNOT 80 +#define DUK_TOK_LAND 81 +#define DUK_TOK_LOR 82 +#define DUK_TOK_QUESTION 83 +#define DUK_TOK_COLON 84 +#define DUK_TOK_EQUALSIGN 85 +#define DUK_TOK_ADD_EQ 86 +#define DUK_TOK_SUB_EQ 87 +#define DUK_TOK_MUL_EQ 88 +#define DUK_TOK_DIV_EQ 89 +#define DUK_TOK_MOD_EQ 90 +#define DUK_TOK_ALSHIFT_EQ 91 +#define DUK_TOK_ARSHIFT_EQ 92 +#define DUK_TOK_RSHIFT_EQ 93 +#define DUK_TOK_BAND_EQ 94 +#define DUK_TOK_BOR_EQ 95 +#define DUK_TOK_BXOR_EQ 96 /* literals (E5 Section 7.8), except null, true, false, which are treated * like reserved words (above). */ -#define DUK_TOK_NUMBER 99 -#define DUK_TOK_STRING 100 -#define DUK_TOK_REGEXP 101 +#define DUK_TOK_NUMBER 97 +#define DUK_TOK_STRING 98 +#define DUK_TOK_REGEXP 99 -#define DUK_TOK_MAXVAL 101 /* inclusive */ +#define DUK_TOK_MAXVAL 99 /* inclusive */ /* Convert heap string index to a token (reserved words) */ #define DUK_STRIDX_TO_TOK(x) ((x) - DUK_STRIDX_START_RESERVED + DUK_TOK_START_RESERVED) @@ -4426,17 +5761,19 @@ typedef void (*duk_re_range_callback)(void *user, duk_codepoint_t r1, duk_codepo #define DUK_RETOK_ATOM_START_CHARCLASS_INVERTED 21 #define DUK_RETOK_ATOM_END_GROUP 22 -/* constants for duk_lexer_ctx.buf */ -#define DUK_LEXER_TEMP_BUF_INITIAL 64 +/* Constants for duk_lexer_ctx.buf. */ #define DUK_LEXER_TEMP_BUF_LIMIT 256 -/* A token value. Can be memcpy()'d, but note that slot1/slot2 values are on the valstack. */ +/* A token value. Can be memcpy()'d, but note that slot1/slot2 values are on the valstack. + * Some fields (like num, str1, str2) are only valid for specific token types and may have + * stale values otherwise. + */ struct duk_token { duk_small_int_t t; /* token type (with reserved word identification) */ duk_small_int_t t_nores; /* token type (with reserved words as DUK_TOK_IDENTIFER) */ duk_double_t num; /* numeric value of token */ duk_hstring *str1; /* string 1 of token (borrowed, stored to ctx->slot1_idx) */ - duk_hstring *str2; /* string 2 of token (borrowed, stored to ctx->slot1_idx) */ + duk_hstring *str2; /* string 2 of token (borrowed, stored to ctx->slot2_idx) */ duk_size_t start_offset; /* start byte offset of token in lexer input */ duk_int_t start_line; /* start line of token (first char) */ duk_int_t num_escapes; /* number of escapes and line continuations (for directive prologue) */ @@ -4461,22 +5798,34 @@ struct duk_lexer_point { duk_int_t line; }; +/* Lexer codepoint with additional info like offset/line number */ +struct duk_lexer_codepoint { + duk_codepoint_t codepoint; + duk_size_t offset; + duk_int_t line; +}; + /* Lexer context. Same context is used for Ecmascript and Regexp parsing. */ struct duk_lexer_ctx { +#if defined(DUK_USE_LEXER_SLIDING_WINDOW) + duk_lexer_codepoint *window; /* unicode code points, window[0] is always next, points to 'buffer' */ + duk_lexer_codepoint buffer[DUK_LEXER_BUFFER_SIZE]; +#else + duk_lexer_codepoint window[DUK_LEXER_WINDOW_SIZE]; /* unicode code points, window[0] is always next */ +#endif + duk_hthread *thr; /* thread; minimizes argument passing */ const duk_uint8_t *input; /* input string (may be a user pointer) */ duk_size_t input_length; /* input byte length */ duk_size_t input_offset; /* input offset for window leading edge (not window[0]) */ - - duk_codepoint_t window[DUK_LEXER_WINDOW_SIZE]; /* window of unicode code points */ - duk_size_t offsets[DUK_LEXER_WINDOW_SIZE]; /* input byte offset for each char */ - duk_int_t lines[DUK_LEXER_WINDOW_SIZE]; /* input lines for each char */ duk_int_t input_line; /* input linenumber at input_offset (not window[0]), init to 1 */ + duk_idx_t slot1_idx; /* valstack slot for 1st token value */ duk_idx_t slot2_idx; /* valstack slot for 2nd token value */ duk_idx_t buf_idx; /* valstack slot for temp buffer */ - duk_hbuffer_dynamic *buf; /* temp accumulation buffer (on valstack) */ + duk_hbuffer_dynamic *buf; /* temp accumulation buffer */ + duk_bufwriter_ctx bw; /* bufwriter for temp accumulation */ duk_int_t token_count; /* number of tokens parsed */ duk_int_t token_limit; /* maximum token count before error (sanity backstop) */ @@ -4510,11 +5859,6 @@ DUK_INTERNAL_DECL void duk_lexer_parse_re_ranges(duk_lexer_ctx *lex_ctx, duk_re_ #define DUK_JS_COMPILER_H_INCLUDED /* ecmascript compiler limits */ -#if defined(DUK_USE_DEEP_C_STACK) -#define DUK_COMPILER_RECURSION_LIMIT 2500L -#else -#define DUK_COMPILER_RECURSION_LIMIT 50L -#endif #define DUK_COMPILER_TOKEN_LIMIT 100000000L /* 1e8: protects against deeply nested inner functions */ /* maximum loopcount for peephole optimization */ @@ -4620,8 +5964,10 @@ struct duk_compiler_func { * platforms (e.g. if int is 32 bits and pointers are 64 bits). */ + duk_bufwriter_ctx bw_code; /* bufwriter for code */ + duk_hstring *h_name; /* function name (borrowed reference), ends up in _name */ - duk_hbuffer_dynamic *h_code; /* C array of duk_compiler_instr */ + /* h_code: held in bw_code */ duk_hobject *h_consts; /* array */ duk_hobject *h_funcs; /* array of function templates: [func1, offset1, line1, func2, offset2, line2] * offset/line points to closing brace to allow skipping on pass 2 @@ -4636,7 +5982,7 @@ struct duk_compiler_func { duk_hobject *h_varmap; /* variable map for pass 2 (identifier -> register number or null (unmapped)) */ /* value stack indices for tracking objects */ - duk_idx_t code_idx; + /* code_idx: not needed */ duk_idx_t consts_idx; duk_idx_t funcs_idx; duk_idx_t decls_idx; @@ -4682,7 +6028,7 @@ struct duk_compiler_func { duk_bool_t is_setget; /* is a setter/getter */ duk_bool_t is_decl; /* is a function declaration (as opposed to function expression) */ duk_bool_t is_strict; /* function is strict */ - duk_bool_t is_notail; /* function must not be tailcalled */ + duk_bool_t is_notail; /* function must not be tail called */ duk_bool_t in_directive_prologue; /* parsing in "directive prologue", recognize directives */ duk_bool_t in_scanning; /* parsing in "scanning" phase (first pass) */ duk_bool_t may_direct_eval; /* function may call direct eval */ @@ -4725,7 +6071,7 @@ struct duk_compiler_ctx { * Prototypes */ -#define DUK_JS_COMPILE_FLAG_EVAL (1 << 0) /* source is eval code (not program) */ +#define DUK_JS_COMPILE_FLAG_EVAL (1 << 0) /* source is eval code (not global) */ #define DUK_JS_COMPILE_FLAG_STRICT (1 << 1) /* strict outer context */ #define DUK_JS_COMPILE_FLAG_FUNCEXPR (1 << 2) /* source is a function expression (used for Function constructor) */ @@ -4744,19 +6090,9 @@ DUK_INTERNAL_DECL void duk_js_compile(duk_hthread *thr, const duk_uint8_t *src_b #define DUK_RE_MAX_ATOM_COPIES 1000 /* regexp compilation limits */ -#if defined(DUK_USE_DEEP_C_STACK) -#define DUK_RE_COMPILE_RECURSION_LIMIT 10000 -#else -#define DUK_RE_COMPILE_RECURSION_LIMIT 100 -#endif #define DUK_RE_COMPILE_TOKEN_LIMIT 100000000L /* 1e8 */ /* regexp execution limits */ -#if defined(DUK_USE_DEEP_C_STACK) -#define DUK_RE_EXECUTE_RECURSION_LIMIT 10000 -#else -#define DUK_RE_EXECUTE_RECURSION_LIMIT 100 -#endif #define DUK_RE_EXECUTE_STEPS_LIMIT 1000000000L /* 1e9 */ /* regexp opcodes */ @@ -4807,7 +6143,7 @@ struct duk_re_compiler_ctx { duk_uint32_t re_flags; duk_lexer_ctx lex; duk_re_token curr_token; - duk_hbuffer_dynamic *buf; + duk_bufwriter_ctx bw; duk_uint32_t captures; /* highest capture number emitted so far (used as: ++captures) */ duk_uint32_t highest_backref; duk_uint32_t recursion_depth; @@ -4839,7 +6175,7 @@ DUK_INTERNAL_DECL void duk_regexp_match_force_global(duk_hthread *thr); /* hack * * Selecting the tagged type format involves many trade-offs (memory * use, size and performance of generated code, portability, etc), - * see doc/types.txt for a detailed discussion (especially of how the + * see doc/types.rst for a detailed discussion (especially of how the * IEEE double format is used to pack tagged values). * * NB: because macro arguments are often expressions, macros should @@ -4861,11 +6197,6 @@ DUK_INTERNAL_DECL void duk_regexp_match_force_global(duk_hthread *thr); /* hack * Packed 8-byte representation */ -/* sanity */ -#if !defined(DUK_USE_PACKED_TVAL_POSSIBLE) -#error packed representation not supported -#endif - /* use duk_double_union as duk_tval directly */ typedef union duk_double_union duk_tval; @@ -4875,22 +6206,20 @@ typedef union duk_double_union duk_tval; #if defined(DUK_USE_FASTINT) #define DUK_TAG_FASTINT 0xfff1UL /* embed: integer value */ #endif -#define DUK_TAG_UNDEFINED 0xfff2UL /* embed: 0 or 1 (normal or unused) */ -#define DUK_TAG_NULL 0xfff3UL /* embed: nothing */ -#define DUK_TAG_BOOLEAN 0xfff4UL /* embed: 0 or 1 (false or true) */ +#define DUK_TAG_UNUSED 0xfff2UL /* marker; not actual tagged value */ +#define DUK_TAG_UNDEFINED 0xfff3UL /* embed: nothing */ +#define DUK_TAG_NULL 0xfff4UL /* embed: nothing */ +#define DUK_TAG_BOOLEAN 0xfff5UL /* embed: 0 or 1 (false or true) */ /* DUK_TAG_NUMBER would logically go here, but it has multiple 'tags' */ -#define DUK_TAG_POINTER 0xfff5UL /* embed: void ptr */ -#define DUK_TAG_LIGHTFUNC 0xfff6UL /* embed: func ptr */ -#define DUK_TAG_STRING 0xfff7UL /* embed: duk_hstring ptr */ -#define DUK_TAG_OBJECT 0xfff8UL /* embed: duk_hobject ptr */ -#define DUK_TAG_BUFFER 0xfff9UL /* embed: duk_hbuffer ptr */ +#define DUK_TAG_POINTER 0xfff6UL /* embed: void ptr */ +#define DUK_TAG_LIGHTFUNC 0xfff7UL /* embed: func ptr */ +#define DUK_TAG_STRING 0xfff8UL /* embed: duk_hstring ptr */ +#define DUK_TAG_OBJECT 0xfff9UL /* embed: duk_hobject ptr */ +#define DUK_TAG_BUFFER 0xfffaUL /* embed: duk_hbuffer ptr */ /* for convenience */ -#define DUK_XTAG_UNDEFINED_ACTUAL 0xfff20000UL -#define DUK_XTAG_UNDEFINED_UNUSED 0xfff20001UL -#define DUK_XTAG_NULL 0xfff30000UL -#define DUK_XTAG_BOOLEAN_FALSE 0xfff40000UL -#define DUK_XTAG_BOOLEAN_TRUE 0xfff40001UL +#define DUK_XTAG_BOOLEAN_FALSE 0xfff50000UL +#define DUK_XTAG_BOOLEAN_TRUE 0xfff50001UL /* two casts to avoid gcc warning: "warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]" */ #ifdef DUK_USE_64BIT_OPS @@ -4967,10 +6296,12 @@ typedef union duk_double_union duk_tval; #define DUK__TVAL_GET_FASTINT_I32(v) ((duk_int32_t) (v)->ui[DUK_DBL_IDX_UI1]) #endif /* DUK_USE_FASTINT */ -#define DUK_TVAL_SET_UNDEFINED_ACTUAL(v) DUK_DBLUNION_SET_HIGH32((v), DUK_XTAG_UNDEFINED_ACTUAL) -#define DUK_TVAL_SET_UNDEFINED_UNUSED(v) DUK_DBLUNION_SET_HIGH32((v), DUK_XTAG_UNDEFINED_UNUSED) - -/* Note: 16-bit initializer suffices (unlike for undefined/boolean) */ +#define DUK_TVAL_SET_UNDEFINED(v) do { \ + (v)->us[DUK_DBL_IDX_US0] = (duk_uint16_t) DUK_TAG_UNDEFINED; \ + } while (0) +#define DUK_TVAL_SET_UNUSED(v) do { \ + (v)->us[DUK_DBL_IDX_US0] = (duk_uint16_t) DUK_TAG_UNUSED; \ + } while (0) #define DUK_TVAL_SET_NULL(v) do { \ (v)->us[DUK_DBL_IDX_US0] = (duk_uint16_t) DUK_TAG_NULL; \ } while (0) @@ -4981,12 +6312,17 @@ typedef union duk_double_union duk_tval; /* Assumes that caller has normalized NaNs, otherwise trouble ahead. */ #if defined(DUK_USE_FASTINT) -#define DUK_TVAL_SET_DOUBLE(v,d) DUK_DBLUNION_SET_DOUBLE((v), (d)) +#define DUK_TVAL_SET_DOUBLE(v,d) do { \ + duk_double_t duk__dblval; \ + duk__dblval = (d); \ + DUK_ASSERT_DOUBLE_IS_NORMALIZED(duk__dblval); \ + DUK_DBLUNION_SET_DOUBLE((v), duk__dblval); \ + } while (0) #define DUK_TVAL_SET_FASTINT(v,i) DUK__TVAL_SET_FASTINT((v), (i)) #define DUK_TVAL_SET_FASTINT_I32(v,i) DUK__TVAL_SET_FASTINT_I32((v), (i)) #define DUK_TVAL_SET_FASTINT_U32(v,i) DUK__TVAL_SET_FASTINT_U32((v), (i)) #define DUK_TVAL_SET_NUMBER_CHKFAST(v,d) duk_tval_set_number_chkfast((v), (d)) -#define DUK_TVAL_SET_NUMBER(v,d) DUK_DBLUNION_SET_DOUBLE((v), (d)) +#define DUK_TVAL_SET_NUMBER(v,d) DUK_TVAL_SET_DOUBLE((v), (d)) #define DUK_TVAL_CHKFAST_INPLACE(v) do { \ duk_tval *duk__tv; \ duk_double_t duk__d; \ @@ -4997,9 +6333,14 @@ typedef union duk_double_union duk_tval; } \ } while (0) #else -#define DUK_TVAL_SET_NUMBER(v,d) DUK_DBLUNION_SET_DOUBLE((v), (d)) -#define DUK_TVAL_SET_NUMBER_CHKFAST(v,d) DUK_TVAL_SET_NUMBER((v), (d)) -#define DUK_TVAL_SET_DOUBLE(v,d) DUK_TVAL_SET_NUMBER((v), (d)) +#define DUK_TVAL_SET_DOUBLE(v,d) do { \ + duk_double_t duk__dblval; \ + duk__dblval = (d); \ + DUK_ASSERT_DOUBLE_IS_NORMALIZED(duk__dblval); \ + DUK_DBLUNION_SET_DOUBLE((v), duk__dblval); \ + } while (0) +#define DUK_TVAL_SET_NUMBER_CHKFAST(v,d) DUK_TVAL_SET_DOUBLE((v), (d)) +#define DUK_TVAL_SET_NUMBER(v,d) DUK_TVAL_SET_DOUBLE((v), (d)) #define DUK_TVAL_CHKFAST_INPLACE(v) do { } while (0) #endif @@ -5039,8 +6380,7 @@ typedef union duk_double_union duk_tval; #define DUK_TVAL_GET_TAG(v) ((duk_small_uint_t) (v)->us[DUK_DBL_IDX_US0]) #define DUK_TVAL_IS_UNDEFINED(v) (DUK_TVAL_GET_TAG((v)) == DUK_TAG_UNDEFINED) -#define DUK_TVAL_IS_UNDEFINED_ACTUAL(v) ((v)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_UNDEFINED_ACTUAL) -#define DUK_TVAL_IS_UNDEFINED_UNUSED(v) ((v)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_UNDEFINED_UNUSED) +#define DUK_TVAL_IS_UNUSED(v) (DUK_TVAL_GET_TAG((v)) == DUK_TAG_UNUSED) #define DUK_TVAL_IS_NULL(v) (DUK_TVAL_GET_TAG((v)) == DUK_TAG_NULL) #define DUK_TVAL_IS_BOOLEAN(v) (DUK_TVAL_GET_TAG((v)) == DUK_TAG_BOOLEAN) #define DUK_TVAL_IS_BOOLEAN_TRUE(v) ((v)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_BOOLEAN_TRUE) @@ -5060,11 +6400,11 @@ typedef union duk_double_union duk_tval; #define DUK_TVAL_IS_DOUBLE(v) DUK_TVAL_IS_NUMBER((v)) #endif +/* This is performance critical because it appears in every DECREF. */ #define DUK_TVAL_IS_HEAP_ALLOCATED(v) (DUK_TVAL_GET_TAG((v)) >= DUK_TAG_STRING) #if defined(DUK_USE_FASTINT) -/* Inlining is only effective in a single file build. */ -DUK_INTERNAL_DECL DUK_ALWAYS_INLINE duk_double_t duk_tval_get_number_packed(duk_tval *tv); +DUK_INTERNAL_DECL duk_double_t duk_tval_get_number_packed(duk_tval *tv); #endif #else /* DUK_USE_PACKED_TVAL */ @@ -5114,9 +6454,10 @@ struct duk_tval_struct { #define DUK_TAG_BOOLEAN 4 #define DUK_TAG_POINTER 5 #define DUK_TAG_LIGHTFUNC 6 -#define DUK_TAG_STRING 7 -#define DUK_TAG_OBJECT 8 -#define DUK_TAG_BUFFER 9 +#define DUK_TAG_UNUSED 7 /* marker; not actual tagged type */ +#define DUK_TAG_STRING 8 /* first heap allocated, match bit boundary */ +#define DUK_TAG_OBJECT 9 +#define DUK_TAG_BUFFER 10 /* DUK__TAG_NUMBER is intentionally first, as it is the default clause in code * to support the 8-byte representation. Further, it is a non-heap-allocated @@ -5125,14 +6466,12 @@ struct duk_tval_struct { */ /* setters */ -#define DUK_TVAL_SET_UNDEFINED_ACTUAL(tv) do { \ +#define DUK_TVAL_SET_UNDEFINED(tv) do { \ (tv)->t = DUK_TAG_UNDEFINED; \ - (tv)->v.i = 0; \ } while (0) -#define DUK_TVAL_SET_UNDEFINED_UNUSED(tv) do { \ - (tv)->t = DUK_TAG_UNDEFINED; \ - (tv)->v.i = 1; \ +#define DUK_TVAL_SET_UNUSED(tv) do { \ + (tv)->t = DUK_TAG_UNUSED; \ } while (0) #define DUK_TVAL_SET_NULL(tv) do { \ @@ -5179,7 +6518,7 @@ struct duk_tval_struct { (tv)->t = DUK__TAG_NUMBER; \ (tv)->v.d = (val); \ } while (0) -#define DUK_TVAL_SET_NUMBER_CHKFAST(v,d) \ +#define DUK_TVAL_SET_NUMBER_CHKFAST(tv,d) \ DUK_TVAL_SET_NUMBER((tv), (d)) #define DUK_TVAL_SET_DOUBLE(v,d) \ DUK_TVAL_SET_NUMBER((tv), (d)) @@ -5257,8 +6596,7 @@ struct duk_tval_struct { /* decoding */ #define DUK_TVAL_GET_TAG(tv) ((tv)->t) #define DUK_TVAL_IS_UNDEFINED(tv) ((tv)->t == DUK_TAG_UNDEFINED) -#define DUK_TVAL_IS_UNDEFINED_ACTUAL(tv) (((tv)->t == DUK_TAG_UNDEFINED) && ((tv)->v.i == 0)) -#define DUK_TVAL_IS_UNDEFINED_UNUSED(tv) (((tv)->t == DUK_TAG_UNDEFINED) && ((tv)->v.i != 0)) +#define DUK_TVAL_IS_UNUSED(tv) ((tv)->t == DUK_TAG_UNUSED) #define DUK_TVAL_IS_NULL(tv) ((tv)->t == DUK_TAG_NULL) #define DUK_TVAL_IS_BOOLEAN(tv) ((tv)->t == DUK_TAG_BOOLEAN) #define DUK_TVAL_IS_BOOLEAN_TRUE(tv) (((tv)->t == DUK_TAG_BOOLEAN) && ((tv)->v.i != 0)) @@ -5278,14 +6616,21 @@ struct duk_tval_struct { #define DUK_TVAL_IS_OBJECT(tv) ((tv)->t == DUK_TAG_OBJECT) #define DUK_TVAL_IS_BUFFER(tv) ((tv)->t == DUK_TAG_BUFFER) +/* This is performance critical because it's needed for every DECREF. + * Take advantage of the fact that the first heap allocated tag is 8, + * so that bit 3 is set for all heap allocated tags (and never set for + * non-heap-allocated tags). + */ +#if 0 #define DUK_TVAL_IS_HEAP_ALLOCATED(tv) ((tv)->t >= DUK_TAG_STRING) +#endif +#define DUK_TVAL_IS_HEAP_ALLOCATED(tv) ((tv)->t & 0x08) #if defined(DUK_USE_FASTINT) -/* Inlining is only effective in a single file build. */ #if 0 -DUK_INTERNAL_DECL DUK_ALWAYS_INLINE duk_double_t duk_tval_get_number_unpacked(duk_tval *tv); +DUK_INTERNAL_DECL duk_double_t duk_tval_get_number_unpacked(duk_tval *tv); #endif -DUK_INTERNAL_DECL DUK_ALWAYS_INLINE duk_double_t duk_tval_get_number_unpacked_fastint(duk_tval *tv); +DUK_INTERNAL_DECL duk_double_t duk_tval_get_number_unpacked_fastint(duk_tval *tv); #endif #endif /* DUK_USE_PACKED_TVAL */ @@ -5660,6 +7005,8 @@ struct duk_heaphdr_string { #define DUK_HCOMPILEDFUNCTION_DECREF(thr,h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj) #define DUK_HNATIVEFUNCTION_INCREF(thr,h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj) #define DUK_HNATIVEFUNCTION_DECREF(thr,h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj) +#define DUK_HBUFFEROBJECT_INCREF(thr,h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj) +#define DUK_HBUFFEROBJECT_DECREF(thr,h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj) #define DUK_HTHREAD_INCREF(thr,h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj) #define DUK_HTHREAD_DECREF(thr,h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj) @@ -5677,6 +7024,189 @@ struct duk_heaphdr_string { } \ } while (0) +/* + * Macros to set a duk_tval and update refcount of the target (decref the + * old value and incref the new value if necessary). This is both performance + * and footprint critical; any changes made should be measured for size/speed. + */ + +#define DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0(thr,tvptr_dst) do { \ + duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \ + DUK_TVAL_SET_UNDEFINED(tv__dst); \ + DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \ + } while (0) + +#define DUK_TVAL_SET_UNUSED_UPDREF_ALT0(thr,tvptr_dst) do { \ + duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \ + DUK_TVAL_SET_UNUSED(tv__dst); \ + DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \ + } while (0) + +#define DUK_TVAL_SET_NULL_UPDREF_ALT0(thr,tvptr_dst) do { \ + duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \ + DUK_TVAL_SET_NULL(tv__dst); \ + DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \ + } while (0) + +#define DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \ + DUK_TVAL_SET_BOOLEAN(tv__dst, (newval)); \ + DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \ + } while (0) + +#define DUK_TVAL_SET_NUMBER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \ + DUK_TVAL_SET_NUMBER(tv__dst, (newval)); \ + DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \ + } while (0) +#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \ + DUK_TVAL_SET_NUMBER_CHKFAST(tv__dst, (newval)); \ + DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \ + } while (0) +#define DUK_TVAL_SET_DOUBLE_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \ + DUK_TVAL_SET_DOUBLE(tv__dst, (newval)); \ + DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \ + } while (0) +#define DUK_TVAL_SET_NAN_UPDREF_ALT0(thr,tvptr_dst) do { \ + duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \ + DUK_TVAL_SET_NAN(tv__dst); \ + DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \ + } while (0) +#if defined(DUK_USE_FASTINT) +#define DUK_TVAL_SET_FASTINT_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \ + DUK_TVAL_SET_FASTINT(tv__dst, (newval)); \ + DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \ + } while (0) +#define DUK_TVAL_SET_FASTINT_I32_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \ + DUK_TVAL_SET_FASTINT_I32(tv__dst, (newval)); \ + DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \ + } while (0) +#define DUK_TVAL_SET_FASTINT_U32_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \ + DUK_TVAL_SET_FASTINT_U32(tv__dst, (newval)); \ + DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \ + } while (0) +#endif /* DUK_USE_FASTINT */ + +#define DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0(thr,tvptr_dst,lf_v,lf_fp,lf_flags) do { \ + duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \ + DUK_TVAL_SET_LIGHTFUNC(tv__dst, (lf_v), (lf_fp), (lf_flags)); \ + DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \ + } while (0) + +#define DUK_TVAL_SET_STRING_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \ + DUK_TVAL_SET_STRING(tv__dst, (newval)); \ + DUK_HSTRING_INCREF((thr), (newval)); \ + DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \ + } while (0) + +#define DUK_TVAL_SET_OBJECT_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \ + DUK_TVAL_SET_OBJECT(tv__dst, (newval)); \ + DUK_HOBJECT_INCREF((thr), (newval)); \ + DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \ + } while (0) + +#define DUK_TVAL_SET_BUFFER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \ + DUK_TVAL_SET_BUFFER(tv__dst, (newval)); \ + DUK_HBUFFER_INCREF((thr), (newval)); \ + DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \ + } while (0) + +#define DUK_TVAL_SET_POINTER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \ + DUK_TVAL_SET_POINTER(tv__dst, (newval)); \ + DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \ + } while (0) + +/* DUK_TVAL_SET_TVAL_UPDREF() is used a lot in executor, property lookups, + * etc, so it's very important for performance. Measure when changing. + * + * NOTE: the source and destination duk_tval pointers may be the same, and + * the macros MUST deal with that correctly. + */ + +/* Original idiom used, minimal code size. */ +#define DUK_TVAL_SET_TVAL_UPDREF_ALT0(thr,tvptr_dst,tvptr_src) do { \ + duk_tval *tv__dst, *tv__src; duk_tval tv__tmp; \ + tv__dst = (tvptr_dst); tv__src = (tvptr_src); \ + DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \ + DUK_TVAL_SET_TVAL(tv__dst, tv__src); \ + DUK_TVAL_INCREF((thr), tv__src); \ + DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \ + } while (0) + +/* Faster alternative: avoid making a temporary copy of tvptr_dst and use + * fast incref/decref macros. + */ +#define DUK_TVAL_SET_TVAL_UPDREF_ALT1(thr,tvptr_dst,tvptr_src) do { \ + duk_tval *tv__dst, *tv__src; duk_heaphdr *h__obj; \ + tv__dst = (tvptr_dst); tv__src = (tvptr_src); \ + DUK_TVAL_INCREF_FAST((thr), tv__src); \ + if (DUK_TVAL_IS_HEAP_ALLOCATED(tv__dst)) { \ + h__obj = DUK_TVAL_GET_HEAPHDR(tv__dst); \ + DUK_ASSERT(h__obj != NULL); \ + DUK_TVAL_SET_TVAL(tv__dst, tv__src); \ + DUK_HEAPHDR_DECREF_FAST((thr), h__obj); /* side effects */ \ + } else { \ + DUK_TVAL_SET_TVAL(tv__dst, tv__src); \ + } \ + } while (0) + +/* XXX: no optimized variants yet */ +#define DUK_TVAL_SET_UNDEFINED_UPDREF DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0 +#define DUK_TVAL_SET_UNUSED_UPDREF DUK_TVAL_SET_UNUSED_UPDREF_ALT0 +#define DUK_TVAL_SET_NULL_UPDREF DUK_TVAL_SET_NULL_UPDREF_ALT0 +#define DUK_TVAL_SET_BOOLEAN_UPDREF DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0 +#define DUK_TVAL_SET_NUMBER_UPDREF DUK_TVAL_SET_NUMBER_UPDREF_ALT0 +#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0 +#define DUK_TVAL_SET_DOUBLE_UPDREF DUK_TVAL_SET_DOUBLE_UPDREF_ALT0 +#define DUK_TVAL_SET_NAN_UPDREF DUK_TVAL_SET_NAN_UPDREF_ALT0 +#if defined(DUK_USE_FASTINT) +#define DUK_TVAL_SET_FASTINT_UPDREF DUK_TVAL_SET_FASTINT_UPDREF_ALT0 +#define DUK_TVAL_SET_FASTINT_I32_UPDREF DUK_TVAL_SET_FASTINT_I32_UPDREF_ALT0 +#define DUK_TVAL_SET_FASTINT_U32_UPDREF DUK_TVAL_SET_FASTINT_U32_UPDREF_ALT0 +#endif /* DUK_USE_FASTINT */ +#define DUK_TVAL_SET_LIGHTFUNC_UPDREF DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0 +#define DUK_TVAL_SET_STRING_UPDREF DUK_TVAL_SET_STRING_UPDREF_ALT0 +#define DUK_TVAL_SET_OBJECT_UPDREF DUK_TVAL_SET_OBJECT_UPDREF_ALT0 +#define DUK_TVAL_SET_BUFFER_UPDREF DUK_TVAL_SET_BUFFER_UPDREF_ALT0 +#define DUK_TVAL_SET_POINTER_UPDREF DUK_TVAL_SET_POINTER_UPDREF_ALT0 + +#if defined(DUK_USE_FAST_REFCOUNT_DEFAULT) +/* Optimized for speed. */ +#define DUK_TVAL_SET_TVAL_UPDREF DUK_TVAL_SET_TVAL_UPDREF_ALT1 +#define DUK_TVAL_SET_TVAL_UPDREF_FAST DUK_TVAL_SET_TVAL_UPDREF_ALT1 +#define DUK_TVAL_SET_TVAL_UPDREF_SLOW DUK_TVAL_SET_TVAL_UPDREF_ALT0 +#else +/* Optimized for size. */ +#define DUK_TVAL_SET_TVAL_UPDREF DUK_TVAL_SET_TVAL_UPDREF_ALT0 +#define DUK_TVAL_SET_TVAL_UPDREF_FAST DUK_TVAL_SET_TVAL_UPDREF_ALT0 +#define DUK_TVAL_SET_TVAL_UPDREF_SLOW DUK_TVAL_SET_TVAL_UPDREF_ALT0 +#endif + #else /* DUK_USE_REFERENCE_COUNTING */ #define DUK_TVAL_INCREF_FAST(thr,v) do {} while (0) /* nop */ @@ -5701,11 +7231,135 @@ struct duk_heaphdr_string { #define DUK_HCOMPILEDFUNCTION_DECREF(thr,h) do {} while (0) /* nop */ #define DUK_HNATIVEFUNCTION_INCREF(thr,h) do {} while (0) /* nop */ #define DUK_HNATIVEFUNCTION_DECREF(thr,h) do {} while (0) /* nop */ +#define DUK_HBUFFEROBJECT_INCREF(thr,h) do {} while (0) /* nop */ +#define DUK_HBUFFEROBJECT_DECREF(thr,h) do {} while (0) /* nop */ #define DUK_HTHREAD_INCREF(thr,h) do {} while (0) /* nop */ #define DUK_HTHREAD_DECREF(thr,h) do {} while (0) /* nop */ #define DUK_HOBJECT_INCREF_ALLOWNULL(thr,h) do {} while (0) /* nop */ #define DUK_HOBJECT_DECREF_ALLOWNULL(thr,h) do {} while (0) /* nop */ +#define DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0(thr,tvptr_dst) do { \ + duk_tval *tv__dst; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_UNDEFINED(tv__dst); \ + DUK_UNREF((thr)); \ + } while (0) + +#define DUK_TVAL_SET_UNUSED_UPDREF_ALT0(thr,tvptr_dst) do { \ + duk_tval *tv__dst; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_UNUSED(tv__dst); \ + DUK_UNREF((thr)); \ + } while (0) + +#define DUK_TVAL_SET_NULL_UPDREF_ALT0(thr,tvptr_dst) do { \ + duk_tval *tv__dst; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_NULL(tv__dst); \ + DUK_UNREF((thr)); \ + } while (0) + +#define DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_BOOLEAN(tv__dst, (newval)); \ + DUK_UNREF((thr)); \ + } while (0) + +#define DUK_TVAL_SET_NUMBER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_NUMBER(tv__dst, (newval)); \ + DUK_UNREF((thr)); \ + } while (0) +#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_NUMBER_CHKFAST(tv__dst, (newval)); \ + DUK_UNREF((thr)); \ + } while (0) +#define DUK_TVAL_SET_DOUBLE_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_DOUBLE(tv__dst, (newval)); \ + DUK_UNREF((thr)); \ + } while (0) +#define DUK_TVAL_SET_NAN_UPDREF_ALT0(thr,tvptr_dst) do { \ + duk_tval *tv__dst; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_NAN(tv__dst); \ + DUK_UNREF((thr)); \ + } while (0) +#if defined(DUK_USE_FASTINT) +#define DUK_TVAL_SET_FASTINT_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_FASTINT(tv__dst, (newval)); \ + DUK_UNREF((thr)); \ + } while (0) +#define DUK_TVAL_SET_FASTINT_I32_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_FASTINT_I32(tv__dst, (newval)); \ + DUK_UNREF((thr)); \ + } while (0) +#define DUK_TVAL_SET_FASTINT_U32_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_FASTINT_U32(tv__dst, (newval)); \ + DUK_UNREF((thr)); \ + } while (0) +#endif /* DUK_USE_FASTINT */ + +#define DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0(thr,tvptr_dst,lf_v,lf_fp,lf_flags) do { \ + duk_tval *tv__dst; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_LIGHTFUNC(tv__dst, (lf_v), (lf_fp), (lf_flags)); \ + DUK_UNREF((thr)); \ + } while (0) + +#define DUK_TVAL_SET_STRING_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_STRING(tv__dst, (newval)); \ + DUK_UNREF((thr)); \ + } while (0) + +#define DUK_TVAL_SET_OBJECT_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_OBJECT(tv__dst, (newval)); \ + DUK_UNREF((thr)); \ + } while (0) + +#define DUK_TVAL_SET_BUFFER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_BUFFER(tv__dst, (newval)); \ + DUK_UNREF((thr)); \ + } while (0) + +#define DUK_TVAL_SET_POINTER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \ + duk_tval *tv__dst; tv__dst = (tvptr_dst); \ + DUK_TVAL_SET_POINTER(tv__dst, (newval)); \ + DUK_UNREF((thr)); \ + } while (0) + +#define DUK_TVAL_SET_TVAL_UPDREF_ALT0(thr,tvptr_dst,tvptr_src) do { \ + duk_tval *tv__dst, *tv__src; \ + tv__dst = (tvptr_dst); tv__src = (tvptr_src); \ + DUK_TVAL_SET_TVAL(tv__dst, tv__src); \ + DUK_UNREF((thr)); \ + } while (0) + +#define DUK_TVAL_SET_UNDEFINED_UPDREF DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0 +#define DUK_TVAL_SET_UNUSED_UPDREF DUK_TVAL_SET_UNUSED_UPDREF_ALT0 +#define DUK_TVAL_SET_NULL_UPDREF DUK_TVAL_SET_NULL_UPDREF_ALT0 +#define DUK_TVAL_SET_BOOLEAN_UPDREF DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0 +#define DUK_TVAL_SET_NUMBER_UPDREF DUK_TVAL_SET_NUMBER_UPDREF_ALT0 +#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0 +#define DUK_TVAL_SET_DOUBLE_UPDREF DUK_TVAL_SET_DOUBLE_UPDREF_ALT0 +#define DUK_TVAL_SET_NAN_UPDREF DUK_TVAL_SET_NAN_UPDREF_ALT0 +#if defined(DUK_USE_FASTINT) +#define DUK_TVAL_SET_FASTINT_UPDREF DUK_TVAL_SET_FASTINT_UPDREF_ALT0 +#define DUK_TVAL_SET_FASTINT_I32_UPDREF DUK_TVAL_SET_FASTINT_I32_UPDREF_ALT0 +#define DUK_TVAL_SET_FASTINT_U32_UPDREF DUK_TVAL_SET_FASTINT_U32_UPDREF_ALT0 +#endif /* DUK_USE_FASTINT */ +#define DUK_TVAL_SET_LIGHTFUNC_UPDREF DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0 +#define DUK_TVAL_SET_STRING_UPDREF DUK_TVAL_SET_STRING_UPDREF_ALT0 +#define DUK_TVAL_SET_OBJECT_UPDREF DUK_TVAL_SET_OBJECT_UPDREF_ALT0 +#define DUK_TVAL_SET_BUFFER_UPDREF DUK_TVAL_SET_BUFFER_UPDREF_ALT0 +#define DUK_TVAL_SET_POINTER_UPDREF DUK_TVAL_SET_POINTER_UPDREF_ALT0 + +#define DUK_TVAL_SET_TVAL_UPDREF DUK_TVAL_SET_TVAL_UPDREF_ALT0 +#define DUK_TVAL_SET_TVAL_UPDREF_FAST DUK_TVAL_SET_TVAL_UPDREF_ALT0 +#define DUK_TVAL_SET_TVAL_UPDREF_SLOW DUK_TVAL_SET_TVAL_UPDREF_ALT0 + #endif /* DUK_USE_REFERENCE_COUNTING */ #endif /* DUK_HEAPHDR_H_INCLUDED */ @@ -5740,6 +7394,10 @@ duk_bool_t duk_valstack_resize_raw(duk_context *ctx, duk_size_t min_new_size, duk_small_uint_t flags); +#if defined(DUK_USE_VERBOSE_ERRORS) && defined(DUK_USE_PARANOID_ERRORS) +DUK_INTERNAL_DECL const char *duk_get_type_name(duk_context *ctx, duk_idx_t index); +#endif + DUK_INTERNAL_DECL duk_tval *duk_get_tval(duk_context *ctx, duk_idx_t index); DUK_INTERNAL_DECL duk_tval *duk_require_tval(duk_context *ctx, duk_idx_t index); DUK_INTERNAL_DECL void duk_push_tval(duk_context *ctx, duk_tval *tv); @@ -5755,6 +7413,18 @@ DUK_INTERNAL_DECL duk_hobject *duk_push_this_coercible_to_object(duk_context *ct /* duk_push_this() + CheckObjectCoercible() + duk_to_string() */ DUK_INTERNAL_DECL duk_hstring *duk_push_this_coercible_to_string(duk_context *ctx); +/* Get a borrowed duk_tval pointer to the current 'this' binding. Caller must + * make sure there's an active callstack entry. Note that the returned pointer + * is unstable with regards to side effects. + */ +DUK_INTERNAL_DECL duk_tval *duk_get_borrowed_this_tval(duk_context *ctx); + +/* XXX: add fastint support? */ +#define duk_push_u64(ctx,val) \ + duk_push_number((ctx), (duk_double_t) (val)) +#define duk_push_i64(ctx,val) \ + duk_push_number((ctx), (duk_double_t) (val)) + /* duk_push_(u)int() is guaranteed to support at least (un)signed 32-bit range */ #define duk_push_u32(ctx,val) \ duk_push_uint((ctx), (duk_uint_t) (val)) @@ -5769,13 +7439,6 @@ DUK_INTERNAL_DECL duk_hstring *duk_push_this_coercible_to_string(duk_context *ct #define duk_push_size_t(ctx,val) \ duk_push_uint((ctx), (duk_uint_t) (val)) /* XXX: assumed to fit for now */ -/* internal helper for looking up a tagged type */ -#define DUK_GETTAGGED_FLAG_ALLOW_NULL (1L << 24) -#define DUK_GETTAGGED_FLAG_CHECK_CLASS (1L << 25) -#define DUK_GETTAGGED_CLASS_SHIFT 16 - -DUK_INTERNAL_DECL duk_heaphdr *duk_get_tagged_heaphdr_raw(duk_context *ctx, duk_idx_t index, duk_uint_t flags_and_tag); - DUK_INTERNAL_DECL duk_hstring *duk_get_hstring(duk_context *ctx, duk_idx_t index); DUK_INTERNAL_DECL duk_hobject *duk_get_hobject(duk_context *ctx, duk_idx_t index); DUK_INTERNAL_DECL duk_hbuffer *duk_get_hbuffer(duk_context *ctx, duk_idx_t index); @@ -5783,10 +7446,7 @@ DUK_INTERNAL_DECL duk_hthread *duk_get_hthread(duk_context *ctx, duk_idx_t index DUK_INTERNAL_DECL duk_hcompiledfunction *duk_get_hcompiledfunction(duk_context *ctx, duk_idx_t index); DUK_INTERNAL_DECL duk_hnativefunction *duk_get_hnativefunction(duk_context *ctx, duk_idx_t index); -#define duk_get_hobject_with_class(ctx,index,classnum) \ - ((duk_hobject *) duk_get_tagged_heaphdr_raw((ctx), (index), \ - DUK_TAG_OBJECT | DUK_GETTAGGED_FLAG_ALLOW_NULL | \ - DUK_GETTAGGED_FLAG_CHECK_CLASS | ((classnum) << DUK_GETTAGGED_CLASS_SHIFT))) +DUK_INTERNAL_DECL duk_hobject *duk_get_hobject_with_class(duk_context *ctx, duk_idx_t index, duk_small_uint_t classnum); #if 0 /* This would be pointless: unexpected type and lightfunc would both return NULL */ DUK_INTERNAL_DECL duk_hobject *duk_get_hobject_or_lfunc(duk_context *ctx, duk_idx_t index); @@ -5798,30 +7458,33 @@ DUK_INTERNAL_DECL void *duk_get_voidptr(duk_context *ctx, duk_idx_t index); #endif DUK_INTERNAL_DECL duk_hstring *duk_to_hstring(duk_context *ctx, duk_idx_t index); +#if defined(DUK_USE_DEBUGGER_SUPPORT) /* only needed by debugger for now */ +DUK_INTERNAL_DECL duk_hstring *duk_safe_to_hstring(duk_context *ctx, duk_idx_t index); +#endif +DUK_INTERNAL_DECL void duk_to_object_class_string_top(duk_context *ctx); +#if !defined(DUK_USE_PARANOID_ERRORS) +DUK_INTERNAL_DECL void duk_push_hobject_class_string(duk_context *ctx, duk_hobject *h); +#endif + DUK_INTERNAL_DECL duk_int_t duk_to_int_clamped_raw(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval, duk_bool_t *out_clamped); /* out_clamped=NULL, RangeError if outside range */ DUK_INTERNAL_DECL duk_int_t duk_to_int_clamped(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval); DUK_INTERNAL_DECL duk_int_t duk_to_int_check_range(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval); +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL_DECL duk_uint8_t duk_to_uint8clamped(duk_context *ctx, duk_idx_t index); +#endif DUK_INTERNAL_DECL duk_hstring *duk_require_hstring(duk_context *ctx, duk_idx_t index); DUK_INTERNAL_DECL duk_hobject *duk_require_hobject(duk_context *ctx, duk_idx_t index); DUK_INTERNAL_DECL duk_hbuffer *duk_require_hbuffer(duk_context *ctx, duk_idx_t index); DUK_INTERNAL_DECL duk_hthread *duk_require_hthread(duk_context *ctx, duk_idx_t index); -#if 0 /*unused */ DUK_INTERNAL_DECL duk_hcompiledfunction *duk_require_hcompiledfunction(duk_context *ctx, duk_idx_t index); -#endif DUK_INTERNAL_DECL duk_hnativefunction *duk_require_hnativefunction(duk_context *ctx, duk_idx_t index); -#define duk_require_hobject_with_class(ctx,index,classnum) \ - ((duk_hobject *) duk_get_tagged_heaphdr_raw((ctx), (index), \ - DUK_TAG_OBJECT | \ - DUK_GETTAGGED_FLAG_CHECK_CLASS | ((classnum) << DUK_GETTAGGED_CLASS_SHIFT))) +DUK_INTERNAL_DECL duk_hobject *duk_require_hobject_with_class(duk_context *ctx, duk_idx_t index, duk_small_uint_t classnum); DUK_INTERNAL_DECL duk_hobject *duk_require_hobject_or_lfunc(duk_context *ctx, duk_idx_t index); DUK_INTERNAL_DECL duk_hobject *duk_require_hobject_or_lfunc_coerce(duk_context *ctx, duk_idx_t index); -#if defined(DUK_USE_DEBUGGER_SUPPORT) -DUK_INTERNAL_DECL void duk_push_unused(duk_context *ctx); -#endif DUK_INTERNAL_DECL void duk_push_hstring(duk_context *ctx, duk_hstring *h); DUK_INTERNAL_DECL void duk_push_hstring_stridx(duk_context *ctx, duk_small_int_t stridx); DUK_INTERNAL_DECL void duk_push_hobject(duk_context *ctx, duk_hobject *h); @@ -5843,6 +7506,12 @@ DUK_INTERNAL_DECL void duk_push_c_function_noconstruct_noexotic(duk_context *ctx DUK_INTERNAL_DECL void duk_push_string_funcptr(duk_context *ctx, duk_uint8_t *ptr, duk_size_t sz); DUK_INTERNAL_DECL void duk_push_lightfunc_name(duk_context *ctx, duk_tval *tv); DUK_INTERNAL_DECL void duk_push_lightfunc_tostring(duk_context *ctx, duk_tval *tv); +DUK_INTERNAL_DECL duk_hbufferobject *duk_push_bufferobject_raw(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx); + +#if !defined(DUK_USE_PARANOID_ERRORS) +DUK_INTERNAL_DECL const char *duk_push_string_readable(duk_context *ctx, duk_idx_t index); +DUK_INTERNAL_DECL const char *duk_push_string_tval_readable(duk_context *ctx, duk_tval *tv); +#endif DUK_INTERNAL_DECL duk_bool_t duk_get_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx); /* [] -> [val] */ DUK_INTERNAL_DECL duk_bool_t duk_put_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx); /* [val] -> [] */ @@ -6108,21 +7777,20 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr #define DUK_HOBJECT_FLAG_BOUND DUK_HEAPHDR_USER_FLAG(2) /* object established using Function.prototype.bind() */ #define DUK_HOBJECT_FLAG_COMPILEDFUNCTION DUK_HEAPHDR_USER_FLAG(4) /* object is a compiled function (duk_hcompiledfunction) */ #define DUK_HOBJECT_FLAG_NATIVEFUNCTION DUK_HEAPHDR_USER_FLAG(5) /* object is a native function (duk_hnativefunction) */ -#define DUK_HOBJECT_FLAG_THREAD DUK_HEAPHDR_USER_FLAG(6) /* object is a thread (duk_hthread) */ -#define DUK_HOBJECT_FLAG_ARRAY_PART DUK_HEAPHDR_USER_FLAG(7) /* object has an array part (a_size may still be 0) */ -#define DUK_HOBJECT_FLAG_STRICT DUK_HEAPHDR_USER_FLAG(8) /* function: function object is strict */ -#define DUK_HOBJECT_FLAG_NOTAIL DUK_HEAPHDR_USER_FLAG(9) /* function: function must not be tailcalled */ -#define DUK_HOBJECT_FLAG_NEWENV DUK_HEAPHDR_USER_FLAG(10) /* function: create new environment when called (see duk_hcompiledfunction) */ -#define DUK_HOBJECT_FLAG_NAMEBINDING DUK_HEAPHDR_USER_FLAG(11) /* function: create binding for func name (function templates only, used for named function expressions) */ -#define DUK_HOBJECT_FLAG_CREATEARGS DUK_HEAPHDR_USER_FLAG(12) /* function: create an arguments object on function call */ -#define DUK_HOBJECT_FLAG_ENVRECCLOSED DUK_HEAPHDR_USER_FLAG(13) /* envrec: (declarative) record is closed */ -#define DUK_HOBJECT_FLAG_EXOTIC_ARRAY DUK_HEAPHDR_USER_FLAG(14) /* 'Array' object, array length and index exotic behavior */ -#define DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ DUK_HEAPHDR_USER_FLAG(15) /* 'String' object, array index exotic behavior */ -#define DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS DUK_HEAPHDR_USER_FLAG(16) /* 'Arguments' object and has arguments exotic behavior (non-strict callee) */ -#define DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC DUK_HEAPHDR_USER_FLAG(17) /* Duktape/C (nativefunction) object, exotic 'length' */ -#define DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ DUK_HEAPHDR_USER_FLAG(18) /* 'Buffer' object, array index exotic behavior, virtual 'length' */ +#define DUK_HOBJECT_FLAG_BUFFEROBJECT DUK_HEAPHDR_USER_FLAG(6) /* object is a buffer object (duk_hbufferobject) (always exotic) */ +#define DUK_HOBJECT_FLAG_THREAD DUK_HEAPHDR_USER_FLAG(7) /* object is a thread (duk_hthread) */ +#define DUK_HOBJECT_FLAG_ARRAY_PART DUK_HEAPHDR_USER_FLAG(8) /* object has an array part (a_size may still be 0) */ +#define DUK_HOBJECT_FLAG_STRICT DUK_HEAPHDR_USER_FLAG(9) /* function: function object is strict */ +#define DUK_HOBJECT_FLAG_NOTAIL DUK_HEAPHDR_USER_FLAG(10) /* function: function must not be tail called */ +#define DUK_HOBJECT_FLAG_NEWENV DUK_HEAPHDR_USER_FLAG(11) /* function: create new environment when called (see duk_hcompiledfunction) */ +#define DUK_HOBJECT_FLAG_NAMEBINDING DUK_HEAPHDR_USER_FLAG(12) /* function: create binding for func name (function templates only, used for named function expressions) */ +#define DUK_HOBJECT_FLAG_CREATEARGS DUK_HEAPHDR_USER_FLAG(13) /* function: create an arguments object on function call */ +#define DUK_HOBJECT_FLAG_ENVRECCLOSED DUK_HEAPHDR_USER_FLAG(14) /* envrec: (declarative) record is closed */ +#define DUK_HOBJECT_FLAG_EXOTIC_ARRAY DUK_HEAPHDR_USER_FLAG(15) /* 'Array' object, array length and index exotic behavior */ +#define DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ DUK_HEAPHDR_USER_FLAG(16) /* 'String' object, array index exotic behavior */ +#define DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS DUK_HEAPHDR_USER_FLAG(17) /* 'Arguments' object and has arguments exotic behavior (non-strict callee) */ +#define DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC DUK_HEAPHDR_USER_FLAG(18) /* Duktape/C (nativefunction) object, exotic 'length' */ #define DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ DUK_HEAPHDR_USER_FLAG(19) /* 'Proxy' object */ -/* bit 20 unused */ #define DUK_HOBJECT_FLAG_CLASS_BASE DUK_HEAPHDR_USER_FLAG_NUMBER(21) #define DUK_HOBJECT_FLAG_CLASS_BITS 5 @@ -6132,6 +7800,9 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr #define DUK_HOBJECT_SET_CLASS_NUMBER(h,v) \ DUK_HEAPHDR_SET_FLAG_RANGE(&(h)->hdr, DUK_HOBJECT_FLAG_CLASS_BASE, DUK_HOBJECT_FLAG_CLASS_BITS, (v)) +#define DUK_HOBJECT_GET_CLASS_MASK(h) \ + (1UL << DUK_HEAPHDR_GET_FLAG_RANGE(&(h)->hdr, DUK_HOBJECT_FLAG_CLASS_BASE, DUK_HOBJECT_FLAG_CLASS_BITS)) + /* Macro for creating flag initializer from a class number. * Unsigned type cast is needed to avoid warnings about coercing * a signed integer to an unsigned one; the largest class values @@ -6156,9 +7827,68 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr #define DUK_HOBJECT_CLASS_GLOBAL 13 #define DUK_HOBJECT_CLASS_OBJENV 14 /* custom */ #define DUK_HOBJECT_CLASS_DECENV 15 /* custom */ -#define DUK_HOBJECT_CLASS_BUFFER 16 /* custom */ +#define DUK_HOBJECT_CLASS_BUFFER 16 /* custom; implies DUK_HOBJECT_IS_BUFFEROBJECT */ #define DUK_HOBJECT_CLASS_POINTER 17 /* custom */ -#define DUK_HOBJECT_CLASS_THREAD 18 /* custom */ +#define DUK_HOBJECT_CLASS_THREAD 18 /* custom; implies DUK_HOBJECT_IS_THREAD */ +#define DUK_HOBJECT_CLASS_ARRAYBUFFER 19 /* implies DUK_HOBJECT_IS_BUFFEROBJECT */ +#define DUK_HOBJECT_CLASS_DATAVIEW 20 +#define DUK_HOBJECT_CLASS_INT8ARRAY 21 +#define DUK_HOBJECT_CLASS_UINT8ARRAY 22 +#define DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY 23 +#define DUK_HOBJECT_CLASS_INT16ARRAY 24 +#define DUK_HOBJECT_CLASS_UINT16ARRAY 25 +#define DUK_HOBJECT_CLASS_INT32ARRAY 26 +#define DUK_HOBJECT_CLASS_UINT32ARRAY 27 +#define DUK_HOBJECT_CLASS_FLOAT32ARRAY 28 +#define DUK_HOBJECT_CLASS_FLOAT64ARRAY 29 +#define DUK_HOBJECT_CLASS_MAX 29 + +/* class masks */ +#define DUK_HOBJECT_CMASK_ALL ((1UL << (DUK_HOBJECT_CLASS_MAX + 1)) - 1UL) +#define DUK_HOBJECT_CMASK_UNUSED (1UL << DUK_HOBJECT_CLASS_UNUSED) +#define DUK_HOBJECT_CMASK_ARGUMENTS (1UL << DUK_HOBJECT_CLASS_ARGUMENTS) +#define DUK_HOBJECT_CMASK_ARRAY (1UL << DUK_HOBJECT_CLASS_ARRAY) +#define DUK_HOBJECT_CMASK_BOOLEAN (1UL << DUK_HOBJECT_CLASS_BOOLEAN) +#define DUK_HOBJECT_CMASK_DATE (1UL << DUK_HOBJECT_CLASS_DATE) +#define DUK_HOBJECT_CMASK_ERROR (1UL << DUK_HOBJECT_CLASS_ERROR) +#define DUK_HOBJECT_CMASK_FUNCTION (1UL << DUK_HOBJECT_CLASS_FUNCTION) +#define DUK_HOBJECT_CMASK_JSON (1UL << DUK_HOBJECT_CLASS_JSON) +#define DUK_HOBJECT_CMASK_MATH (1UL << DUK_HOBJECT_CLASS_MATH) +#define DUK_HOBJECT_CMASK_NUMBER (1UL << DUK_HOBJECT_CLASS_NUMBER) +#define DUK_HOBJECT_CMASK_OBJECT (1UL << DUK_HOBJECT_CLASS_OBJECT) +#define DUK_HOBJECT_CMASK_REGEXP (1UL << DUK_HOBJECT_CLASS_REGEXP) +#define DUK_HOBJECT_CMASK_STRING (1UL << DUK_HOBJECT_CLASS_STRING) +#define DUK_HOBJECT_CMASK_GLOBAL (1UL << DUK_HOBJECT_CLASS_GLOBAL) +#define DUK_HOBJECT_CMASK_OBJENV (1UL << DUK_HOBJECT_CLASS_OBJENV) +#define DUK_HOBJECT_CMASK_DECENV (1UL << DUK_HOBJECT_CLASS_DECENV) +#define DUK_HOBJECT_CMASK_BUFFER (1UL << DUK_HOBJECT_CLASS_BUFFER) +#define DUK_HOBJECT_CMASK_POINTER (1UL << DUK_HOBJECT_CLASS_POINTER) +#define DUK_HOBJECT_CMASK_THREAD (1UL << DUK_HOBJECT_CLASS_THREAD) +#define DUK_HOBJECT_CMASK_ARRAYBUFFER (1UL << DUK_HOBJECT_CLASS_ARRAYBUFFER) +#define DUK_HOBJECT_CMASK_DATAVIEW (1UL << DUK_HOBJECT_CLASS_DATAVIEW) +#define DUK_HOBJECT_CMASK_INT8ARRAY (1UL << DUK_HOBJECT_CLASS_INT8ARRAY) +#define DUK_HOBJECT_CMASK_UINT8ARRAY (1UL << DUK_HOBJECT_CLASS_UINT8ARRAY) +#define DUK_HOBJECT_CMASK_UINT8CLAMPEDARRAY (1UL << DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY) +#define DUK_HOBJECT_CMASK_INT16ARRAY (1UL << DUK_HOBJECT_CLASS_INT16ARRAY) +#define DUK_HOBJECT_CMASK_UINT16ARRAY (1UL << DUK_HOBJECT_CLASS_UINT16ARRAY) +#define DUK_HOBJECT_CMASK_INT32ARRAY (1UL << DUK_HOBJECT_CLASS_INT32ARRAY) +#define DUK_HOBJECT_CMASK_UINT32ARRAY (1UL << DUK_HOBJECT_CLASS_UINT32ARRAY) +#define DUK_HOBJECT_CMASK_FLOAT32ARRAY (1UL << DUK_HOBJECT_CLASS_FLOAT32ARRAY) +#define DUK_HOBJECT_CMASK_FLOAT64ARRAY (1UL << DUK_HOBJECT_CLASS_FLOAT64ARRAY) + +#define DUK_HOBJECT_CMASK_ALL_BUFFEROBJECTS \ + (DUK_HOBJECT_CMASK_BUFFER | \ + DUK_HOBJECT_CMASK_ARRAYBUFFER | \ + DUK_HOBJECT_CMASK_DATAVIEW | \ + DUK_HOBJECT_CMASK_INT8ARRAY | \ + DUK_HOBJECT_CMASK_UINT8ARRAY | \ + DUK_HOBJECT_CMASK_UINT8CLAMPEDARRAY | \ + DUK_HOBJECT_CMASK_INT16ARRAY | \ + DUK_HOBJECT_CMASK_UINT16ARRAY | \ + DUK_HOBJECT_CMASK_INT32ARRAY | \ + DUK_HOBJECT_CMASK_UINT32ARRAY | \ + DUK_HOBJECT_CMASK_FLOAT32ARRAY | \ + DUK_HOBJECT_CMASK_FLOAT64ARRAY) #define DUK_HOBJECT_IS_OBJENV(h) (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_OBJENV) #define DUK_HOBJECT_IS_DECENV(h) (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_DECENV) @@ -6166,6 +7896,7 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr #define DUK_HOBJECT_IS_ARRAY(h) (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_ARRAY) #define DUK_HOBJECT_IS_COMPILEDFUNCTION(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION) #define DUK_HOBJECT_IS_NATIVEFUNCTION(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION) +#define DUK_HOBJECT_IS_BUFFEROBJECT(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFFEROBJECT) #define DUK_HOBJECT_IS_THREAD(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD) #define DUK_HOBJECT_IS_NONBOUND_FUNCTION(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \ @@ -6187,7 +7918,7 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS | \ DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ | \ DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC | \ - DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ | \ + DUK_HOBJECT_FLAG_BUFFEROBJECT | \ DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ) #define DUK_HOBJECT_HAS_EXOTIC_BEHAVIOR(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_EXOTIC_BEHAVIOR_FLAGS) @@ -6197,6 +7928,7 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr #define DUK_HOBJECT_HAS_BOUND(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND) #define DUK_HOBJECT_HAS_COMPILEDFUNCTION(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION) #define DUK_HOBJECT_HAS_NATIVEFUNCTION(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION) +#define DUK_HOBJECT_HAS_BUFFEROBJECT(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFFEROBJECT) #define DUK_HOBJECT_HAS_THREAD(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD) #define DUK_HOBJECT_HAS_ARRAY_PART(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART) #define DUK_HOBJECT_HAS_STRICT(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT) @@ -6209,7 +7941,6 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr #define DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ) #define DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS) #define DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC) -#define DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ) #define DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ) #define DUK_HOBJECT_SET_EXTENSIBLE(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE) @@ -6217,6 +7948,7 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr #define DUK_HOBJECT_SET_BOUND(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND) #define DUK_HOBJECT_SET_COMPILEDFUNCTION(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION) #define DUK_HOBJECT_SET_NATIVEFUNCTION(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION) +#define DUK_HOBJECT_SET_BUFFEROBJECT(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFFEROBJECT) #define DUK_HOBJECT_SET_THREAD(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD) #define DUK_HOBJECT_SET_ARRAY_PART(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART) #define DUK_HOBJECT_SET_STRICT(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT) @@ -6229,7 +7961,6 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr #define DUK_HOBJECT_SET_EXOTIC_STRINGOBJ(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ) #define DUK_HOBJECT_SET_EXOTIC_ARGUMENTS(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS) #define DUK_HOBJECT_SET_EXOTIC_DUKFUNC(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC) -#define DUK_HOBJECT_SET_EXOTIC_BUFFEROBJ(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ) #define DUK_HOBJECT_SET_EXOTIC_PROXYOBJ(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ) #define DUK_HOBJECT_CLEAR_EXTENSIBLE(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE) @@ -6237,6 +7968,7 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr #define DUK_HOBJECT_CLEAR_BOUND(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND) #define DUK_HOBJECT_CLEAR_COMPILEDFUNCTION(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION) #define DUK_HOBJECT_CLEAR_NATIVEFUNCTION(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION) +#define DUK_HOBJECT_CLEAR_BUFFEROBJECT(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFFEROBJECT) #define DUK_HOBJECT_CLEAR_THREAD(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD) #define DUK_HOBJECT_CLEAR_ARRAY_PART(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART) #define DUK_HOBJECT_CLEAR_STRICT(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT) @@ -6249,7 +7981,6 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr #define DUK_HOBJECT_CLEAR_EXOTIC_STRINGOBJ(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ) #define DUK_HOBJECT_CLEAR_EXOTIC_ARGUMENTS(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS) #define DUK_HOBJECT_CLEAR_EXOTIC_DUKFUNC(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC) -#define DUK_HOBJECT_CLEAR_EXOTIC_BUFFEROBJ(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ) #define DUK_HOBJECT_CLEAR_EXOTIC_PROXYOBJ(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ) /* flags used for property attributes in duk_propdesc and packed flags */ @@ -6282,6 +8013,31 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr DUK_PROPDESC_FLAG_ENUMERABLE | \ DUK_PROPDESC_FLAG_CONFIGURABLE) +/* + * Macro for object validity check + * + * Assert for currently guaranteed relations between flags, for instance. + */ + +#define DUK_ASSERT_HOBJECT_VALID(h) do { \ + DUK_ASSERT((h) != NULL); \ + DUK_ASSERT(!DUK_HOBJECT_IS_CALLABLE((h)) || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_FUNCTION); \ + DUK_ASSERT(!DUK_HOBJECT_IS_BUFFEROBJECT((h)) || \ + (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_BUFFER || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_ARRAYBUFFER || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_DATAVIEW || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_INT8ARRAY || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT8ARRAY || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_INT16ARRAY || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT16ARRAY || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_INT32ARRAY || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_UINT32ARRAY || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_FLOAT32ARRAY || \ + DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_FLOAT64ARRAY)); \ + } while (0) + /* * Macros to access the 'props' allocation. */ @@ -6296,32 +8052,32 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr #define DUK_HOBJECT_GET_PROPS(heap,h) \ ((h)->props) #define DUK_HOBJECT_SET_PROPS(heap,h,x) do { \ - (h)->props = (x); \ + (h)->props = (duk_uint8_t *) (x); \ } while (0) #endif #if defined(DUK_USE_HOBJECT_LAYOUT_1) /* LAYOUT 1 */ #define DUK_HOBJECT_E_GET_KEY_BASE(heap,h) \ - ((duk_hstring **) ( \ + ((duk_hstring **) (void *) ( \ DUK_HOBJECT_GET_PROPS((heap), (h)) \ )) #define DUK_HOBJECT_E_GET_VALUE_BASE(heap,h) \ - ((duk_propvalue *) ( \ + ((duk_propvalue *) (void *) ( \ DUK_HOBJECT_GET_PROPS((heap), (h)) + \ DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_hstring *) \ )) #define DUK_HOBJECT_E_GET_FLAGS_BASE(heap,h) \ - ((duk_uint8_t *) ( \ + ((duk_uint8_t *) (void *) ( \ DUK_HOBJECT_GET_PROPS((heap), (h)) + DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue)) \ )) #define DUK_HOBJECT_A_GET_BASE(heap,h) \ - ((duk_tval *) ( \ + ((duk_tval *) (void *) ( \ DUK_HOBJECT_GET_PROPS((heap), (h)) + \ DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) \ )) #define DUK_HOBJECT_H_GET_BASE(heap,h) \ - ((duk_uint32_t *) ( \ + ((duk_uint32_t *) (void *) ( \ DUK_HOBJECT_GET_PROPS((heap), (h)) + \ DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \ DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) \ @@ -6333,42 +8089,44 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr (n_hash) * sizeof(duk_uint32_t) \ ) #define DUK_HOBJECT_P_SET_REALLOC_PTRS(p_base,set_e_k,set_e_pv,set_e_f,set_a,set_h,n_ent,n_arr,n_hash) do { \ - (set_e_k) = (duk_hstring **) (p_base); \ - (set_e_pv) = (duk_propvalue *) ((set_e_k) + (n_ent)); \ - (set_e_f) = (duk_uint8_t *) ((set_e_pv) + (n_ent)); \ - (set_a) = (duk_tval *) ((set_e_f) + (n_ent)); \ - (set_h) = (duk_uint32_t *) ((set_a) + (n_arr)); \ + (set_e_k) = (duk_hstring **) (void *) (p_base); \ + (set_e_pv) = (duk_propvalue *) (void *) ((set_e_k) + (n_ent)); \ + (set_e_f) = (duk_uint8_t *) (void *) ((set_e_pv) + (n_ent)); \ + (set_a) = (duk_tval *) (void *) ((set_e_f) + (n_ent)); \ + (set_h) = (duk_uint32_t *) (void *) ((set_a) + (n_arr)); \ } while (0) #elif defined(DUK_USE_HOBJECT_LAYOUT_2) /* LAYOUT 2 */ -#if defined(DUK_USE_ALIGN_4) +#if (DUK_USE_ALIGN_BY == 4) #define DUK_HOBJECT_E_FLAG_PADDING(e_sz) ((4 - (e_sz)) & 0x03) -#elif defined(DUK_USE_ALIGN_8) +#elif (DUK_USE_ALIGN_BY == 8) #define DUK_HOBJECT_E_FLAG_PADDING(e_sz) ((8 - (e_sz)) & 0x07) -#else +#elif (DUK_USE_ALIGN_BY == 1) #define DUK_HOBJECT_E_FLAG_PADDING(e_sz) 0 +#else +#error invalid DUK_USE_ALIGN_BY #endif #define DUK_HOBJECT_E_GET_KEY_BASE(heap,h) \ - ((duk_hstring **) ( \ + ((duk_hstring **) (void *) ( \ DUK_HOBJECT_GET_PROPS((heap), (h)) + \ DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_propvalue) \ )) #define DUK_HOBJECT_E_GET_VALUE_BASE(heap,h) \ - ((duk_propvalue *) ( \ + ((duk_propvalue *) (void *) ( \ DUK_HOBJECT_GET_PROPS((heap), (h)) \ )) #define DUK_HOBJECT_E_GET_FLAGS_BASE(heap,h) \ - ((duk_uint8_t *) ( \ + ((duk_uint8_t *) (void *) ( \ DUK_HOBJECT_GET_PROPS((heap), (h)) + DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue)) \ )) #define DUK_HOBJECT_A_GET_BASE(heap,h) \ - ((duk_tval *) ( \ + ((duk_tval *) (void *) ( \ DUK_HOBJECT_GET_PROPS((heap), (h)) + \ DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \ DUK_HOBJECT_E_FLAG_PADDING(DUK_HOBJECT_GET_ESIZE((h))) \ )) #define DUK_HOBJECT_H_GET_BASE(heap,h) \ - ((duk_uint32_t *) ( \ + ((duk_uint32_t *) (void *) ( \ DUK_HOBJECT_GET_PROPS((heap), (h)) + \ DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \ DUK_HOBJECT_E_FLAG_PADDING(DUK_HOBJECT_GET_ESIZE((h))) + \ @@ -6382,40 +8140,40 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr (n_hash) * sizeof(duk_uint32_t) \ ) #define DUK_HOBJECT_P_SET_REALLOC_PTRS(p_base,set_e_k,set_e_pv,set_e_f,set_a,set_h,n_ent,n_arr,n_hash) do { \ - (set_e_pv) = (duk_propvalue *) (p_base); \ - (set_e_k) = (duk_hstring **) ((set_e_pv) + (n_ent)); \ - (set_e_f) = (duk_uint8_t *) ((set_e_k) + (n_ent)); \ - (set_a) = (duk_tval *) (((duk_uint8_t *) (set_e_f)) + \ - sizeof(duk_uint8_t) * (n_ent) + \ - DUK_HOBJECT_E_FLAG_PADDING((n_ent))); \ - (set_h) = (duk_uint32_t *) ((set_a) + (n_arr)); \ + (set_e_pv) = (duk_propvalue *) (void *) (p_base); \ + (set_e_k) = (duk_hstring **) (void *) ((set_e_pv) + (n_ent)); \ + (set_e_f) = (duk_uint8_t *) (void *) ((set_e_k) + (n_ent)); \ + (set_a) = (duk_tval *) (void *) (((duk_uint8_t *) (set_e_f)) + \ + sizeof(duk_uint8_t) * (n_ent) + \ + DUK_HOBJECT_E_FLAG_PADDING((n_ent))); \ + (set_h) = (duk_uint32_t *) (void *) ((set_a) + (n_arr)); \ } while (0) #elif defined(DUK_USE_HOBJECT_LAYOUT_3) /* LAYOUT 3 */ #define DUK_HOBJECT_E_GET_KEY_BASE(heap,h) \ - ((duk_hstring **) ( \ + ((duk_hstring **) (void *) ( \ DUK_HOBJECT_GET_PROPS((heap), (h)) + \ DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_propvalue) + \ DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) \ )) #define DUK_HOBJECT_E_GET_VALUE_BASE(heap,h) \ - ((duk_propvalue *) ( \ + ((duk_propvalue *) (void *) ( \ DUK_HOBJECT_GET_PROPS((heap), (h)) \ )) #define DUK_HOBJECT_E_GET_FLAGS_BASE(heap,h) \ - ((duk_uint8_t *) ( \ + ((duk_uint8_t *) (void *) ( \ DUK_HOBJECT_GET_PROPS((heap), (h)) + \ DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_propvalue) + sizeof(duk_hstring *)) + \ DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) + \ DUK_HOBJECT_GET_HSIZE((h)) * sizeof(duk_uint32_t) \ )) #define DUK_HOBJECT_A_GET_BASE(heap,h) \ - ((duk_tval *) ( \ + ((duk_tval *) (void *) ( \ DUK_HOBJECT_GET_PROPS((heap), (h)) + \ DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_propvalue) \ )) #define DUK_HOBJECT_H_GET_BASE(heap,h) \ - ((duk_uint32_t *) ( \ + ((duk_uint32_t *) (void *) ( \ DUK_HOBJECT_GET_PROPS((heap), (h)) + \ DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_propvalue) + sizeof(duk_hstring *)) + \ DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) \ @@ -6427,11 +8185,11 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr (n_hash) * sizeof(duk_uint32_t) \ ) #define DUK_HOBJECT_P_SET_REALLOC_PTRS(p_base,set_e_k,set_e_pv,set_e_f,set_a,set_h,n_ent,n_arr,n_hash) do { \ - (set_e_pv) = (duk_propvalue *) (p_base); \ - (set_a) = (duk_tval *) ((set_e_pv) + (n_ent)); \ - (set_e_k) = (duk_hstring **) ((set_a) + (n_arr)); \ - (set_h) = (duk_uint32_t *) ((set_e_k) + (n_ent)); \ - (set_e_f) = (duk_uint8_t *) ((set_h) + (n_hash)); \ + (set_e_pv) = (duk_propvalue *) (void *) (p_base); \ + (set_a) = (duk_tval *) (void *) ((set_e_pv) + (n_ent)); \ + (set_e_k) = (duk_hstring **) (void *) ((set_a) + (n_arr)); \ + (set_h) = (duk_uint32_t *) (void *) ((set_e_k) + (n_ent)); \ + (set_e_f) = (duk_uint8_t *) (void *) ((set_h) + (n_hash)); \ } while (0) #else #error invalid hobject layout defines @@ -6473,7 +8231,7 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.set = (v); \ } while (0) #define DUK_HOBJECT_E_SET_FLAGS(heap,h,i,f) do { \ - DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) = (f); \ + DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) = (duk_uint8_t) (f); \ } while (0) #define DUK_HOBJECT_A_SET_VALUE(heap,h,i,v) do { \ DUK_HOBJECT_A_GET_VALUE((heap), (h), (i)) = (v); \ @@ -6595,7 +8353,7 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr #endif /* note: this updates refcounts */ -#define DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr,h,p) duk_hobject_set_prototype((thr), (h), (p)) +#define DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr,h,p) duk_hobject_set_prototype_updref((thr), (h), (p)) /* * Resizing and hash behavior @@ -6627,12 +8385,14 @@ DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr #define DUK_HOBJECT_A_ABANDON_LIMIT 2 /* 25%, i.e. less than 25% used -> abandon */ /* internal align target for props allocation, must be 2*n for some n */ -#if defined(DUK_USE_ALIGN_4) +#if (DUK_USE_ALIGN_BY == 4) #define DUK_HOBJECT_ALIGN_TARGET 4 -#elif defined(DUK_USE_ALIGN_8) +#elif (DUK_USE_ALIGN_BY == 8) #define DUK_HOBJECT_ALIGN_TARGET 8 -#else +#elif (DUK_USE_ALIGN_BY == 1) #define DUK_HOBJECT_ALIGN_TARGET 1 +#else +#error invalid DUK_USE_ALIGN_BY #endif /* controls for minimum entry part growth */ @@ -6806,6 +8566,7 @@ DUK_INTERNAL_DECL duk_hobject *duk_hobject_alloc_checked(duk_hthread *thr, duk_u #endif DUK_INTERNAL_DECL duk_hcompiledfunction *duk_hcompiledfunction_alloc(duk_heap *heap, duk_uint_t hobject_flags); DUK_INTERNAL_DECL duk_hnativefunction *duk_hnativefunction_alloc(duk_heap *heap, duk_uint_t hobject_flags); +DUK_INTERNAL duk_hbufferobject *duk_hbufferobject_alloc(duk_heap *heap, duk_uint_t hobject_flags); DUK_INTERNAL_DECL duk_hthread *duk_hthread_alloc(duk_heap *heap, duk_uint_t hobject_flags); /* low-level property functions */ @@ -6814,6 +8575,12 @@ DUK_INTERNAL_DECL duk_tval *duk_hobject_find_existing_entry_tval_ptr(duk_heap *h DUK_INTERNAL_DECL duk_tval *duk_hobject_find_existing_entry_tval_ptr_and_attrs(duk_heap *heap, duk_hobject *obj, duk_hstring *key, duk_int_t *out_attrs); DUK_INTERNAL_DECL duk_tval *duk_hobject_find_existing_array_entry_tval_ptr(duk_heap *heap, duk_hobject *obj, duk_uarridx_t i); +/* XXX: when optimizing for guaranteed property slots, use a guaranteed + * slot for internal value; this call can then access it directly. + */ +#define duk_hobject_get_internal_value_tval_ptr(heap,obj) \ + duk_hobject_find_existing_entry_tval_ptr((heap), (obj), DUK_HEAP_STRING_INT_VALUE((heap))) + /* core property functions */ DUK_INTERNAL_DECL duk_bool_t duk_hobject_getprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key); DUK_INTERNAL_DECL duk_bool_t duk_hobject_putprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key, duk_tval *tv_val, duk_bool_t throw_flag); @@ -6858,7 +8625,6 @@ DUK_INTERNAL_DECL duk_bool_t duk_hobject_object_ownprop_helper(duk_context *ctx, /* internal properties */ DUK_INTERNAL_DECL duk_bool_t duk_hobject_get_internal_value(duk_heap *heap, duk_hobject *obj, duk_tval *tv); DUK_INTERNAL_DECL duk_hstring *duk_hobject_get_internal_value_string(duk_heap *heap, duk_hobject *obj); -DUK_INTERNAL_DECL duk_hbuffer *duk_hobject_get_internal_value_buffer(duk_heap *heap, duk_hobject *obj); /* hobject management functions */ DUK_INTERNAL_DECL void duk_hobject_compact_props(duk_hthread *thr, duk_hobject *obj); @@ -6866,6 +8632,7 @@ DUK_INTERNAL_DECL void duk_hobject_compact_props(duk_hthread *thr, duk_hobject * /* ES6 proxy */ #if defined(DUK_USE_ES6_PROXY) DUK_INTERNAL_DECL duk_bool_t duk_hobject_proxy_check(duk_hthread *thr, duk_hobject *obj, duk_hobject **out_target, duk_hobject **out_handler); +DUK_INTERNAL_DECL duk_hobject *duk_hobject_resolve_proxy_target(duk_hthread *thr, duk_hobject *obj); #endif /* enumeration */ @@ -6874,7 +8641,7 @@ DUK_INTERNAL_DECL duk_ret_t duk_hobject_get_enumerated_keys(duk_context *ctx, du DUK_INTERNAL_DECL duk_bool_t duk_hobject_enumerator_next(duk_context *ctx, duk_bool_t get_value); /* macros */ -DUK_INTERNAL_DECL void duk_hobject_set_prototype(duk_hthread *thr, duk_hobject *h, duk_hobject *p); +DUK_INTERNAL_DECL void duk_hobject_set_prototype_updref(duk_hthread *thr, duk_hobject *h, duk_hobject *p); /* finalization */ DUK_INTERNAL_DECL void duk_hobject_run_finalizer(duk_hthread *thr, duk_hobject *obj); @@ -6908,23 +8675,23 @@ DUK_INTERNAL_DECL duk_bool_t duk_hobject_prototype_chain_contains(duk_hthread *t #if defined(DUK_USE_HEAPPTR16) #define DUK_HCOMPILEDFUNCTION_GET_DATA(heap,h) \ - ((duk_hbuffer_fixed *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->data16)) + ((duk_hbuffer_fixed *) (void *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->data16)) #define DUK_HCOMPILEDFUNCTION_SET_DATA(heap,h,v) do { \ (h)->data16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \ } while (0) #define DUK_HCOMPILEDFUNCTION_GET_FUNCS(heap,h) \ - ((duk_hobject **) (DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->funcs16))) + ((duk_hobject **) (void *) (DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->funcs16))) #define DUK_HCOMPILEDFUNCTION_SET_FUNCS(heap,h,v) do { \ (h)->funcs16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \ } while (0) #define DUK_HCOMPILEDFUNCTION_GET_BYTECODE(heap,h) \ - ((duk_instr_t *) (DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->bytecode16))) + ((duk_instr_t *) (void *) (DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->bytecode16))) #define DUK_HCOMPILEDFUNCTION_SET_BYTECODE(heap,h,v) do { \ (h)->bytecode16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \ } while (0) #else #define DUK_HCOMPILEDFUNCTION_GET_DATA(heap,h) \ - ((duk_hbuffer_fixed *) (h)->data) + ((duk_hbuffer_fixed *) (void *) (h)->data) #define DUK_HCOMPILEDFUNCTION_SET_DATA(heap,h,v) do { \ (h)->data = (duk_hbuffer *) (v); \ } while (0) @@ -6949,7 +8716,7 @@ DUK_INTERNAL_DECL duk_bool_t duk_hobject_prototype_chain_contains(duk_hthread *t DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), DUK_HCOMPILEDFUNCTION_GET_DATA((heap), (h))) #define DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(heap,h) \ - ((duk_tval *) DUK_HCOMPILEDFUNCTION_GET_BUFFER_BASE((heap), (h))) + ((duk_tval *) (void *) DUK_HCOMPILEDFUNCTION_GET_BUFFER_BASE((heap), (h))) #define DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(heap,h) \ DUK_HCOMPILEDFUNCTION_GET_FUNCS((heap), (h)) @@ -6958,14 +8725,14 @@ DUK_INTERNAL_DECL duk_bool_t duk_hobject_prototype_chain_contains(duk_hthread *t DUK_HCOMPILEDFUNCTION_GET_BYTECODE((heap), (h)) #define DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(heap,h) \ - ((duk_tval *) DUK_HCOMPILEDFUNCTION_GET_FUNCS((heap), (h))) + ((duk_tval *) (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS((heap), (h))) #define DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(heap,h) \ - ((duk_hobject **) DUK_HCOMPILEDFUNCTION_GET_BYTECODE((heap), (h))) + ((duk_hobject **) (void *) DUK_HCOMPILEDFUNCTION_GET_BYTECODE((heap), (h))) /* XXX: double evaluation of DUK_HCOMPILEDFUNCTION_GET_DATA() */ #define DUK_HCOMPILEDFUNCTION_GET_CODE_END(heap,h) \ - ((duk_instr_t *) (DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), DUK_HCOMPILEDFUNCTION_GET_DATA((heap), (h))) + \ + ((duk_instr_t *) (void *) (DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), DUK_HCOMPILEDFUNCTION_GET_DATA((heap), (h))) + \ DUK_HBUFFER_GET_SIZE((duk_hbuffer *) DUK_HCOMPILEDFUNCTION_GET_DATA((heap), h)))) #define DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE(heap,h) \ @@ -7162,6 +8929,140 @@ struct duk_hnativefunction { }; #endif /* DUK_HNATIVEFUNCTION_H_INCLUDED */ +#line 1 "duk_hbufferobject.h" +/* + * Heap Buffer object representation. Used for all Buffer variants. + */ + +#ifndef DUK_HBUFFEROBJECT_H_INCLUDED +#define DUK_HBUFFEROBJECT_H_INCLUDED + +/* All element accessors are host endian now (driven by TypedArray spec). */ +#define DUK_HBUFFEROBJECT_ELEM_UINT8 0 +#define DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED 1 +#define DUK_HBUFFEROBJECT_ELEM_INT8 2 +#define DUK_HBUFFEROBJECT_ELEM_UINT16 3 +#define DUK_HBUFFEROBJECT_ELEM_INT16 4 +#define DUK_HBUFFEROBJECT_ELEM_UINT32 5 +#define DUK_HBUFFEROBJECT_ELEM_INT32 6 +#define DUK_HBUFFEROBJECT_ELEM_FLOAT32 7 +#define DUK_HBUFFEROBJECT_ELEM_FLOAT64 8 +#define DUK_HBUFFEROBJECT_ELEM_MAX 8 + +#define DUK_ASSERT_HBUFFEROBJECT_VALID(h) do { \ + DUK_ASSERT((h) != NULL); \ + DUK_ASSERT((h)->shift <= 3); \ + DUK_ASSERT((h)->elem_type <= DUK_HBUFFEROBJECT_ELEM_MAX); \ + DUK_ASSERT(((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8) || \ + ((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED) || \ + ((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT8) || \ + ((h)->shift == 1 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT16) || \ + ((h)->shift == 1 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT16) || \ + ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT32) || \ + ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT32) || \ + ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_FLOAT32) || \ + ((h)->shift == 3 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_FLOAT64)); \ + DUK_ASSERT((h)->is_view == 0 || (h)->is_view == 1); \ + DUK_ASSERT(DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) (h))); \ + if ((h)->buf == NULL) { \ + DUK_ASSERT((h)->offset == 0); \ + DUK_ASSERT((h)->length == 0); \ + } else { \ + /* No assertions for offset or length; in particular, \ + * it's OK for length to be longer than underlying \ + * buffer. Just ensure they don't wrap when added. \ + */ \ + DUK_ASSERT((h)->offset + (h)->length >= (h)->offset); \ + } \ + } while (0) + +/* Get the current data pointer (caller must ensure buf != NULL) as a + * duk_uint8_t ptr. + */ +#define DUK_HBUFFEROBJECT_GET_SLICE_BASE(heap,h) \ + (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \ + (((duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR((heap), (h)->buf)) + (h)->offset)) + +/* True if slice is full, i.e. offset is zero and length covers the entire + * buffer. This status may change independently of the duk_hbufferobject if + * the underlying buffer is dynamic and changes without the hbufferobject + * being changed. + */ +#define DUK_HBUFFEROBJECT_FULL_SLICE(h) \ + (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \ + ((h)->offset == 0 && (h)->length == DUK_HBUFFER_GET_SIZE((h)->buf))) + +/* Validate that the whole slice [0,length[ is contained in the underlying + * buffer. Caller must ensure 'buf' != NULL. + */ +#define DUK_HBUFFEROBJECT_VALID_SLICE(h) \ + (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \ + ((h)->offset + (h)->length <= DUK_HBUFFER_GET_SIZE((h)->buf))) + +/* Validate byte read/write for virtual 'offset', i.e. check that the + * offset, taking into account h->offset, is within the underlying + * buffer size. This is a safety check which is needed to ensure + * that even a misconfigured duk_hbufferobject never causes memory + * unsafe behavior (e.g. if an underlying dynamic buffer changes + * after being setup). Caller must ensure 'buf' != NULL. + */ +#define DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_INCL(h,off) \ + (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \ + ((h)->offset + (off) < DUK_HBUFFER_GET_SIZE((h)->buf))) + +#define DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h,off) \ + (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \ + ((h)->offset + (off) <= DUK_HBUFFER_GET_SIZE((h)->buf))) + +/* Clamp an input byte length (already assumed to be within the nominal + * duk_hbufferobject 'length') to the current dynamic buffer limits to + * yield a byte length limit that's safe for memory accesses. This value + * can be invalidated by any side effect because it may trigger a user + * callback that resizes the underlying buffer. + */ +#define DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH(h,len) \ + (DUK_ASSERT_EXPR((h) != NULL), \ + duk_hbufferobject_clamp_bytelength((h), (len))) + +struct duk_hbufferobject { + /* Shared object part. */ + duk_hobject obj; + + /* Underlying buffer (refcounted), may be NULL. */ + duk_hbuffer *buf; + + /* Slice and accessor information. + * + * Because the underlying buffer may be dynamic, these may be + * invalidated by the buffer being modified so that both offset + * and length should be validated before every access. Behavior + * when the underlying buffer has changed doesn't need to be clean: + * virtual 'length' doesn't need to be affected, reads can return + * zero/NaN, and writes can be ignored. + * + * Note that a data pointer cannot be precomputed because 'buf' may + * be dynamic and its pointer unstable. + */ + + duk_uint_t offset; /* byte offset to buf */ + duk_uint_t length; /* byte index limit for element access, exclusive */ + duk_uint8_t shift; /* element size shift: + * 0 = u8/i8 + * 1 = u16/i16 + * 2 = u32/i32/float + * 3 = double + */ + duk_uint8_t elem_type; /* element type */ + duk_uint8_t is_view; +}; + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL_DECL duk_uint_t duk_hbufferobject_clamp_bytelength(duk_hbufferobject *h_bufobj, duk_uint_t len); +#endif +DUK_INTERNAL_DECL void duk_hbufferobject_push_validated_read(duk_context *ctx, duk_hbufferobject *h_bufobj, duk_uint8_t *p, duk_small_uint_t elem_size); +DUK_INTERNAL_DECL void duk_hbufferobject_validated_write(duk_context *ctx, duk_hbufferobject *h_bufobj, duk_uint8_t *p, duk_small_uint_t elem_size); + +#endif /* DUK_HBUFFEROBJECT_H_INCLUDED */ #line 1 "duk_hthread.h" /* * Heap thread object representation. @@ -7214,7 +9115,7 @@ struct duk_hnativefunction { */ #define DUK_ACT_FLAG_STRICT (1 << 0) /* function executes in strict mode */ -#define DUK_ACT_FLAG_TAILCALLED (1 << 1) /* activation has tailcalled one or more times */ +#define DUK_ACT_FLAG_TAILCALLED (1 << 1) /* activation has tail called one or more times */ #define DUK_ACT_FLAG_CONSTRUCT (1 << 2) /* function executes as a constructor (called via "new") */ #define DUK_ACT_FLAG_PREVENT_YIELD (1 << 3) /* activation prevents yield (native call or "new") */ #define DUK_ACT_FLAG_DIRECT_EVAL (1 << 4) /* activation is a direct eval call */ @@ -7303,6 +9204,44 @@ struct duk_hnativefunction { #define DUK_HTHREAD_STATE_YIELDED 4 /* thread has yielded */ #define DUK_HTHREAD_STATE_TERMINATED 5 /* thread has terminated */ +/* Executor interrupt default interval when nothing else requires a + * smaller value. The default interval must be small enough to allow + * for reasonable execution timeout checking but large enough to keep + * impact on execution performance low. + */ +#if defined(DUK_USE_INTERRUPT_COUNTER) +#define DUK_HTHREAD_INTCTR_DEFAULT (256L * 1024L) +#endif + +/* + * Assert context is valid: non-NULL pointer, fields look sane. + * + * This is used by public API call entrypoints to catch invalid 'ctx' pointers + * as early as possible; invalid 'ctx' pointers cause very odd and difficult to + * diagnose behavior so it's worth checking even when the check is not 100%. + */ + +#if defined(DUK_USE_PREFER_SIZE) +#define DUK_ASSERT_CTX_VSSIZE(ctx) /*nop*/ +#else +#define DUK_ASSERT_CTX_VSSIZE(ctx) \ + DUK_ASSERT((duk_size_t) (((duk_hthread *) (ctx))->valstack_end - ((duk_hthread *) (ctx))->valstack) == \ + ((duk_hthread *) (ctx))->valstack_size) +#endif +#define DUK_ASSERT_CTX_VALID(ctx) do { \ + DUK_ASSERT((ctx) != NULL); \ + DUK_ASSERT(DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) (ctx)) == DUK_HTYPE_OBJECT); \ + DUK_ASSERT(DUK_HOBJECT_IS_THREAD((duk_hobject *) (ctx))); \ + DUK_ASSERT(((duk_hthread *) (ctx))->unused1 == 0); \ + DUK_ASSERT(((duk_hthread *) (ctx))->unused2 == 0); \ + DUK_ASSERT(((duk_hthread *) (ctx))->valstack != NULL); \ + DUK_ASSERT(((duk_hthread *) (ctx))->valstack_end >= ((duk_hthread *) (ctx))->valstack); \ + DUK_ASSERT(((duk_hthread *) (ctx))->valstack_top >= ((duk_hthread *) (ctx))->valstack); \ + DUK_ASSERT(((duk_hthread *) (ctx))->valstack_top >= ((duk_hthread *) (ctx))->valstack_bottom); \ + DUK_ASSERT(((duk_hthread *) (ctx))->valstack_end >= ((duk_hthread *) (ctx))->valstack_top); \ + DUK_ASSERT_CTX_VSSIZE((ctx)); \ + } while (0) + /* * Struct defines */ @@ -7324,11 +9263,11 @@ struct duk_activation { duk_hobject *prev_caller; #endif - duk_small_uint_t flags; - duk_uint32_t pc; /* next instruction to execute */ + duk_instr_t *curr_pc; /* next instruction to execute (points to 'func' bytecode, stable pointer), NULL for native calls */ #if defined(DUK_USE_DEBUGGER_SUPPORT) duk_uint32_t prev_line; /* needed for stepping */ #endif + duk_small_uint_t flags; /* idx_bottom and idx_retval are only used for book-keeping of * Ecmascript-initiated calls, to allow returning to an Ecmascript @@ -7367,67 +9306,83 @@ struct duk_activation { struct duk_catcher { duk_hstring *h_varname; /* borrowed reference to catch variable name (or NULL if none) */ /* (reference is valid as long activation exists) */ + duk_instr_t *pc_base; /* resume execution from pc_base or pc_base+1 (points to 'func' bytecode, stable pointer) */ duk_size_t callstack_index; /* callstack index of related activation */ duk_size_t idx_base; /* idx_base and idx_base+1 get completion value and type */ - duk_uint32_t pc_base; /* resume execution from pc_base or pc_base+1 */ duk_uint32_t flags; /* type and control flags, label number */ }; struct duk_hthread { - /* shared object part */ + /* Shared object part */ duk_hobject obj; - /* backpointers */ + /* Pointer to bytecode executor's 'curr_pc' variable. Used to copy + * the current PC back into the topmost activation when activation + * state is about to change (or "syncing" is otherwise needed). This + * is rather awkward but important for performance, see execution.rst. + */ + duk_instr_t **ptr_curr_pc; + + /* Backpointers. */ duk_heap *heap; - /* current strictness flag: affects API calls */ + /* Current strictness flag: affects API calls. */ duk_uint8_t strict; + + /* Thread state. */ duk_uint8_t state; duk_uint8_t unused1; duk_uint8_t unused2; - /* sanity limits */ + /* Sanity limits for stack sizes. */ duk_size_t valstack_max; duk_size_t callstack_max; duk_size_t catchstack_max; - /* XXX: valstack, callstack, and catchstack are currently assumed + /* XXX: Valstack, callstack, and catchstack are currently assumed * to have non-NULL pointers. Relaxing this would not lead to big * benefits (except perhaps for terminated threads). */ - /* value stack: these are expressed as pointers for faster stack manipulation */ + /* Value stack: these are expressed as pointers for faster stack manipulation. + * [valstack,valstack_top[ is GC-reachable, [valstack_top,valstack_end[ is + * not GC-reachable but kept initialized as 'undefined'. + */ duk_tval *valstack; /* start of valstack allocation */ duk_tval *valstack_end; /* end of valstack allocation (exclusive) */ duk_tval *valstack_bottom; /* bottom of current frame */ duk_tval *valstack_top; /* top of current frame (exclusive) */ +#if !defined(DUK_USE_PREFER_SIZE) + duk_size_t valstack_size; /* cached: valstack_end - valstack (in entries, not bytes) */ +#endif - /* call stack */ + /* Call stack. [0,callstack_top[ is GC reachable. */ duk_activation *callstack; duk_size_t callstack_size; /* allocation size */ duk_size_t callstack_top; /* next to use, highest used is top - 1 */ duk_size_t callstack_preventcount; /* number of activation records in callstack preventing a yield */ - /* catch stack */ + /* Catch stack. [0,catchstack_top[ is GC reachable. */ duk_catcher *catchstack; duk_size_t catchstack_size; /* allocation size */ duk_size_t catchstack_top; /* next to use, highest used is top - 1 */ - /* yield/resume book-keeping */ + /* Yield/resume book-keeping. */ duk_hthread *resumer; /* who resumed us (if any) */ - /* current compiler state (if any), used for augmenting SyntaxErrors */ + /* Current compiler state (if any), used for augmenting SyntaxErrors. */ duk_compiler_ctx *compile_ctx; -#ifdef DUK_USE_INTERRUPT_COUNTER +#if defined(DUK_USE_INTERRUPT_COUNTER) /* Interrupt counter for triggering a slow path check for execution - * timeout, debugger interaction such as breakpoints, etc. This is - * actually a value copied from the heap structure into the current - * thread to be more convenient for the bytecode executor inner loop. - * The final value is copied back to the heap structure on a thread - * switch by DUK_HEAP_SWITCH_THREAD(). + * timeout, debugger interaction such as breakpoints, etc. The value + * is valid for the current running thread, and both the init and + * counter values are copied whenever a thread switch occurs. It's + * important for the counter to be conveniently accessible for the + * bytecode executor inner loop for performance reasons. */ - duk_int_t interrupt_counter; + duk_int_t interrupt_counter; /* countdown state */ + duk_int_t interrupt_init; /* start value for current countdown */ #endif /* Builtin-objects; may or may not be shared with other threads, @@ -7439,7 +9394,7 @@ struct duk_hthread { */ duk_hobject *builtins[DUK_NUM_BUILTINS]; - /* convenience copies from heap/vm for faster access */ + /* Convenience copies from heap/vm for faster access. */ #if defined(DUK_USE_HEAPPTR16) duk_uint16_t *strs16; #else @@ -7468,6 +9423,13 @@ DUK_INTERNAL_DECL void *duk_hthread_get_valstack_ptr(duk_heap *heap, void *ud); DUK_INTERNAL_DECL void *duk_hthread_get_callstack_ptr(duk_heap *heap, void *ud); /* indirect allocs */ DUK_INTERNAL_DECL void *duk_hthread_get_catchstack_ptr(duk_heap *heap, void *ud); /* indirect allocs */ +#if defined(DUK_USE_DEBUGGER_SUPPORT) +DUK_INTERNAL_DECL duk_uint_fast32_t duk_hthread_get_act_curr_pc(duk_hthread *thr, duk_activation *act); +#endif +DUK_INTERNAL_DECL duk_uint_fast32_t duk_hthread_get_act_prev_pc(duk_hthread *thr, duk_activation *act); +DUK_INTERNAL_DECL void duk_hthread_sync_currpc(duk_hthread *thr); +DUK_INTERNAL_DECL void duk_hthread_sync_and_null_currpc(duk_hthread *thr); + #endif /* DUK_HTHREAD_H_INCLUDED */ #line 1 "duk_hbuffer.h" /* @@ -7486,17 +9448,23 @@ DUK_INTERNAL_DECL void *duk_hthread_get_catchstack_ptr(duk_heap *heap, void *ud) /* * Flags + * + * Fixed buffer: 0 + * Dynamic buffer: DUK_HBUFFER_FLAG_DYNAMIC + * External buffer: DUK_HBUFFER_FLAG_DYNAMIC | DUK_HBUFFER_FLAG_EXTERNAL */ -#define DUK_HBUFFER_FLAG_DYNAMIC DUK_HEAPHDR_USER_FLAG(0) /* buffer is resizable */ +#define DUK_HBUFFER_FLAG_DYNAMIC DUK_HEAPHDR_USER_FLAG(0) /* buffer is behind a pointer, dynamic or external */ +#define DUK_HBUFFER_FLAG_EXTERNAL DUK_HEAPHDR_USER_FLAG(1) /* buffer pointer is to an externally allocated buffer */ #define DUK_HBUFFER_HAS_DYNAMIC(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC) +#define DUK_HBUFFER_HAS_EXTERNAL(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL) #define DUK_HBUFFER_SET_DYNAMIC(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC) +#define DUK_HBUFFER_SET_EXTERNAL(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL) #define DUK_HBUFFER_CLEAR_DYNAMIC(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC) - -#define DUK_HBUFFER_FIXED_GET_DATA_PTR(heap,x) ((duk_uint8_t *) (((duk_hbuffer_fixed *) (x)) + 1)) +#define DUK_HBUFFER_CLEAR_EXTERNAL(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL) /* * Misc defines @@ -7504,14 +9472,17 @@ DUK_INTERNAL_DECL void *duk_hthread_get_catchstack_ptr(duk_heap *heap, void *ud) /* Impose a maximum buffer length for now. Restricted artificially to * ensure resize computations or adding a heap header length won't - * overflow size_t. The limit should be synchronized with - * DUK_HSTRING_MAX_BYTELEN. + * overflow size_t and that a signed duk_int_t can hold a buffer + * length. The limit should be synchronized with DUK_HSTRING_MAX_BYTELEN. */ #if defined(DUK_USE_BUFLEN16) #define DUK_HBUFFER_MAX_BYTELEN (0x0000ffffUL) #else -#define DUK_HBUFFER_MAX_BYTELEN (0x7fffffffUL) +/* Intentionally not 0x7fffffffUL; at least JSON code expects that + * 2*len + 2 fits in 32 bits. + */ +#define DUK_HBUFFER_MAX_BYTELEN (0x7ffffffeUL) #endif /* @@ -7554,37 +9525,19 @@ DUK_INTERNAL_DECL void *duk_hthread_get_catchstack_ptr(duk_heap *heap, void *ud) #define DUK_HBUFFER_DYNAMIC_ADD_SIZE(x,dv) DUK_HBUFFER_ADD_SIZE((duk_hbuffer *) (x), (dv)) #define DUK_HBUFFER_DYNAMIC_SUB_SIZE(x,dv) DUK_HBUFFER_SUB_SIZE((duk_hbuffer *) (x), (dv)) -#if defined(DUK_USE_BUFLEN16) && defined(DUK_USE_HEAPPTR16) -/* alloc_size16 stored in duk_heaphdr h_extra16, available with pointer compression. */ -#define DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(x) ((duk_size_t) ((x)->hdr.h_extra16)) -#define DUK_HBUFFER_DYNAMIC_SET_ALLOC_SIZE(x,v) do { \ - (x)->hdr.h_extra16 = (duk_uint16_t) (v); \ - } while (0) -#elif defined(DUK_USE_BUFLEN16) -/* alloc_size16 stored in an explicit 16-bit fields. */ -#define DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(x) ((duk_size_t) ((x)->alloc_size16)) -#define DUK_HBUFFER_DYNAMIC_SET_ALLOC_SIZE(x,v) do { \ - (x)->alloc_size16 = (duk_uint16_t) (v); \ - } while (0) -#else -/* normal case */ -#define DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(x) ((x)->alloc_size) -#define DUK_HBUFFER_DYNAMIC_SET_ALLOC_SIZE(x,v) do { \ - (x)->alloc_size = (v); \ - } while (0) -#endif +#define DUK_HBUFFER_EXTERNAL_GET_SIZE(x) DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x)) +#define DUK_HBUFFER_EXTERNAL_SET_SIZE(x,v) DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x), (v)) -#define DUK_HBUFFER_DYNAMIC_GET_SPARE_SIZE(x) \ - (duk_size_t) (DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE((x)) - DUK_HBUFFER_DYNAMIC_GET_SIZE((x))) +#define DUK_HBUFFER_FIXED_GET_DATA_PTR(heap,x) ((duk_uint8_t *) (((duk_hbuffer_fixed *) (x)) + 1)) #if defined(DUK_USE_HEAPPTR16) #define DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap,x) \ - ((void *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (x)->curr_alloc16)) + ((void *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, ((duk_heaphdr *) (x))->h_extra16)) #define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap,x,v) do { \ - (x)->curr_alloc16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \ + ((duk_heaphdr *) (x))->h_extra16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \ } while (0) #define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(heap,x) do { \ - (x)->curr_alloc16 = 0; /* assume 0 <=> NULL */ \ + ((duk_heaphdr *) (x))->h_extra16 = 0; /* assume 0 <=> NULL */ \ } while (0) #else #define DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap,x) ((x)->curr_alloc) @@ -7596,23 +9549,58 @@ DUK_INTERNAL_DECL void *duk_hthread_get_catchstack_ptr(duk_heap *heap, void *ud) } while (0) #endif -/* Gets the actual buffer contents which matches the current allocation size - * (may be NULL for zero size dynamic buffer). +/* No pointer compression because pointer is potentially outside of + * Duktape heap. + */ +#if defined(DUK_USE_HEAPPTR16) +#define DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap,x) \ + ((void *) (x)->curr_alloc) +#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap,x,v) do { \ + (x)->curr_alloc = (void *) (v); \ + } while (0) +#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR_NULL(heap,x) do { \ + (x)->curr_alloc = (void *) NULL; \ + } while (0) +#else +#define DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap,x) \ + ((void *) (x)->curr_alloc) +#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap,x,v) do { \ + (x)->curr_alloc = (void *) (v); \ + } while (0) +#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR_NULL(heap,x) do { \ + (x)->curr_alloc = (void *) NULL; \ + } while (0) +#endif + +/* Get a pointer to the current buffer contents (matching current allocation + * size). May be NULL for zero size dynamic/external buffer. + */ +#if defined(DUK_USE_HEAPPTR16) +#define DUK_HBUFFER_GET_DATA_PTR(heap,x) ( \ + DUK_HBUFFER_HAS_DYNAMIC((x)) ? \ + ( \ + DUK_HBUFFER_HAS_EXTERNAL((x)) ? \ + DUK_HBUFFER_EXTERNAL_GET_DATA_PTR((heap), (duk_hbuffer_external *) (x)) : \ + DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((heap), (duk_hbuffer_dynamic *) (x)) \ + ) : \ + DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), (duk_hbuffer_fixed *) (x)) \ + ) +#else +/* Without heap pointer compression duk_hbuffer_dynamic and duk_hbuffer_external + * have the same layout so checking for fixed vs. dynamic (or external) is enough. */ #define DUK_HBUFFER_GET_DATA_PTR(heap,x) ( \ DUK_HBUFFER_HAS_DYNAMIC((x)) ? \ DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((heap), (duk_hbuffer_dynamic *) (x)) : \ DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), (duk_hbuffer_fixed *) (x)) \ ) - -/* Growth parameters for dynamic buffers. */ -#define DUK_HBUFFER_SPARE_ADD 16 -#define DUK_HBUFFER_SPARE_DIVISOR 16 /* 2^4 -> 1/16 = 6.25% spare */ +#endif /* * Structs */ +/* Shared prefix for all buffer types. */ struct duk_hbuffer { duk_heaphdr hdr; @@ -7640,6 +9628,11 @@ struct duk_hbuffer { * - a "void *" pointing to the current allocation * - a duk_size_t indicating the full allocated size (always >= 'size') * + * If DUK_HBUFFER_FLAG_EXTERNAL is set, the buffer has been allocated + * by user code, so that Duktape won't be able to resize it and won't + * free it. This allows buffers to point to e.g. an externally + * allocated structure such as a frame buffer. + * * Unlike strings, no terminator byte (NUL) is guaranteed after the * data. This would be convenient, but would pad aligned user buffers * unnecessarily upwards in size. For instance, if user code requested @@ -7648,7 +9641,10 @@ struct duk_hbuffer { */ }; -#if defined(DUK_USE_ALIGN_8) && defined(DUK_USE_PACK_MSVC_PRAGMA) +/* Fixed buffer; data follows struct, with proper alignment guaranteed by + * struct size. + */ +#if (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_MSVC_PRAGMA) #pragma pack(push, 8) #endif struct duk_hbuffer_fixed { @@ -7667,12 +9663,14 @@ struct duk_hbuffer_fixed { duk_size_t size; #endif } s; -#if defined(DUK_USE_ALIGN_4) +#if (DUK_USE_ALIGN_BY == 4) duk_uint32_t dummy_for_align4; -#elif defined(DUK_USE_ALIGN_8) +#elif (DUK_USE_ALIGN_BY == 8) duk_double_t dummy_for_align8; -#else +#elif (DUK_USE_ALIGN_BY == 1) /* no extra padding */ +#else +#error invalid DUK_USE_ALIGN_BY #endif } u; @@ -7689,16 +9687,20 @@ struct duk_hbuffer_fixed { * dynamic buffer). */ } -#if defined(DUK_USE_ALIGN_8) && defined(DUK_USE_PACK_GCC_ATTR) +#if (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_GCC_ATTR) __attribute__ ((aligned (8))) -#elif defined(DUK_USE_ALIGN_8) && defined(DUK_USE_PACK_CLANG_ATTR) +#elif (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_CLANG_ATTR) __attribute__ ((aligned (8))) #endif ; -#if defined(DUK_USE_ALIGN_8) && defined(DUK_USE_PACK_MSVC_PRAGMA) +#if (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_MSVC_PRAGMA) #pragma pack(pop) #endif +/* Dynamic buffer with 'curr_alloc' pointing to a dynamic area allocated using + * heap allocation primitives. Also used for external buffers when low memory + * options are not used. + */ struct duk_hbuffer_dynamic { duk_heaphdr hdr; @@ -7708,16 +9710,8 @@ struct duk_hbuffer_dynamic { duk_size_t size; #endif -#if defined(DUK_USE_BUFLEN16) && defined(DUK_USE_HEAPPTR16) - /* Stored in duk_heaphdr h_extra16. */ -#elif defined(DUK_USE_BUFLEN16) - duk_uint16_t alloc_size16; -#else - duk_size_t alloc_size; -#endif - #if defined(DUK_USE_HEAPPTR16) - duk_uint16_t curr_alloc16; + /* Stored in duk_heaphdr h_extra16. */ #else void *curr_alloc; /* may be NULL if alloc_size == 0 */ #endif @@ -7732,45 +9726,35 @@ struct duk_hbuffer_dynamic { */ }; +/* External buffer with 'curr_alloc' managed by user code and pointing to an + * arbitrary address. When heap pointer compression is not used, this struct + * has the same layout as duk_hbuffer_dynamic. + */ +struct duk_hbuffer_external { + duk_heaphdr hdr; + +#if defined(DUK_USE_BUFLEN16) + /* Stored in duk_heaphdr unused flags. */ +#else + duk_size_t size; +#endif + + /* Cannot be compressed as a heap pointer because may point to + * an arbitrary address. + */ + void *curr_alloc; /* may be NULL if alloc_size == 0 */ +}; + /* * Prototypes */ -DUK_INTERNAL_DECL duk_hbuffer *duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk_small_uint_t flags); +DUK_INTERNAL_DECL duk_hbuffer *duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk_small_uint_t flags, void **out_bufdata); DUK_INTERNAL_DECL void *duk_hbuffer_get_dynalloc_ptr(duk_heap *heap, void *ud); /* indirect allocs */ /* dynamic buffer ops */ -DUK_INTERNAL_DECL void duk_hbuffer_resize(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t new_size, duk_size_t new_alloc_size); +DUK_INTERNAL_DECL void duk_hbuffer_resize(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t new_size); DUK_INTERNAL_DECL void duk_hbuffer_reset(duk_hthread *thr, duk_hbuffer_dynamic *buf); -#if 0 /*unused*/ -DUK_INTERNAL_DECL void duk_hbuffer_compact(duk_hthread *thr, duk_hbuffer_dynamic *buf); -#endif -DUK_INTERNAL_DECL void duk_hbuffer_append_bytes(duk_hthread *thr, duk_hbuffer_dynamic *buf, const duk_uint8_t *data, duk_size_t length); -DUK_INTERNAL_DECL void duk_hbuffer_append_byte(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_uint8_t byte); -DUK_INTERNAL_DECL duk_size_t duk_hbuffer_append_cstring(duk_hthread *thr, duk_hbuffer_dynamic *buf, const char *str); -DUK_INTERNAL_DECL duk_size_t duk_hbuffer_append_hstring(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_hstring *str); -DUK_INTERNAL_DECL duk_size_t duk_hbuffer_append_xutf8(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_ucodepoint_t codepoint); -DUK_INTERNAL_DECL duk_size_t duk_hbuffer_append_cesu8(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_ucodepoint_t codepoint); -#if 0 -DUK_INTERNAL_DECL void duk_hbuffer_append_native_u32(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_uint32_t val); -#endif -DUK_INTERNAL_DECL void duk_hbuffer_insert_bytes(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, const duk_uint8_t *data, duk_size_t length); -#if 0 /*unused*/ -DUK_INTERNAL_DECL void duk_hbuffer_insert_byte(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_uint8_t byte); -#endif -#if 0 /*unused*/ -DUK_INTERNAL_DECL duk_size_t duk_hbuffer_insert_cstring(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, const char *str); -#endif -#if 0 /*unused*/ -DUK_INTERNAL_DECL duk_size_t duk_hbuffer_insert_hstring(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_hstring *str); -#endif -DUK_INTERNAL_DECL duk_size_t duk_hbuffer_insert_xutf8(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_ucodepoint_t codepoint); -#if 0 /*unused*/ -DUK_INTERNAL_DECL duk_size_t duk_hbuffer_insert_cesu8(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_ucodepoint_t codepoint); -#endif -DUK_INTERNAL_DECL void duk_hbuffer_remove_slice(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_size_t length); -DUK_INTERNAL_DECL void duk_hbuffer_insert_slice(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t dst_offset, duk_size_t src_offset, duk_size_t length); -DUK_INTERNAL_DECL void duk_hbuffer_append_slice(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t src_offset, duk_size_t length); #endif /* DUK_HBUFFER_H_INCLUDED */ #line 1 "duk_heap.h" @@ -7795,6 +9779,7 @@ DUK_INTERNAL_DECL void duk_hbuffer_append_slice(duk_hthread *thr, duk_hbuffer_dy #define DUK_HEAP_FLAG_REFZERO_FREE_RUNNING (1 << 2) /* refcount code is processing refzero list */ #define DUK_HEAP_FLAG_ERRHANDLER_RUNNING (1 << 3) /* an error handler (user callback to augment/replace error) is running */ #define DUK_HEAP_FLAG_INTERRUPT_RUNNING (1 << 4) /* executor interrupt running (used to avoid nested interrupts) */ +#define DUK_HEAP_FLAG_FINALIZER_NORESCUE (1 << 5) /* heap destruction ongoing, finalizer rescue no longer possible */ #define DUK__HEAP_HAS_FLAGS(heap,bits) ((heap)->flags & (bits)) #define DUK__HEAP_SET_FLAGS(heap,bits) do { \ @@ -7809,31 +9794,34 @@ DUK_INTERNAL_DECL void duk_hbuffer_append_slice(duk_hthread *thr, duk_hbuffer_dy #define DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING) #define DUK_HEAP_HAS_ERRHANDLER_RUNNING(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING) #define DUK_HEAP_HAS_INTERRUPT_RUNNING(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING) +#define DUK_HEAP_HAS_FINALIZER_NORESCUE(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE) #define DUK_HEAP_SET_MARKANDSWEEP_RUNNING(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING) #define DUK_HEAP_SET_MARKANDSWEEP_RECLIMIT_REACHED(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED) #define DUK_HEAP_SET_REFZERO_FREE_RUNNING(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING) #define DUK_HEAP_SET_ERRHANDLER_RUNNING(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING) #define DUK_HEAP_SET_INTERRUPT_RUNNING(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING) +#define DUK_HEAP_SET_FINALIZER_NORESCUE(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE) #define DUK_HEAP_CLEAR_MARKANDSWEEP_RUNNING(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING) #define DUK_HEAP_CLEAR_MARKANDSWEEP_RECLIMIT_REACHED(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED) #define DUK_HEAP_CLEAR_REFZERO_FREE_RUNNING(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING) #define DUK_HEAP_CLEAR_ERRHANDLER_RUNNING(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING) #define DUK_HEAP_CLEAR_INTERRUPT_RUNNING(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING) +#define DUK_HEAP_CLEAR_FINALIZER_NORESCUE(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE) /* * Longjmp types, also double as identifying continuation type for a rethrow (in 'finally') */ #define DUK_LJ_TYPE_UNKNOWN 0 /* unused */ -#define DUK_LJ_TYPE_RETURN 1 /* value1 -> return value */ -#define DUK_LJ_TYPE_THROW 2 /* value1 -> error object */ -#define DUK_LJ_TYPE_BREAK 3 /* value1 -> label number */ -#define DUK_LJ_TYPE_CONTINUE 4 /* value1 -> label number */ -#define DUK_LJ_TYPE_YIELD 5 /* value1 -> yield value, iserror -> error / normal */ -#define DUK_LJ_TYPE_RESUME 6 /* value1 -> resume value, value2 -> resumee thread, iserror -> error/normal */ -#define DUK_LJ_TYPE_NORMAL 7 /* pseudo-type to indicate a normal continuation (for 'finally' rethrowing) */ +#define DUK_LJ_TYPE_THROW 1 /* value1 -> error object */ +#define DUK_LJ_TYPE_YIELD 2 /* value1 -> yield value, iserror -> error / normal */ +#define DUK_LJ_TYPE_RESUME 3 /* value1 -> resume value, value2 -> resumee thread, iserror -> error/normal */ +#define DUK_LJ_TYPE_BREAK 4 /* value1 -> label number, pseudo-type to indicate a break continuation (for ENDFIN) */ +#define DUK_LJ_TYPE_CONTINUE 5 /* value1 -> label number, pseudo-type to indicate a continue continuation (for ENDFIN) */ +#define DUK_LJ_TYPE_RETURN 6 /* value1 -> return value, pseudo-type to indicate a return continuation (for ENDFIN) */ +#define DUK_LJ_TYPE_NORMAL 7 /* no value, pseudo-type to indicate a normal continuation (for ENDFIN) */ /* * Mark-and-sweep flags @@ -7845,8 +9833,9 @@ DUK_INTERNAL_DECL void duk_hbuffer_append_slice(duk_hthread *thr, duk_hbuffer_dy #define DUK_MS_FLAG_EMERGENCY (1 << 0) /* emergency mode: try extra hard */ #define DUK_MS_FLAG_NO_STRINGTABLE_RESIZE (1 << 1) /* don't resize stringtable (but may sweep it); needed during stringtable resize */ -#define DUK_MS_FLAG_NO_FINALIZERS (1 << 2) /* don't run finalizers (which may have arbitrary side effects) */ -#define DUK_MS_FLAG_NO_OBJECT_COMPACTION (1 << 3) /* don't compact objects; needed during object property allocation resize */ +#define DUK_MS_FLAG_NO_OBJECT_COMPACTION (1 << 2) /* don't compact objects; needed during object property allocation resize */ +#define DUK_MS_FLAG_NO_FINALIZERS (1 << 3) /* don't run finalizers; leave finalizable objects in finalize_list for next round */ +#define DUK_MS_FLAG_SKIP_FINALIZERS (1 << 4) /* don't run finalizers; queue finalizable objects back to heap_allocated */ /* * Thread switching @@ -7868,31 +9857,6 @@ DUK_INTERNAL_DECL void duk_hbuffer_append_slice(duk_hthread *thr, duk_hbuffer_dy * Other heap related defines */ -/* Maximum duk_handle_call / duk_handle_safe_call depth. Note that this - * does not limit bytecode executor internal call depth at all (e.g. - * for Ecmascript-to-Ecmascript calls, thread yields/resumes, etc). - * There is a separate callstack depth limit for threads. - */ - -#if defined(DUK_USE_DEEP_C_STACK) -#define DUK_HEAP_DEFAULT_CALL_RECURSION_LIMIT 1000 /* assuming 0.5 kB between calls, about 500kB of stack */ -#else -#define DUK_HEAP_DEFAULT_CALL_RECURSION_LIMIT 60 /* assuming 0.5 kB between calls, about 30kB of stack */ -#endif - -/* Mark-and-sweep C recursion depth for marking phase; if reached, - * mark object as a TEMPROOT and use multi-pass marking. - */ -#if defined(DUK_USE_MARK_AND_SWEEP) -#if defined(DUK_USE_GC_TORTURE) -#define DUK_HEAP_MARK_AND_SWEEP_RECURSION_LIMIT 3 -#elif defined(DUK_USE_DEEP_C_STACK) -#define DUK_HEAP_MARK_AND_SWEEP_RECURSION_LIMIT 256 -#else -#define DUK_HEAP_MARK_AND_SWEEP_RECURSION_LIMIT 32 -#endif -#endif - /* Mark-and-sweep interval is relative to combined count of objects and * strings kept in the heap during the latest mark-and-sweep pass. * Fixed point .8 multiplier and .0 adder. Trigger count (interval) is @@ -7924,14 +9888,6 @@ DUK_INTERNAL_DECL void duk_hbuffer_append_slice(duk_hthread *thr, duk_hbuffer_dy /* helper to insert a (non-string) heap object into heap allocated list */ #define DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap,hdr) duk_heap_insert_into_heap_allocated((heap),(hdr)) -/* Executor interrupt default interval when nothing else requires a - * smaller value. The default interval must be small enough to allow - * for reasonable execution timeout checking. - */ -#if defined(DUK_USE_INTERRUPT_COUNTER) -#define DUK_HEAP_INTCTR_DEFAULT (256L * 1024L) -#endif - /* * Stringtable */ @@ -8106,7 +10062,9 @@ struct duk_strcache { */ struct duk_ljstate { +#if !defined(DUK_USE_CPP_EXCEPTIONS) duk_jmpbuf *jmpbuf_ptr; /* current setjmp() catchpoint */ +#endif duk_small_uint_t type; /* longjmp type */ duk_bool_t iserror; /* isError flag for yield */ duk_tval value1; /* 1st related value (type specific) */ @@ -8207,9 +10165,6 @@ struct duk_heap { /* heap level "stash" object (e.g., various reachability roots) */ duk_hobject *heap_object; - /* heap level temporary log formatting buffer */ - duk_hbuffer_dynamic *log_buffer; - /* duk_handle_call / duk_handle_safe_call recursion depth limiting */ duk_int_t call_recursion_depth; duk_int_t call_recursion_limit; @@ -8220,10 +10175,13 @@ struct duk_heap { /* rnd_state for duk_util_tinyrandom.c */ duk_uint32_t rnd_state; - /* interrupt counter */ -#if defined(DUK_USE_INTERRUPT_COUNTER) - duk_int_t interrupt_init; /* start value for current countdown */ - duk_int_t interrupt_counter; /* countdown state (mirrored in current thread state) */ + /* For manual debugging: instruction count based on executor and + * interrupt counter book-keeping. Inspect debug logs to see how + * they match up. + */ +#if defined(DUK_USE_INTERRUPT_COUNTER) && defined(DUK_USE_DEBUG) + duk_int_t inst_count_exec; + duk_int_t inst_count_interrupt; #endif /* debugger */ @@ -8242,6 +10200,8 @@ struct duk_heap { duk_bool_t dbg_processing; /* currently processing messages or breakpoints: don't enter message processing recursively (e.g. no breakpoints when processing debugger eval) */ duk_bool_t dbg_paused; /* currently paused: talk with debug client until step/resume */ duk_bool_t dbg_state_dirty; /* resend state next time executor is about to run */ + duk_bool_t dbg_force_restart; /* force executor restart to recheck breakpoints; used to handle function returns (see GH-303) */ + duk_bool_t dbg_detaching; /* debugger detaching; used to avoid calling detach handler recursively */ duk_small_uint_t dbg_step_type; /* step type: none, step into, step over, step out */ duk_hthread *dbg_step_thread; /* borrowed; NULL if no step state (NULLed in unwind) */ duk_size_t dbg_step_csindex; /* callstack index */ @@ -8255,6 +10215,10 @@ struct duk_heap { duk_uint32_t dbg_exec_counter; /* cumulative opcode execution count (overflows are OK) */ duk_uint32_t dbg_last_counter; /* value of dbg_exec_counter when we last did a Date-based check */ duk_double_t dbg_last_time; /* time when status/peek was last done (Date-based rate limit) */ + + /* Used to support single-byte stream lookahead. */ + duk_bool_t dbg_have_next_byte; + duk_uint8_t dbg_next_byte; #endif /* string intern table (weak refs) */ @@ -8322,7 +10286,9 @@ DUK_INTERNAL_DECL duk_hstring *duk_heap_string_lookup_u32(duk_heap *heap, duk_ui #endif DUK_INTERNAL_DECL duk_hstring *duk_heap_string_intern_u32(duk_heap *heap, duk_uint32_t val); DUK_INTERNAL_DECL duk_hstring *duk_heap_string_intern_u32_checked(duk_hthread *thr, duk_uint32_t val); +#if defined(DUK_USE_REFERENCE_COUNTING) DUK_INTERNAL_DECL void duk_heap_string_remove(duk_heap *heap, duk_hstring *h); +#endif #if defined(DUK_USE_MARK_AND_SWEEP) && defined(DUK_USE_MS_STRINGTABLE_RESIZE) DUK_INTERNAL_DECL void duk_heap_force_strtab_resize(duk_heap *heap); #endif @@ -8401,6 +10367,8 @@ DUK_INTERNAL_DECL duk_uint32_t duk_heap_hashstring(duk_heap *heap, const duk_uin #define DUK_DBG_CMD_PRINT 0x02 #define DUK_DBG_CMD_ALERT 0x03 #define DUK_DBG_CMD_LOG 0x04 +#define DUK_DBG_CMD_THROW 0x05 +#define DUK_DBG_CMD_DETACHING 0x06 /* Initiated by debug client */ #define DUK_DBG_CMD_BASICINFO 0x10 @@ -8451,7 +10419,7 @@ DUK_INTERNAL_DECL void duk_debug_write_cstring(duk_hthread *thr, const char *dat DUK_INTERNAL_DECL void duk_debug_write_hstring(duk_hthread *thr, duk_hstring *h); DUK_INTERNAL_DECL void duk_debug_write_buffer(duk_hthread *thr, const char *data, duk_size_t length); DUK_INTERNAL_DECL void duk_debug_write_hbuffer(duk_hthread *thr, duk_hbuffer *h); -DUK_INTERNAL_DECL void duk_debug_write_pointer(duk_hthread *thr, const void *ptr); +DUK_INTERNAL_DECL void duk_debug_write_pointer(duk_hthread *thr, void *ptr); #if defined(DUK_USE_DEBUGGER_DUMPHEAP) DUK_INTERNAL_DECL void duk_debug_write_heapptr(duk_hthread *thr, duk_heaphdr *h); #endif @@ -8466,9 +10434,13 @@ DUK_INTERNAL_DECL void duk_debug_write_error_eom(duk_hthread *thr, duk_small_uin DUK_INTERNAL_DECL void duk_debug_write_notify(duk_hthread *thr, duk_small_uint_t command); DUK_INTERNAL_DECL void duk_debug_write_eom(duk_hthread *thr); -DUK_INTERNAL duk_uint_fast32_t duk_debug_curr_line(duk_hthread *thr); -DUK_INTERNAL void duk_debug_send_status(duk_hthread *thr); +DUK_INTERNAL_DECL duk_uint_fast32_t duk_debug_curr_line(duk_hthread *thr); +DUK_INTERNAL_DECL void duk_debug_send_status(duk_hthread *thr); +#if defined(DUK_USE_DEBUGGER_THROW_NOTIFY) +DUK_INTERNAL_DECL void duk_debug_send_throw(duk_hthread *thr, duk_bool_t fatal); +#endif +DUK_INTERNAL_DECL void duk_debug_halt_execution(duk_hthread *thr, duk_bool_t use_prev_pc); DUK_INTERNAL_DECL duk_bool_t duk_debug_process_messages(duk_hthread *thr, duk_bool_t no_block); DUK_INTERNAL_DECL duk_small_int_t duk_debug_add_breakpoint(duk_hthread *thr, duk_hstring *filename, duk_uint32_t line); @@ -8652,7 +10624,7 @@ DUK_INTERNAL_DECL duk_small_int_t duk_debug_level_stash; DUK_INTERNAL_DECL void duk_debug_log(const char *fmt, ...); #endif /* DUK_USE_VARIADIC_MACROS */ -DUK_INTERNAL_DECL void duk_fb_put_bytes(duk_fixedbuffer *fb, duk_uint8_t *buffer, duk_size_t length); +DUK_INTERNAL_DECL void duk_fb_put_bytes(duk_fixedbuffer *fb, const duk_uint8_t *buffer, duk_size_t length); DUK_INTERNAL_DECL void duk_fb_put_byte(duk_fixedbuffer *fb, duk_uint8_t x); DUK_INTERNAL_DECL void duk_fb_put_cstring(duk_fixedbuffer *fb, const char *x); DUK_INTERNAL_DECL void duk_fb_sprintf(duk_fixedbuffer *fb, const char *fmt, ...); @@ -8710,9 +10682,9 @@ DUK_INTERNAL_DECL duk_bool_t duk_fb_is_full(duk_fixedbuffer *fb); * fall back to awkward hacks. */ -#ifdef DUK_USE_VERBOSE_ERRORS +#if defined(DUK_USE_VERBOSE_ERRORS) -#ifdef DUK_USE_VARIADIC_MACROS +#if defined(DUK_USE_VARIADIC_MACROS) /* __VA_ARGS__ has comma issues for empty lists, so we mandate at least 1 argument for '...' (format string) */ #define DUK_ERROR(thr,err,...) duk_err_handle_error(DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (thr), (err), __VA_ARGS__) @@ -8734,7 +10706,7 @@ DUK_INTERNAL_DECL duk_bool_t duk_fb_is_full(duk_fixedbuffer *fb); #else /* DUK_USE_VERBOSE_ERRORS */ -#ifdef DUK_USE_VARIADIC_MACROS +#if defined(DUK_USE_VARIADIC_MACROS) #define DUK_ERROR(thr,err,...) duk_err_handle_error((thr), (err)) #define DUK_ERROR_RAW(file,line,thr,err,...) duk_err_handle_error((thr), (err)) @@ -8763,7 +10735,7 @@ DUK_INTERNAL_DECL duk_bool_t duk_fb_is_full(duk_fixedbuffer *fb); * Panic error * * Panic errors are not relative to either a heap or a thread, and cause - * DUK_PANIC() macro to be invoked. Unlesa a user provides DUK_OPT_PANIC_HANDLER, + * DUK_PANIC() macro to be invoked. Unless a user provides DUK_USE_PANIC_HANDLER, * DUK_PANIC() calls a helper which prints out the error and causes a process * exit. * @@ -8786,7 +10758,7 @@ DUK_INTERNAL_DECL duk_bool_t duk_fb_is_full(duk_fixedbuffer *fb); * Assert macro: failure causes panic. */ -#ifdef DUK_USE_ASSERTIONS +#if defined(DUK_USE_ASSERTIONS) /* the message should be a compile time constant without formatting (less risk); * we don't care about assertion text size because they're not used in production @@ -8800,16 +10772,32 @@ DUK_INTERNAL_DECL duk_bool_t duk_fb_is_full(duk_fixedbuffer *fb); } \ } while (0) +/* Assertion compatible inside a comma expression, evaluates to void. + * Currently not compatible with DUK_USE_PANIC_HANDLER() which may have + * a statement block. + */ +#if defined(DUK_USE_PANIC_HANDLER) +/* XXX: resolve macro definition issue or call through a helper function? */ +#define DUK_ASSERT_EXPR(x) ((void) 0) +#else +#define DUK_ASSERT_EXPR(x) \ + ((void) ((x) ? 0 : (DUK_PANIC(DUK_ERR_ASSERTION_ERROR, \ + "assertion failed: " #x \ + " (" DUK_FILE_MACRO ":" DUK_MACRO_STRINGIFY(DUK_LINE_MACRO) ")"), 0))) +#endif + #else /* DUK_USE_ASSERTIONS */ -#define DUK_ASSERT(x) do { /* assertion omitted */ } while(0) +#define DUK_ASSERT(x) do { /* assertion omitted */ } while (0) + +#define DUK_ASSERT_EXPR(x) ((void) 0) #endif /* DUK_USE_ASSERTIONS */ /* this variant is used when an assert would generate a compile warning by * being always true (e.g. >= 0 comparison for an unsigned value */ -#define DUK_ASSERT_DISABLE(x) do { /* assertion disabled */ } while(0) +#define DUK_ASSERT_DISABLE(x) do { /* assertion disabled */ } while (0) /* * Assertion helpers @@ -8833,9 +10821,9 @@ DUK_INTERNAL_DECL duk_bool_t duk_fb_is_full(duk_fixedbuffer *fb); #if defined(DUK_USE_ASSERTIONS) && defined(DUK_USE_PACKED_TVAL) #define DUK_ASSERT_DOUBLE_IS_NORMALIZED(dval) do { \ - duk_double_union assert_tmp_du; \ - assert_tmp_du.d = (dval); \ - DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&assert_tmp_du)); \ + duk_double_union duk__assert_tmp_du; \ + duk__assert_tmp_du.d = (dval); \ + DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&duk__assert_tmp_du)); \ } while (0) #else #define DUK_ASSERT_DOUBLE_IS_NORMALIZED(dval) /* nop */ @@ -8861,12 +10849,55 @@ DUK_INTERNAL_DECL duk_bool_t duk_fb_is_full(duk_fixedbuffer *fb); #define DUK_ASSERT_VALSTACK_SPACE(thr,n) /* no valstack space check */ #endif +/* + * Error throwing helpers + * + * The goal is to provide verbose and configurable error messages. Call + * sites should be clean in source code and compile to a small footprint. + * Small footprint is also useful for performance because small cold paths + * reduce code cache pressure. + */ + +#if defined(DUK_USE_VERBOSE_ERRORS) +#if defined(DUK_USE_PARANOID_ERRORS) +/* Verbose but paranoid errors. */ + +#define DUK_ERROR_REQUIRE_TYPE_INDEX(thr,index,expectname,lowmemstr) do { \ + duk_err_require_type_index(DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (thr), (index), (expectname)); \ + } while (0) +#else +/* Verbose errors with key/value summaries. */ + +#define DUK_ERROR_REQUIRE_TYPE_INDEX(thr,index,expectname,lowmemstr) do { \ + duk_err_require_type_index(DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (thr), (index), (expectname)); \ + } while (0) +#endif +#define DUK_ERROR_API_INDEX(thr,index) do { \ + duk_err_api_index(DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (thr), (index)); \ + } while (0) +#define DUK_ERROR_API(thr,msg) do { \ + duk_err_api(DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (thr), (msg)); \ + } while (0) +#else +/* Non-verbose errors for low memory targets. */ + +#define DUK_ERROR_REQUIRE_TYPE_INDEX(thr,index,expectname,lowmemstr) do { \ + duk_err_require_type_index(DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (thr), (lowmemstr)); \ + } while (0) +#define DUK_ERROR_API_INDEX(thr,index) do { \ + duk_err_api_index(DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (thr)); \ + } while (0) +#define DUK_ERROR_API(thr,msg) do { \ + duk_err_api(DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (thr), (msg)); \ + } while (0) +#endif + /* * Prototypes */ -#ifdef DUK_USE_VERBOSE_ERRORS -#ifdef DUK_USE_VARIADIC_MACROS +#if defined(DUK_USE_VERBOSE_ERRORS) +#if defined(DUK_USE_VARIADIC_MACROS) DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error(const char *filename, duk_int_t line, duk_hthread *thr, duk_errcode_t code, const char *fmt, ...)); #else /* DUK_USE_VARIADIC_MACROS */ #if !defined(DUK_SINGLE_FILE) @@ -8877,7 +10908,7 @@ DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error(const char *filename, d DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error_stash(duk_hthread *thr, duk_errcode_t code, const char *fmt, ...)); #endif /* DUK_USE_VARIADIC_MACROS */ #else /* DUK_USE_VERBOSE_ERRORS */ -#ifdef DUK_USE_VARIADIC_MACROS +#if defined(DUK_USE_VARIADIC_MACROS) DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error(duk_hthread *thr, duk_errcode_t code)); #else /* DUK_USE_VARIADIC_MACROS */ DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error_nonverbose1(duk_hthread *thr, duk_errcode_t code, const char *fmt, ...)); @@ -8885,7 +10916,7 @@ DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error_nonverbose2(const char #endif /* DUK_USE_VARIADIC_MACROS */ #endif /* DUK_USE_VERBOSE_ERRORS */ -#ifdef DUK_USE_VERBOSE_ERRORS +#if defined(DUK_USE_VERBOSE_ERRORS) DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code, const char *msg, const char *filename, duk_int_t line)); #else DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code)); @@ -8900,6 +10931,20 @@ DUK_INTERNAL_DECL void duk_err_augment_error_create(duk_hthread *thr, duk_hthrea DUK_INTERNAL_DECL void duk_err_augment_error_throw(duk_hthread *thr); #endif +#if defined(DUK_USE_VERBOSE_ERRORS) +#if defined(DUK_USE_PARANOID_ERRORS) +DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_require_type_index(const char *filename, duk_int_t linenumber, duk_hthread *thr, duk_idx_t index, const char *expect_name)); +#else +DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_require_type_index(const char *filename, duk_int_t linenumber, duk_hthread *thr, duk_idx_t index, const char *expect_name)); +#endif +DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_api_index(const char *filename, duk_int_t linenumber, duk_hthread *thr, duk_idx_t index)); +DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_api(const char *filename, duk_int_t linenumber, duk_hthread *thr, const char *message)); +#else +DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_require_type_index(const char *filename, duk_int_t linenumber, duk_hthread *thr, const char *error_msg)); +DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_api_index(const char *filename, duk_int_t linenumber, duk_hthread *thr)); +DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_api(const char *filename, duk_int_t linenumber, duk_hthread *thr, const char *message)); +#endif + DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_longjmp(duk_hthread *thr)); DUK_NORETURN(DUK_INTERNAL_DECL void duk_default_fatal_handler(duk_context *ctx, duk_errcode_t code, const char *msg)); @@ -8913,81 +10958,6 @@ DUK_INTERNAL_DECL void duk_err_setup_heap_ljstate(duk_hthread *thr, duk_small_in DUK_INTERNAL_DECL duk_hobject *duk_error_prototype_from_code(duk_hthread *thr, duk_errcode_t err_code); #endif /* DUK_ERROR_H_INCLUDED */ -#line 1 "duk_util.h" -/* - * Utilities - */ - -#ifndef DUK_UTIL_H_INCLUDED -#define DUK_UTIL_H_INCLUDED - -#define DUK_UTIL_MIN_HASH_PRIME 17 /* must match genhashsizes.py */ - -#define DUK_UTIL_GET_HASH_PROBE_STEP(hash) (duk_util_probe_steps[(hash) & 0x1f]) - -/* - * Bitstream decoder - */ - -struct duk_bitdecoder_ctx { - const duk_uint8_t *data; - duk_size_t offset; - duk_size_t length; - duk_uint32_t currval; - duk_small_int_t currbits; -}; - -/* - * Bitstream encoder - */ - -struct duk_bitencoder_ctx { - duk_uint8_t *data; - duk_size_t offset; - duk_size_t length; - duk_uint32_t currval; - duk_small_int_t currbits; - duk_small_int_t truncated; -}; - -/* - * Externs and prototypes - */ - -#if !defined(DUK_SINGLE_FILE) -DUK_INTERNAL_DECL duk_uint8_t duk_lc_digits[36]; -DUK_INTERNAL_DECL duk_uint8_t duk_uc_nybbles[16]; -DUK_INTERNAL_DECL duk_int8_t duk_hex_dectab[256]; -#endif /* !DUK_SINGLE_FILE */ - -/* Note: assumes that duk_util_probe_steps size is 32 */ -#if defined(DUK_USE_HOBJECT_HASH_PART) || defined(DUK_USE_STRTAB_PROBE) -#if !defined(DUK_SINGLE_FILE) -DUK_INTERNAL_DECL duk_uint8_t duk_util_probe_steps[32]; -#endif /* !DUK_SINGLE_FILE */ -#endif - -DUK_INTERNAL_DECL duk_uint32_t duk_util_hashbytes(const duk_uint8_t *data, duk_size_t len, duk_uint32_t seed); - -#if defined(DUK_USE_HOBJECT_HASH_PART) || defined(DUK_USE_STRTAB_PROBE) -DUK_INTERNAL_DECL duk_uint32_t duk_util_get_hash_prime(duk_uint32_t size); -#endif - -DUK_INTERNAL_DECL duk_int32_t duk_bd_decode(duk_bitdecoder_ctx *ctx, duk_small_int_t bits); -DUK_INTERNAL_DECL duk_small_int_t duk_bd_decode_flag(duk_bitdecoder_ctx *ctx); -DUK_INTERNAL_DECL duk_int32_t duk_bd_decode_flagged(duk_bitdecoder_ctx *ctx, duk_small_int_t bits, duk_int32_t def_value); - -DUK_INTERNAL_DECL void duk_be_encode(duk_bitencoder_ctx *ctx, duk_uint32_t data, duk_small_int_t bits); -DUK_INTERNAL_DECL void duk_be_finish(duk_bitencoder_ctx *ctx); - -DUK_INTERNAL_DECL duk_uint32_t duk_util_tinyrandom_get_bits(duk_hthread *thr, duk_small_int_t n); -DUK_INTERNAL_DECL duk_double_t duk_util_tinyrandom_get_double(duk_hthread *thr); - -#if defined(DUK_USE_DEBUGGER_SUPPORT) /* For now only needed by the debugger. */ -DUK_INTERNAL void duk_byteswap_bytes(duk_uint8_t *p, duk_small_uint_t len); -#endif - -#endif /* DUK_UTIL_H_INCLUDED */ #line 1 "duk_unicode.h" /* * Unicode helpers @@ -9000,8 +10970,10 @@ DUK_INTERNAL void duk_byteswap_bytes(duk_uint8_t *p, duk_small_uint_t len); * UTF-8 / XUTF-8 / CESU-8 constants */ -#define DUK_UNICODE_MAX_XUTF8_LENGTH 7 /* up to 36 bit codepoints */ -#define DUK_UNICODE_MAX_CESU8_LENGTH 6 /* all codepoints up to U+10FFFF */ +#define DUK_UNICODE_MAX_XUTF8_LENGTH 7 /* up to 36 bit codepoints */ +#define DUK_UNICODE_MAX_XUTF8_BMP_LENGTH 3 /* all codepoints up to U+FFFF */ +#define DUK_UNICODE_MAX_CESU8_LENGTH 6 /* all codepoints up to U+10FFFF */ +#define DUK_UNICODE_MAX_CESU8_BMP_LENGTH 3 /* all codepoints up to U+FFFF */ /* * Useful Unicode codepoints @@ -9207,6 +11179,14 @@ extern const duk_uint8_t duk_unicode_idp_m_ids_noabmp[348]; extern const duk_uint8_t duk_unicode_caseconv_uc[1288]; extern const duk_uint8_t duk_unicode_caseconv_lc[616]; +#if defined(DUK_USE_REGEXP_CANON_WORKAROUND) +/* + * Automatically generated by extract_caseconv.py, do not edit! + */ + +extern const duk_uint16_t duk_unicode_re_canon_lookup[65536]; +#endif + /* * Extern */ @@ -9227,6 +11207,9 @@ DUK_INTERNAL_DECL duk_uint16_t duk_unicode_re_ranges_not_wordchar[10]; */ DUK_INTERNAL_DECL duk_small_int_t duk_unicode_get_xutf8_length(duk_ucodepoint_t cp); +#if defined(DUK_USE_ASSERTIONS) +DUK_INTERNAL_DECL duk_small_int_t duk_unicode_get_cesu8_length(duk_ucodepoint_t cp); +#endif DUK_INTERNAL_DECL duk_small_int_t duk_unicode_encode_xutf8(duk_ucodepoint_t cp, duk_uint8_t *out); DUK_INTERNAL_DECL duk_small_int_t duk_unicode_encode_cesu8(duk_ucodepoint_t cp, duk_uint8_t *out); DUK_INTERNAL_DECL duk_small_int_t duk_unicode_decode_xutf8(duk_hthread *thr, const duk_uint8_t **ptr, const duk_uint8_t *ptr_start, const duk_uint8_t *ptr_end, duk_ucodepoint_t *out_cp); @@ -9250,20 +11233,11 @@ DUK_INTERNAL_DECL duk_small_int_t duk_unicode_re_is_wordchar(duk_codepoint_t cp) #ifndef DUK_JSON_H_INCLUDED #define DUK_JSON_H_INCLUDED -/* Object/array recursion limit (to protect C stack) */ -#if defined(DUK_USE_DEEP_C_STACK) -#define DUK_JSON_ENC_RECURSION_LIMIT 1000 -#define DUK_JSON_DEC_RECURSION_LIMIT 1000 -#else -#define DUK_JSON_ENC_RECURSION_LIMIT 100 -#define DUK_JSON_DEC_RECURSION_LIMIT 100 -#endif - /* Encoding/decoding flags */ -#define DUK_JSON_FLAG_ASCII_ONLY (1 << 0) /* escape any non-ASCII characters */ -#define DUK_JSON_FLAG_AVOID_KEY_QUOTES (1 << 1) /* avoid key quotes when key is an ASCII Identifier */ -#define DUK_JSON_FLAG_EXT_CUSTOM (1 << 2) /* extended types: custom encoding */ -#define DUK_JSON_FLAG_EXT_COMPATIBLE (1 << 3) /* extended types: compatible encoding */ +#define DUK_JSON_FLAG_ASCII_ONLY (1 << 0) /* escape any non-ASCII characters */ +#define DUK_JSON_FLAG_AVOID_KEY_QUOTES (1 << 1) /* avoid key quotes when key is an ASCII Identifier */ +#define DUK_JSON_FLAG_EXT_CUSTOM (1 << 2) /* extended types: custom encoding */ +#define DUK_JSON_FLAG_EXT_COMPATIBLE (1 << 3) /* extended types: compatible encoding */ /* How much stack to require on entry to object/array encode */ #define DUK_JSON_ENC_REQSTACK 32 @@ -9271,13 +11245,15 @@ DUK_INTERNAL_DECL duk_small_int_t duk_unicode_re_is_wordchar(duk_codepoint_t cp) /* How much stack to require on entry to object/array decode */ #define DUK_JSON_DEC_REQSTACK 32 +/* How large a loop detection stack to use */ +#define DUK_JSON_ENC_LOOPARRAY 64 + /* Encoding state. Heap object references are all borrowed. */ typedef struct { duk_hthread *thr; - duk_hbuffer_dynamic *h_buf; + duk_bufwriter_ctx bw; /* output bufwriter */ duk_hobject *h_replacer; /* replacer function */ duk_hstring *h_gap; /* gap (if empty string, NULL) */ - duk_hstring *h_indent; /* current indent (if gap is NULL, this is NULL) */ duk_idx_t idx_proplist; /* explicit PropertyList */ duk_idx_t idx_loop; /* valstack index of loop detection object */ duk_small_uint_t flags; @@ -9286,6 +11262,7 @@ typedef struct { #if defined(DUK_USE_JX) || defined(DUK_USE_JC) duk_small_uint_t flag_ext_custom; duk_small_uint_t flag_ext_compatible; + duk_small_uint_t flag_ext_custom_or_compatible; #endif duk_int_t recursion_depth; duk_int_t recursion_limit; @@ -9297,6 +11274,7 @@ typedef struct { duk_small_uint_t stridx_custom_posinf; duk_small_uint_t stridx_custom_function; #endif + duk_hobject *visiting[DUK_JSON_ENC_LOOPARRAY]; /* indexed by recursion_depth */ } duk_json_enc_ctx; typedef struct { @@ -9309,6 +11287,7 @@ typedef struct { #if defined(DUK_USE_JX) || defined(DUK_USE_JC) duk_small_uint_t flag_ext_custom; duk_small_uint_t flag_ext_compatible; + duk_small_uint_t flag_ext_custom_or_compatible; #endif duk_int_t recursion_depth; duk_int_t recursion_limit; @@ -9324,12 +11303,11 @@ typedef struct { #define DUK_JS_H_INCLUDED /* Flags for call handling. */ -#define DUK_CALL_FLAG_PROTECTED (1 << 0) /* duk_handle_call: call is protected */ -#define DUK_CALL_FLAG_IGNORE_RECLIMIT (1 << 1) /* duk_handle_call: call ignores C recursion limit (for errhandler calls) */ -#define DUK_CALL_FLAG_CONSTRUCTOR_CALL (1 << 2) /* duk_handle_call: constructor call (i.e. called as 'new Foo()') */ -#define DUK_CALL_FLAG_IS_RESUME (1 << 3) /* duk_handle_ecma_call_setup: setup for a resume() */ -#define DUK_CALL_FLAG_IS_TAILCALL (1 << 4) /* duk_handle_ecma_call_setup: setup for a tailcall */ -#define DUK_CALL_FLAG_DIRECT_EVAL (1 << 5) /* call is a direct eval call */ +#define DUK_CALL_FLAG_IGNORE_RECLIMIT (1 << 0) /* duk_handle_call_xxx: call ignores C recursion limit (for errhandler calls) */ +#define DUK_CALL_FLAG_CONSTRUCTOR_CALL (1 << 1) /* duk_handle_call_xxx: constructor call (i.e. called as 'new Foo()') */ +#define DUK_CALL_FLAG_IS_RESUME (1 << 2) /* duk_handle_ecma_call_setup: setup for a resume() */ +#define DUK_CALL_FLAG_IS_TAILCALL (1 << 3) /* duk_handle_ecma_call_setup: setup for a tail call */ +#define DUK_CALL_FLAG_DIRECT_EVAL (1 << 4) /* call is a direct eval call */ /* Flags for duk_js_equals_helper(). */ #define DUK_EQUALS_FLAG_SAMEVALUE (1 << 0) /* use SameValue instead of non-strict equality */ @@ -9350,7 +11328,11 @@ DUK_INTERNAL_DECL duk_uint16_t duk_js_touint16(duk_hthread *thr, duk_tval *tv); DUK_INTERNAL_DECL duk_small_int_t duk_js_to_arrayindex_raw_string(const duk_uint8_t *str, duk_uint32_t blen, duk_uarridx_t *out_idx); DUK_INTERNAL_DECL duk_uarridx_t duk_js_to_arrayindex_string_helper(duk_hstring *h); DUK_INTERNAL_DECL duk_bool_t duk_js_equals_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags); +DUK_INTERNAL_DECL duk_small_int_t duk_js_data_compare(const duk_uint8_t *buf1, const duk_uint8_t *buf2, duk_size_t len1, duk_size_t len2); DUK_INTERNAL_DECL duk_small_int_t duk_js_string_compare(duk_hstring *h1, duk_hstring *h2); +#if 0 /* unused */ +DUK_INTERNAL_DECL duk_small_int_t duk_js_buffer_compare(duk_heap *heap, duk_hbuffer *h1, duk_hbuffer *h2); +#endif DUK_INTERNAL_DECL duk_bool_t duk_js_compare_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags); DUK_INTERNAL_DECL duk_bool_t duk_js_instanceof(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y); DUK_INTERNAL_DECL duk_bool_t duk_js_in(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y); @@ -9402,7 +11384,8 @@ void duk_js_push_closure(duk_hthread *thr, duk_hobject *outer_lex_env); /* call handling */ -DUK_INTERNAL_DECL duk_int_t duk_handle_call(duk_hthread *thr, duk_idx_t num_stack_args, duk_small_uint_t call_flags); +DUK_INTERNAL_DECL duk_int_t duk_handle_call_protected(duk_hthread *thr, duk_idx_t num_stack_args, duk_small_uint_t call_flags); +DUK_INTERNAL_DECL void duk_handle_call_unprotected(duk_hthread *thr, duk_idx_t num_stack_args, duk_small_uint_t call_flags); DUK_INTERNAL_DECL duk_int_t duk_handle_safe_call(duk_hthread *thr, duk_safe_call_function func, duk_idx_t num_stack_args, duk_idx_t num_stack_res); DUK_INTERNAL_DECL duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, duk_idx_t num_stack_args, duk_small_uint_t call_flags); @@ -9517,11 +11500,6 @@ DUK_INTERNAL_DECL void duk_numconv_parse(duk_context *ctx, duk_small_int_t radix */ #define DUK_BI_DATE_ISO8601_BUFSIZE 48 -/* Buffer size for "short log message" which use a heap-level pre-allocated - * dynamic buffer to reduce memory churn. - */ -#define DUK_BI_LOGGER_SHORT_MSG_LIMIT 256 - /* Maximum length of CommonJS module identifier to resolve. Length includes * both current module ID, requested (possibly relative) module ID, and a * slash in between. @@ -9548,8 +11526,30 @@ DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_reduce_shared(duk_context *ct DUK_INTERNAL_DECL duk_ret_t duk_bi_boolean_constructor(duk_context *ctx); DUK_INTERNAL_DECL duk_ret_t duk_bi_boolean_prototype_tostring_shared(duk_context *ctx); +/* XXX: naming is inconsistent with other builtins, "prototype" not used as + * part of function name. + */ DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_constructor(duk_context *ctx); DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_prototype_tostring_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_readfield(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_writefield(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_compare_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_slice_shared(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_arraybuffer_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_arraybuffer_isview(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_dataview_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_typedarray_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_typedarray_set(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_constructor(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_concat(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_is_encoding(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_is_buffer(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_byte_length(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_tostring(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_tojson(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_fill(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_copy(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_nodejs_buffer_write(duk_context *ctx); DUK_INTERNAL_DECL duk_ret_t duk_bi_date_constructor(duk_context *ctx); DUK_INTERNAL_DECL duk_ret_t duk_bi_date_constructor_parse(duk_context *ctx); @@ -9563,8 +11563,38 @@ DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_get_timezone_offset(duk_contex DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_set_shared(duk_context *ctx); DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_set_time(duk_context *ctx); /* Helpers exposed for internal use */ -DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_now(duk_context *ctx); +DUK_INTERNAL_DECL void duk_bi_date_timeval_to_parts(duk_double_t d, duk_int_t *parts, duk_double_t *dparts, duk_small_uint_t flags); +DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_timeval_from_dparts(duk_double_t *dparts, duk_small_uint_t flags); DUK_INTERNAL_DECL void duk_bi_date_format_timeval(duk_double_t timeval, duk_uint8_t *out_buf); +DUK_INTERNAL_DECL duk_bool_t duk_bi_date_is_leap_year(duk_int_t year); +DUK_INTERNAL_DECL duk_bool_t duk_bi_date_timeval_in_valid_range(duk_double_t x); +DUK_INTERNAL_DECL duk_bool_t duk_bi_date_year_in_valid_range(duk_double_t year); +DUK_INTERNAL_DECL duk_bool_t duk_bi_date_timeval_in_leeway_range(duk_double_t x); +/* Built-in providers */ +#if defined(DUK_USE_DATE_NOW_GETTIMEOFDAY) +DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_now_gettimeofday(duk_context *ctx); +#endif +#if defined(DUK_USE_DATE_NOW_TIME) +DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_now_time(duk_context *ctx); +#endif +#if defined(DUK_USE_DATE_NOW_WINDOWS) +DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_now_windows(duk_context *ctx); +#endif +#if defined(DUK_USE_DATE_TZO_GMTIME_R) || defined(DUK_USE_DATE_TZO_GMTIME) +DUK_INTERNAL_DECL duk_int_t duk_bi_date_get_local_tzoffset_gmtime(duk_double_t d); +#endif +#if defined(DUK_USE_DATE_TZO_WINDOWS) +DUK_INTERNAL_DECL duk_int_t duk_bi_date_get_local_tzoffset_windows(duk_double_t d); +#endif +#if defined(DUK_USE_DATE_PRS_STRPTIME) +DUK_INTERNAL_DECL duk_bool_t duk_bi_date_parse_string_strptime(duk_context *ctx, const char *str); +#endif +#if defined(DUK_USE_DATE_PRS_GETDATE) +DUK_INTERNAL_DECL duk_bool_t duk_bi_date_parse_string_getdate(duk_context *ctx, const char *str); +#endif +#if defined(DUK_USE_DATE_FMT_STRFTIME) +DUK_INTERNAL_DECL duk_bool_t duk_bi_date_format_parts_strftime(duk_context *ctx, duk_int_t *parts, duk_int_t tzoffset, duk_small_uint_t flags); +#endif DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_info(duk_context *ctx); DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_act(duk_context *ctx); @@ -9579,7 +11609,9 @@ DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_to_string(duk_context *ctx); DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_stack_getter(duk_context *ctx); DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_filename_getter(duk_context *ctx); DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_linenumber_getter(duk_context *ctx); -DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_nop_setter(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_stack_setter(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_filename_setter(duk_context *ctx); +DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_linenumber_setter(duk_context *ctx); DUK_INTERNAL_DECL duk_ret_t duk_bi_function_constructor(duk_context *ctx); DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype(duk_context *ctx); @@ -9673,7 +11705,7 @@ DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_split(duk_context *ctx); DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_substring(duk_context *ctx); DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_caseconv_shared(duk_context *ctx); DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_trim(duk_context *ctx); -/* Note: present even if DUK_OPT_NO_SECTION_B given because genbuiltins.py +/* Note: present even if DUK_USE_SECTION_B undefined given because genbuiltins.py * will point to it. */ DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_substr(duk_context *ctx); @@ -9709,7 +11741,7 @@ DUK_INTERNAL_DECL void duk_selftest_run_tests(void); #endif #endif /* DUK_SELFTEST_H_INCLUDED */ -#line 76 "duk_internal.h" +#line 78 "duk_internal.h" #endif /* DUK_INTERNAL_H_INCLUDED */ #line 1 "duk_strings.c" @@ -9717,7 +11749,8 @@ DUK_INTERNAL_DECL void duk_selftest_run_tests(void); * Shared error message strings * * To minimize code footprint, try to share error messages inside Duktape - * code. + * code. Modern compilers will do this automatically anyway, this is mostly + * for older compilers. */ /* include removed: duk_internal.h */ @@ -9733,41 +11766,25 @@ DUK_INTERNAL const char *duk_str_not_writable = "not writable"; DUK_INTERNAL const char *duk_str_not_configurable = "not configurable"; DUK_INTERNAL const char *duk_str_invalid_context = "invalid context"; -DUK_INTERNAL const char *duk_str_invalid_index = "invalid index"; DUK_INTERNAL const char *duk_str_push_beyond_alloc_stack = "attempt to push beyond currently allocated stack"; -DUK_INTERNAL const char *duk_str_not_undefined = "not undefined"; -DUK_INTERNAL const char *duk_str_not_null = "not null"; -DUK_INTERNAL const char *duk_str_not_boolean = "not boolean"; -DUK_INTERNAL const char *duk_str_not_number = "not number"; -DUK_INTERNAL const char *duk_str_not_string = "not string"; -DUK_INTERNAL const char *duk_str_not_pointer = "not pointer"; -DUK_INTERNAL const char *duk_str_not_buffer = "not buffer"; +DUK_INTERNAL const char *duk_str_not_buffer = "not buffer"; /* still in use with verbose messages */ DUK_INTERNAL const char *duk_str_unexpected_type = "unexpected type"; -DUK_INTERNAL const char *duk_str_not_thread = "not thread"; -#if 0 /*unused*/ -DUK_INTERNAL const char *duk_str_not_compiledfunction = "not compiledfunction"; -#endif -DUK_INTERNAL const char *duk_str_not_nativefunction = "not nativefunction"; -DUK_INTERNAL const char *duk_str_not_c_function = "not c function"; DUK_INTERNAL const char *duk_str_defaultvalue_coerce_failed = "[[DefaultValue]] coerce failed"; DUK_INTERNAL const char *duk_str_number_outside_range = "number outside range"; DUK_INTERNAL const char *duk_str_not_object_coercible = "not object coercible"; DUK_INTERNAL const char *duk_str_string_too_long = "string too long"; DUK_INTERNAL const char *duk_str_buffer_too_long = "buffer too long"; DUK_INTERNAL const char *duk_str_sprintf_too_long = "sprintf message too long"; -DUK_INTERNAL const char *duk_str_object_alloc_failed = "object alloc failed"; -DUK_INTERNAL const char *duk_str_thread_alloc_failed = "thread alloc failed"; -DUK_INTERNAL const char *duk_str_func_alloc_failed = "func alloc failed"; -DUK_INTERNAL const char *duk_str_buffer_alloc_failed = "buffer alloc failed"; +DUK_INTERNAL const char *duk_str_alloc_failed = "alloc failed"; DUK_INTERNAL const char *duk_str_pop_too_many = "attempt to pop too many entries"; -DUK_INTERNAL const char *duk_str_buffer_not_dynamic = "buffer is not dynamic"; +DUK_INTERNAL const char *duk_str_wrong_buffer_type = "wrong buffer type"; DUK_INTERNAL const char *duk_str_failed_to_extend_valstack = "failed to extend valstack"; -DUK_INTERNAL const char *duk_str_base64_encode_failed = "base64 encode failed"; -DUK_INTERNAL const char *duk_str_base64_decode_failed = "base64 decode failed"; -DUK_INTERNAL const char *duk_str_hex_decode_failed = "hex decode failed"; +DUK_INTERNAL const char *duk_str_encode_failed = "encode failed"; +DUK_INTERNAL const char *duk_str_decode_failed = "decode failed"; DUK_INTERNAL const char *duk_str_no_sourcecode = "no sourcecode"; DUK_INTERNAL const char *duk_str_concat_result_too_long = "concat result too long"; DUK_INTERNAL const char *duk_str_unimplemented = "unimplemented"; +DUK_INTERNAL const char *duk_str_unsupported = "unsupported"; DUK_INTERNAL const char *duk_str_array_length_over_2g = "array length over 2G"; /* JSON */ @@ -9946,18 +11963,6 @@ DUK_INTERNAL void duk_debug_log(duk_small_int_t level, const char *file, duk_int DUK_MEMZERO((void *) duk__debug_buf, (size_t) DUK__DEBUG_BUFSIZE); duk_debug_vsnprintf(duk__debug_buf, DUK__DEBUG_BUFSIZE - 1, fmt, ap); -#ifdef DUK_USE_DPRINT_RDTSC - DUK_FPRINTF(DUK_STDERR, "%s[%s] <%llu> %s:%ld (%s):%s %s%s\n", - (const char *) duk__get_term_1(level), - (const char *) duk__get_level_string(level), - (unsigned long long) duk_rdtsc(), /* match the inline asm in duk_features.h */ - (const char *) file, - (long) line, - (const char *) func, - (const char *) duk__get_term_2(level), - (const char *) duk__debug_buf, - (const char *) duk__get_term_3(level)); -#else DUK_FPRINTF(DUK_STDERR, "%s[%s] %s:%ld (%s):%s %s%s\n", (const char *) duk__get_term_1(level), (const char *) duk__get_level_string(level), @@ -9967,7 +11972,6 @@ DUK_INTERNAL void duk_debug_log(duk_small_int_t level, const char *file, duk_int (const char *) duk__get_term_2(level), (const char *) duk__debug_buf, (const char *) duk__get_term_3(level)); -#endif DUK_FFLUSH(DUK_STDERR); va_end(ap); @@ -9989,18 +11993,6 @@ DUK_INTERNAL void duk_debug_log(const char *fmt, ...) { DUK_MEMZERO((void *) duk__debug_buf, (size_t) DUK__DEBUG_BUFSIZE); duk_debug_vsnprintf(duk__debug_buf, DUK__DEBUG_BUFSIZE - 1, fmt, ap); -#ifdef DUK_USE_DPRINT_RDTSC - DUK_FPRINTF(DUK_STDERR, "%s[%s] <%llu> %s:%s (%s):%s %s%s\n", - (const char *) duk__get_term_1(level), - (const char *) duk__get_level_string(duk_debug_level_stash), - (unsigned long long) duk_rdtsc(), /* match duk_features.h */ - (const char *) duk_debug_file_stash, - (const char *) duk_debug_line_stash, - (const char *) duk_debug_func_stash, - (const char *) duk__get_term_2(level), - (const char *) duk__debug_buf, - (const char *) duk__get_term_3(level)); -#else DUK_FPRINTF(DUK_STDERR, "%s[%s] %s:%s (%s):%s %s%s\n", (const char *) duk__get_term_1(level), (const char *) duk__get_level_string(duk_debug_level_stash), @@ -10010,7 +12002,6 @@ DUK_INTERNAL void duk_debug_log(const char *fmt, ...) { (const char *) duk__get_term_2(level), (const char *) duk__debug_buf, (const char *) duk__get_term_3(level)); -#endif DUK_FFLUSH(DUK_STDERR); va_end(ap); @@ -10033,108 +12024,141 @@ DUK_INTERNAL void duk_debug_log(const char *fmt, ...) { /* include removed: duk_internal.h */ #if defined(DUK_USE_DOUBLE_LE) -DUK_INTERNAL const duk_uint8_t duk_strings_data[1943] = { -55,86,227,24,145,55,102,120,144,3,63,94,228,54,100,137,186,26,20,164,137, -186,50,11,164,109,77,215,5,61,35,106,3,25,110,8,22,158,130,38,163,8,217, -200,158,76,156,210,117,128,153,203,210,70,46,137,187,18,27,164,187,201,209, -130,100,55,91,70,4,145,63,66,231,44,128,105,187,41,197,13,49,122,8,196,24, -71,75,70,138,104,115,77,215,5,36,20,201,214,209,107,79,104,209,144,168,105, -6,207,251,209,104,209,125,212,227,66,127,235,191,239,232,180,90,52,95,69, -247,83,141,9,255,174,255,191,162,211,80,210,253,23,221,78,52,39,254,183, -254,254,139,72,105,126,139,238,167,26,19,255,91,255,127,69,166,129,191,69, -247,83,141,9,255,175,255,191,162,213,26,50,23,232,190,234,113,161,63,245, -115,119,86,227,118,83,138,26,98,9,110,48,86,22,148,160,152,22,82,70,46,137, -44,8,180,163,32,104,98,206,32,17,7,16,88,101,100,206,42,70,36,108,205,18, -74,140,33,196,230,60,2,152,146,33,38,230,8,36,79,182,251,65,156,151,24,200, -33,145,162,25,80,209,24,67,0,166,68,52,174,61,73,25,33,205,25,27,84,177, -195,234,220,1,144,105,99,135,217,16,17,17,208,72,199,179,60,93,100,146,49, -232,162,64,76,135,19,152,244,44,136,223,98,67,4,18,33,247,217,158,36,0,209, -190,156,13,26,201,21,111,165,67,64,180,100,145,62,250,32,45,100,33,55,214, -1,229,223,65,19,72,187,236,206,137,35,125,120,190,201,104,105,15,190,201, -212,136,136,125,246,160,137,27,83,239,171,37,200,218,159,125,168,34,192,61, -27,233,93,22,1,114,78,250,28,76,130,112,200,93,245,164,188,207,190,204,17, -49,38,109,246,160,93,8,119,185,13,153,34,96,208,165,36,85,190,206,32,17,6, -9,129,75,67,73,214,209,129,36,80,84,44,157,104,24,65,60,69,148,192,37,59, -179,60,93,110,207,15,39,73,24,186,39,232,232,169,129,228,18,6,120,146,20, -68,72,157,105,241,116,221,173,58,68,159,95,23,77,211,195,201,215,20,238, -179,122,162,98,73,35,104,194,68,19,35,134,69,146,100,235,226,231,146,51, -192,206,9,23,175,139,175,131,8,11,89,8,206,161,181,2,208,63,160,232,193,50, -23,246,254,187,235,190,187,247,69,241,95,18,31,160,15,214,11,235,126,192, -95,87,246,1,251,4,253,111,80,210,161,168,158,19,245,125,67,74,134,162,120, -71,80,210,161,168,158,12,224,164,130,153,165,56,161,166,51,104,192,146,39, -11,156,178,1,169,163,70,66,161,164,26,101,56,161,166,65,112,57,129,164,148, -35,49,201,13,44,93,70,140,209,3,70,230,13,238,176,216,134,141,128,184,214, -227,20,171,115,162,50,93,227,19,164,65,17,11,40,38,6,253,145,1,48,52,128, -146,26,64,9,210,24,3,34,250,80,140,254,200,254,148,35,63,177,215,217,11, -207,65,188,183,27,236,126,192,133,242,220,111,178,32,252,182,253,145,60, -182,253,143,216,7,164,59,9,41,0,196,35,64,194,21,13,125,38,84,52,100,185, -62,163,239,254,235,234,82,176,74,125,67,70,75,165,148,92,208,180,52,138,65, -154,232,147,162,4,136,105,58,145,17,9,50,74,100,37,200,37,205,222,51,39,47, -78,40,105,143,34,79,184,32,34,115,18,125,193,1,19,77,222,76,156,213,205, -222,68,157,47,78,40,105,151,55,122,147,20,189,56,161,166,116,137,63,82,98, -47,168,181,247,4,4,87,34,79,165,162,215,220,16,17,92,137,63,82,98,103,156, -217,157,18,36,250,199,54,103,84,137,63,82,98,31,129,50,30,68,159,70,9,145, -114,36,253,73,136,254,117,35,36,72,147,233,221,72,201,178,36,253,73,137, -158,67,105,50,73,82,36,250,196,54,147,36,155,34,79,212,152,165,226,9,205, -28,149,34,79,178,32,156,209,202,82,36,253,73,137,158,66,214,137,16,78,104, -228,249,18,125,98,22,180,72,130,115,71,35,200,147,236,208,194,68,196,159, -102,134,19,46,105,58,226,150,68,156,140,73,250,147,19,60,133,173,18,32,156, -209,201,230,36,250,196,45,104,145,4,230,142,77,49,39,234,76,82,241,4,230, -142,74,49,39,217,16,78,104,228,211,18,126,164,196,207,33,180,153,36,163,18, -125,98,27,73,146,75,49,39,234,76,71,243,169,25,32,196,159,78,234,70,73,49, -39,234,76,67,240,48,99,18,125,24,48,163,18,126,164,196,63,2,100,57,137,62, -140,19,34,204,73,250,147,19,60,230,204,232,49,39,214,57,179,59,140,73,250, -147,17,125,69,175,184,32,34,179,18,125,45,22,190,224,128,137,204,73,246, -104,97,37,55,117,110,16,22,78,205,12,39,101,56,161,166,148,221,213,184,64, -89,58,48,76,157,148,226,134,153,147,119,102,134,19,178,156,80,211,50,110, -232,193,50,118,83,138,26,97,181,214,31,169,49,21,224,140,136,185,187,175, -137,4,137,33,205,108,221,210,93,238,105,27,52,1,103,155,186,84,92,131,143, -158,233,34,104,169,52,134,149,13,68,241,31,52,134,4,209,82,105,13,42,26, -137,224,125,104,58,212,249,136,110,170,5,208,137,243,1,125,84,11,161,13,42, -6,83,137,39,20,50,51,119,86,225,1,100,237,30,242,71,162,4,136,185,187,180, -123,201,30,136,18,36,102,238,173,194,2,201,213,186,196,143,68,9,17,115,119, -86,235,18,61,16,36,68,202,129,148,226,134,152,178,122,209,51,72,128,136, -142,120,145,235,0,136,86,2,98,59,86,225,1,100,232,156,199,130,36,80,142,8, -244,78,25,58,9,152,71,4,122,9,176,177,115,58,35,130,61,19,134,69,196,131, -160,137,216,160,199,153,162,65,208,68,49,80,185,146,35,96,30,114,186,61,32, -4,114,73,204,33,73,82,71,11,88,37,62,161,163,37,250,226,157,13,25,47,215, -20,244,108,142,130,204,210,122,208,34,18,78,140,203,37,160,68,44,142,130, -204,241,37,73,25,16,143,164,142,55,185,228,75,144,211,9,205,16,38,116,75, -160,140,65,132,130,38,163,8,217,200,194,2,214,72,144,40,104,200,32,45,101, -3,222,188,81,241,115,201,25,227,168,151,72,218,48,145,0,86,70,162,93,124, -93,55,79,15,39,92,87,28,18,235,172,222,190,46,121,35,60,30,160,93,9,215,21, -211,119,86,225,1,100,236,167,20,52,200,155,187,41,197,13,50,196,230,202, -113,160,166,232,142,68,152,204,73,168,141,163,9,16,5,100,96,156,210,160, -212,136,2,178,34,209,68,192,21,144,181,2,232,66,40,152,147,17,46,146,243, -35,100,128,172,136,68,186,88,187,36,106,17,46,200,128,89,7,23,196,149,35, -103,210,94,100,108,144,230,200,197,137,9,146,18,68,2,224,50,21,13,39,95,23, -60,145,154,9,39,12,133,67,73,215,197,207,36,103,131,10,36,4,201,51,18,125, -117,155,215,197,207,36,103,142,180,12,36,176,98,79,174,179,122,248,185,228, -140,241,209,146,66,138,31,55,69,198,36,250,248,186,110,158,30,78,184,169, -124,93,55,79,15,33,150,70,154,103,40,22,72,204,175,138,27,52,81,164,144, -128,242,24,146,16,30,73,17,162,112,201,234,69,2,243,152,247,52,141,154,72, -209,56,100,245,34,137,12,130,112,201,234,69,2,243,152,247,52,141,154,70,65, -56,100,245,34,132,34,93,42,26,137,144,168,151,90,14,181,79,4,100,78,149, -110,4,208,240,70,68,234,27,50,18,160,90,61,72,160,158,140,93,20,246,120, -121,58,72,197,209,95,101,134,204,23,233,35,23,69,221,137,10,72,145,162,39, -73,24,186,42,236,64,211,19,164,140,93,20,244,149,2,250,72,197,209,40,98,64, -40,130,4,136,81,2,98,58,4,230,205,13,161,16,50,6,134,49,34,113,144,160,162, -230,97,145,100,153,4,55,16,139,145,14,84,52,11,94,6,87,69,5,163,69,52,57, -162,65,68,134,169,13,148,192,209,17,197,27,73,99,68,147,164,90,105,89,19, -17,201,51,162,69,153,226,235,14,113,193,167,135,145,197,29,65,18,85,200,25, -108,116,44,132,178,38,114,137,96,148,138,39,54,83,33,27,70,24,151,123,163, -51,146,243,35,71,35,33,143,116,102,89,81,228,137,27,69,172,147,141,8,82, -129,114,34,144,199,172,140,35,103,36,161,179,36,74,1,16,107,36,206,240,9, -64,49,14,248,162,160,153,18,248,186,100,20,200,51,62,129,90,4,105,76,19,64, -139,132,17,99, +DUK_INTERNAL const duk_uint8_t duk_strings_data[2624] = { +55,86,227,24,145,55,102,120,144,3,63,94,228,54,100,137,186,50,11,164,109, +77,215,5,61,35,106,206,149,110,4,254,219,237,58,8,196,24,103,74,183,2,127, +103,246,93,4,98,12,47,180,67,103,246,127,101,208,70,32,194,186,134,207,236, +254,203,160,140,65,133,246,136,108,254,199,237,186,8,196,24,87,80,217,253, +143,219,116,17,136,49,30,209,13,159,220,116,75,3,30,65,244,17,136,48,174, +209,13,159,220,116,17,136,48,158,161,179,251,142,130,49,6,17,209,130,96, +237,80,75,47,160,140,65,142,134,133,41,34,110,134,133,41,34,3,25,110,8,22, +158,130,38,163,8,217,200,158,76,156,210,117,128,153,203,210,70,46,137,187, +18,27,164,187,201,209,130,100,55,91,70,4,145,63,66,231,44,128,105,187,41, +197,13,49,122,8,196,24,71,75,70,138,104,115,77,215,5,36,20,201,214,209,107, +79,104,209,144,168,105,6,207,251,209,104,209,125,212,227,66,127,235,191, +239,232,180,90,52,95,69,247,83,141,9,255,174,255,191,162,211,80,210,253,23, +221,78,52,39,254,183,254,254,139,72,105,126,139,238,167,26,19,255,91,255, +127,69,166,129,191,69,247,83,141,9,255,175,255,191,162,213,26,50,23,232, +190,234,113,161,63,245,115,119,86,227,118,83,138,26,98,9,110,48,86,22,148, +160,152,22,82,70,46,137,44,8,180,163,32,104,98,206,32,17,7,16,88,101,100, +206,42,70,36,108,205,18,74,140,33,196,230,60,2,152,146,33,38,230,8,36,79, +182,251,65,156,151,24,200,33,145,162,25,80,209,24,67,0,166,68,52,174,61,73, +25,33,205,25,27,84,177,195,234,220,1,144,105,99,135,217,16,17,17,208,72, +199,179,60,93,100,146,49,232,162,64,76,135,19,152,244,44,136,223,98,67,4, +18,33,247,217,158,36,0,209,190,156,13,26,201,21,111,165,67,64,180,100,145, +62,250,32,45,100,33,55,214,1,229,223,65,19,72,187,236,206,137,35,125,120, +190,201,104,105,15,190,201,212,136,136,125,246,160,137,27,83,239,171,37, +200,218,159,125,168,34,192,61,27,233,93,22,1,114,78,250,28,76,130,112,200, +93,245,164,188,207,190,204,17,49,38,109,246,160,93,8,119,185,13,153,34,173, +246,113,0,136,48,76,10,90,26,78,182,140,9,34,130,161,100,235,64,194,9,226, +44,166,1,41,221,153,226,235,118,120,121,58,72,197,209,63,71,69,76,15,34, +164,73,244,171,112,39,246,223,104,169,18,125,42,220,9,253,159,217,38,68, +159,104,134,207,236,254,201,18,36,250,134,207,236,254,201,50,36,251,68,54, +127,99,246,200,145,39,212,54,127,99,246,200,145,39,218,33,179,251,131,200, +147,234,27,63,184,81,137,62,149,110,4,254,219,237,20,98,79,165,91,129,63, +179,251,36,152,147,237,16,217,253,159,217,32,196,159,80,217,253,159,217,36, +196,159,104,134,207,236,126,217,6,36,250,134,207,236,126,217,6,36,251,68, +54,127,112,115,18,125,67,103,247,8,149,2,8,196,24,143,131,137,146,90,121, +35,162,44,140,35,102,160,226,100,235,138,89,18,102,13,10,82,68,200,151,106, +130,88,131,4,192,73,225,228,85,162,137,147,168,108,252,18,42,209,68,201, +212,54,126,89,23,104,162,100,245,17,230,207,193,34,237,20,76,158,162,60, +217,249,100,109,162,137,147,163,117,2,178,120,36,109,162,137,147,163,117,2, +178,121,100,101,162,137,147,165,91,129,63,4,140,180,81,50,116,171,112,39, +229,145,150,138,38,78,161,179,251,63,178,240,72,203,69,19,39,80,217,253, +159,217,121,100,109,162,137,147,212,71,155,63,179,251,47,4,141,180,81,50, +122,136,243,103,246,127,101,229,145,150,138,38,78,161,179,251,31,182,240, +72,203,69,19,39,80,217,253,143,219,121,100,109,162,137,147,212,71,155,63, +177,251,111,4,141,180,81,50,122,136,243,103,246,63,109,229,145,54,138,38, +78,161,179,251,133,90,40,153,61,68,121,179,251,132,196,128,31,80,217,248, +36,76,72,1,245,13,159,150,69,68,128,31,168,143,54,126,9,21,18,0,126,162,60, +217,249,100,100,72,1,244,110,160,86,79,4,140,137,0,62,141,212,10,201,229, +145,113,32,7,210,173,192,159,130,69,196,128,31,74,183,2,126,89,23,18,0,125, +67,103,246,127,101,224,145,113,32,7,212,54,127,103,246,94,89,25,18,0,126, +162,60,217,253,159,217,120,36,100,72,1,250,136,243,103,246,127,101,229,145, +113,32,7,212,54,127,99,246,222,9,23,18,0,125,67,103,246,63,109,229,145,145, +32,7,234,35,205,159,216,253,183,130,70,68,128,31,168,143,54,127,99,246,222, +89,17,18,0,125,67,103,247,9,137,0,63,81,30,108,254,224,130,115,240,98,66, +128,92,136,84,45,101,180,81,50,28,78,99,193,18,40,56,153,58,178,52,211,58, +17,46,134,133,41,34,164,75,164,104,156,52,52,199,37,222,232,206,66,64,207, +18,66,136,137,19,173,62,46,155,181,167,72,147,235,226,233,186,120,121,58, +226,157,214,111,84,76,73,36,109,24,72,130,100,112,200,178,76,157,124,92, +242,70,120,25,193,34,245,241,117,240,97,1,107,33,25,212,54,160,90,7,244,29, +24,38,66,254,223,215,125,119,215,126,232,190,43,226,67,244,1,250,193,125, +111,216,11,234,254,192,63,96,159,173,234,26,84,53,19,194,126,175,168,105, +80,212,79,8,234,26,84,53,19,193,156,20,144,83,52,167,20,52,198,109,24,18, +68,225,115,150,64,53,52,104,200,84,52,131,76,167,20,52,200,46,7,48,52,146, +132,102,57,33,165,139,168,209,154,32,104,220,193,189,214,27,16,209,176,23, +26,220,98,149,110,116,70,75,188,98,116,136,34,33,101,4,192,223,178,32,38,6, +144,18,67,72,1,58,67,0,100,95,74,17,159,217,31,210,132,103,246,58,251,33, +121,232,55,150,227,125,143,216,16,190,91,141,246,68,31,150,223,178,39,150, +223,177,251,0,244,135,97,37,32,24,132,104,24,66,161,175,164,202,134,140, +151,39,212,125,255,221,125,74,86,9,79,168,104,201,116,178,139,154,22,134, +145,72,51,93,18,116,64,145,13,39,82,34,33,38,73,76,132,185,4,185,187,198, +100,229,233,197,13,49,228,73,247,4,4,78,98,79,184,32,34,105,187,201,147, +154,185,187,200,147,165,233,197,13,50,230,239,82,98,151,167,20,52,206,145, +39,234,76,69,245,22,190,224,128,138,228,73,244,180,90,251,130,2,43,145,39, +234,76,76,243,155,51,162,68,159,88,230,204,234,145,39,234,76,67,240,38,67, +200,147,232,193,50,46,68,159,169,49,31,206,164,100,137,18,125,59,169,25,54, +68,159,169,49,51,200,109,38,73,42,68,159,88,134,210,100,147,100,73,250,147, +20,188,65,57,163,146,164,73,246,68,19,154,57,74,68,159,169,49,51,200,90, +209,34,9,205,28,159,34,79,172,66,214,137,16,78,104,228,121,18,125,154,24, +72,152,147,236,208,194,101,205,39,92,82,200,147,145,137,63,82,98,103,144, +181,162,68,19,154,57,60,196,159,88,133,173,18,32,156,209,201,166,36,253,73, +138,94,32,156,209,201,70,36,251,34,9,205,28,154,98,79,212,152,153,228,54, +147,36,148,98,79,172,67,105,50,73,102,36,253,73,136,254,117,35,36,24,147, +233,221,72,201,38,36,253,73,136,126,6,12,98,79,163,6,20,98,79,212,152,135, +224,76,135,49,39,209,130,100,89,137,63,82,98,103,156,217,157,6,36,250,199, +54,103,113,137,63,82,98,47,168,181,247,4,4,86,98,79,165,162,215,220,16,17, +57,137,62,205,12,36,166,238,173,194,2,201,217,161,132,236,167,20,52,210, +155,186,183,8,11,39,70,9,147,178,156,80,211,50,110,236,208,194,118,83,138, +26,102,77,221,24,38,78,202,113,67,76,54,186,195,245,38,34,188,17,145,23,55, +117,241,32,145,36,57,173,155,186,75,189,205,35,102,128,44,243,119,74,139, +144,113,243,221,36,77,21,38,144,210,161,168,158,35,230,144,192,154,42,77, +33,165,67,81,60,15,173,7,90,159,49,13,213,64,186,17,62,96,47,170,129,116, +33,165,64,202,113,36,226,134,70,110,234,220,32,44,157,163,222,72,244,64, +145,23,55,118,143,121,35,209,2,68,140,221,213,184,64,89,58,183,88,145,232, +129,34,46,110,234,221,98,71,162,4,136,153,80,50,156,80,211,22,79,90,38,105, +16,17,17,207,18,61,96,17,10,192,76,71,106,220,32,44,157,19,152,240,68,138, +17,193,30,137,195,39,65,51,8,224,143,65,54,22,46,103,68,112,71,162,112,200, +184,144,116,17,59,20,24,243,52,72,58,8,134,42,23,50,68,108,3,206,87,71,164, +0,142,73,57,132,41,42,72,225,107,4,167,212,52,100,191,92,83,161,163,37,250, +226,158,141,145,208,89,154,79,90,4,66,73,209,153,100,180,8,133,145,208,89, +158,36,169,35,34,17,244,145,198,247,60,137,114,26,97,57,162,4,206,137,116, +17,136,48,144,68,212,97,27,57,24,64,90,201,18,5,13,25,4,5,172,160,123,215, +138,62,46,121,35,60,117,18,233,27,70,18,32,10,200,212,75,175,139,166,233, +225,228,235,138,227,130,93,117,155,215,197,207,36,103,131,212,11,161,58, +226,186,110,234,220,32,44,157,148,226,134,153,19,119,101,56,161,166,88,156, +217,78,52,20,221,17,200,147,25,137,53,17,180,97,34,0,172,140,19,154,84,26, +145,0,86,68,90,40,152,2,178,22,160,93,8,69,19,18,98,37,210,94,100,108,144, +21,145,8,151,75,23,100,141,66,37,217,16,11,32,226,248,146,164,108,250,75, +204,141,146,28,217,24,177,33,50,66,72,128,92,6,66,161,164,235,226,231,146, +51,65,36,225,144,168,105,58,248,185,228,140,240,97,68,128,153,38,98,79,174, +179,122,248,185,228,140,241,214,129,132,150,12,73,245,214,111,95,23,60,145, +158,58,50,72,81,67,230,232,184,196,159,95,23,77,211,195,201,215,21,47,139, +166,233,225,228,50,200,211,76,229,2,201,25,149,241,67,102,138,52,146,16,30, +67,18,66,3,201,34,52,78,25,61,72,160,94,115,30,230,145,179,73,26,39,12,158, +164,81,33,144,78,25,61,72,160,94,115,30,230,145,179,72,200,39,12,158,164, +80,132,75,165,67,81,50,21,18,235,65,214,169,224,140,137,210,173,192,154,30, +8,200,157,67,102,66,84,11,71,169,20,19,209,139,162,158,207,15,39,73,24,186, +43,236,176,217,130,253,36,98,232,187,177,33,73,18,52,68,233,35,23,69,93, +136,26,98,116,145,139,162,158,146,160,95,73,24,186,37,12,72,5,16,64,145,10, +32,76,71,64,156,217,161,180,34,6,64,208,198,36,78,50,20,20,92,204,50,44, +147,32,134,226,17,114,33,202,134,129,107,192,202,232,160,180,104,166,135, +52,72,40,144,213,33,178,152,26,34,56,163,105,44,104,146,116,139,77,43,34, +98,57,38,116,72,179,60,93,97,206,56,52,240,242,56,163,168,34,81,57,178,153, +42,228,12,182,58,22,66,89,19,57,68,176,74,68,35,104,195,18,239,116,102,114, +94,100,104,228,100,49,238,140,203,42,60,145,35,104,181,146,113,161,10,80, +46,68,82,24,245,145,132,108,228,148,54,100,137,64,34,13,100,153,222,1,40,6, +33,223,20,84,19,34,95,23,76,130,153,6,103,208,43,64,141,41,130,104,17,112, +130,44,96, }; /* to convert a heap stridx to a token number, subtract * DUK_STRIDX_START_RESERVED and add DUK_TOK_START_RESERVED. */ -/* native functions: 128 */ -DUK_INTERNAL const duk_c_function duk_bi_native_functions[128] = { +/* native functions: 149 */ +DUK_INTERNAL const duk_c_function duk_bi_native_functions[149] = { duk_bi_array_constructor, duk_bi_array_constructor_is_array, duk_bi_array_prototype_concat, @@ -10151,10 +12175,17 @@ DUK_INTERNAL const duk_c_function duk_bi_native_functions[128] = { duk_bi_array_prototype_splice, duk_bi_array_prototype_to_string, duk_bi_array_prototype_unshift, + duk_bi_arraybuffer_constructor, + duk_bi_arraybuffer_isview, duk_bi_boolean_constructor, duk_bi_boolean_prototype_tostring_shared, + duk_bi_buffer_compare_shared, duk_bi_buffer_constructor, duk_bi_buffer_prototype_tostring_shared, + duk_bi_buffer_readfield, + duk_bi_buffer_slice_shared, + duk_bi_buffer_writefield, + duk_bi_dataview_constructor, duk_bi_date_constructor, duk_bi_date_constructor_now, duk_bi_date_constructor_parse, @@ -10175,9 +12206,11 @@ DUK_INTERNAL const duk_c_function duk_bi_native_functions[128] = { duk_bi_duktape_object_info, duk_bi_error_constructor_shared, duk_bi_error_prototype_filename_getter, + duk_bi_error_prototype_filename_setter, duk_bi_error_prototype_linenumber_getter, - duk_bi_error_prototype_nop_setter, + duk_bi_error_prototype_linenumber_setter, duk_bi_error_prototype_stack_getter, + duk_bi_error_prototype_stack_setter, duk_bi_error_prototype_to_string, duk_bi_function_constructor, duk_bi_function_prototype, @@ -10209,6 +12242,16 @@ DUK_INTERNAL const duk_c_function duk_bi_native_functions[128] = { duk_bi_math_object_onearg_shared, duk_bi_math_object_random, duk_bi_math_object_twoarg_shared, + duk_bi_nodejs_buffer_byte_length, + duk_bi_nodejs_buffer_concat, + duk_bi_nodejs_buffer_constructor, + duk_bi_nodejs_buffer_copy, + duk_bi_nodejs_buffer_fill, + duk_bi_nodejs_buffer_is_buffer, + duk_bi_nodejs_buffer_is_encoding, + duk_bi_nodejs_buffer_tojson, + duk_bi_nodejs_buffer_tostring, + duk_bi_nodejs_buffer_write, duk_bi_number_constructor, duk_bi_number_prototype_to_exponential, duk_bi_number_prototype_to_fixed, @@ -10263,68 +12306,96 @@ DUK_INTERNAL const duk_c_function duk_bi_native_functions[128] = { duk_bi_thread_resume, duk_bi_thread_yield, duk_bi_type_error_thrower, + duk_bi_typedarray_constructor, + duk_bi_typedarray_set, }; -DUK_INTERNAL const duk_uint8_t duk_builtins_data[1341] = { -105,195,74,136,77,40,105,44,9,124,104,45,3,3,72,0,71,225,65,165,168,33,243, -6,145,0,122,24,210,148,14,249,35,120,160,55,226,13,76,192,196,177,164,152, -22,192,4,202,52,147,72,152,0,169,70,146,105,11,0,23,40,210,77,32,96,3,37, -26,73,163,236,0,108,163,73,52,121,128,14,148,105,38,142,176,1,242,144,56, -208,254,84,6,166,82,242,80,210,246,1,250,67,72,144,15,232,13,44,96,47,162, -52,160,128,62,80,160,255,253,102,76,0,0,0,0,0,0,15,135,243,84,0,0,0,0,0,0, -15,7,243,124,64,153,132,18,49,2,38,48,64,200,7,153,64,227,48,26,103,3,13,0, -89,165,34,53,36,38,180,128,216,143,155,81,227,114,58,111,2,142,0,73,194,94, -56,202,167,33,209,195,114,70,206,209,26,58,36,100,228,145,131,130,69,204, -137,22,51,36,84,208,145,67,82,68,205,137,18,62,36,68,240,122,32,120,62,0,2, -87,61,39,255,254,9,46,24,0,10,31,224,29,13,91,40,0,9,101,137,32,0,48,197, -84,66,214,9,10,82,68,37,81,144,133,52,65,214,137,6,90,40,0,12,21,100,144, -69,114,64,213,202,0,3,2,86,36,5,96,160,0,63,254,16,37,135,91,98,25,242,192, -7,194,248,30,236,32,123,46,17,234,186,71,162,241,5,23,240,0,15,241,1,70,74, -3,8,249,49,3,204,185,15,35,3,231,137,121,240,163,254,0,46,224,18,7,248,192, -42,249,14,3,224,20,32,0,46,208,35,231,96,41,29,96,192,117,3,159,58,66,64, -232,10,3,156,45,14,96,194,57,67,87,156,129,231,206,48,51,240,0,23,16,25, -255,255,251,132,16,209,192,8,106,0,2,223,4,53,0,2,111,2,26,128,1,183,65,13, -64,1,27,129,7,224,0,45,176,131,255,255,241,73,252,0,91,77,103,193,254,64, -36,200,64,101,31,47,32,123,188,129,178,218,70,195,113,29,173,231,206,55,3, -71,19,129,168,0,11,93,196,141,103,34,53,92,208,212,116,35,157,213,13,55, -100,52,158,16,209,108,3,65,176,12,246,192,128,0,179,155,2,0,2,205,122,3,49, -221,2,151,248,0,7,249,64,147,35,4,249,17,8,0,11,220,68,2,155,248,172,184, -31,255,255,255,255,255,253,239,236,168,0,32,0,0,0,0,0,0,12,152,0,0,0,0,0,0, -31,15,236,120,0,0,0,0,0,0,30,15,236,136,0,0,0,0,0,0,30,31,224,7,249,128, -147,32,0,0,0,0,0,0,0,0,12,249,79,35,225,52,143,117,0,49,147,8,197,75,35,17, -56,130,159,248,1,176,197,136,194,23,254,96,138,128,63,206,4,153,32,0,0,0,0, -0,3,225,254,215,200,232,24,3,161,0,1,95,142,132,0,9,240,58,16,0,53,240,232, -64,1,23,163,161,0,5,77,142,132,0,25,52,58,16,0,116,200,225,30,227,192,94, -15,1,118,48,16,0,133,208,192,64,2,87,35,1,0,10,92,12,4,0,45,110,48,16,0, -197,176,192,64,3,86,163,1,0,14,90,12,4,0,61,102,48,16,1,5,144,192,64,4,86, -35,1,0,18,88,12,4,0,77,94,48,16,1,69,112,192,64,5,85,163,1,0,22,86,12,4,0, -93,86,50,5,80,217,21,35,69,0,24,84,13,20,0,101,78,52,190,0,52,166,26,95,0, -27,82,141,63,128,14,41,6,159,192,7,84,99,83,224,3,202,33,169,240,1,245,8, -209,64,8,20,3,69,0,33,79,141,47,128,17,39,134,151,192,8,211,163,79,224,4, -137,193,167,240,2,84,192,192,64,9,146,227,69,0,39,21,31,192,0,63,208,24, -147,4,12,0,32,41,56,72,240,60,100,148,100,140,100,132,128,0,0,0,0,0,0,0,0, -210,172,228,74,52,17,242,210,1,83,252,0,3,253,33,81,132,11,69,144,24,166, -229,69,37,23,39,41,40,57,65,72,47,146,176,10,175,224,0,159,234,4,140,41,18, -44,128,192,10,191,224,0,159,235,4,140,41,10,44,128,192,10,207,224,0,159, -236,4,140,41,2,44,128,192,10,223,224,0,159,237,4,140,40,250,44,128,192,10, -239,224,0,159,238,4,140,40,242,44,128,192,10,255,224,0,159,239,4,140,40, -234,44,128,192,7,255,228,34,160,52,171,138,69,133,95,130,160,34,96,11,42, -218,221,216,181,129,32,34,32,119,156,253,127,33,23,115,31,161,224,127,65, -21,178,163,138,251,159,161,160,7,114,147,10,189,229,237,159,161,96,12,22, -162,42,125,144,132,160,33,32,102,157,191,179,79,80,115,31,160,224,102,157, -191,179,79,80,123,31,164,130,71,34,5,28,160,0,40,4,114,128,1,31,209,202,0, -6,126,73,65,245,28,160,0,135,196,114,128,2,158,209,202,0,12,122,71,40,0,57, -229,28,160,1,7,132,85,227,186,50,241,217,37,32,0,39,84,128,29,17,202,0,18, -115,71,40,0,81,201,28,160,1,103,20,114,128,6,7,255,224,4,195,63,65,193,1, -130,255,248,0,11,255,224,0,31,255,138,52,128,0,0,0,0,1,219,134,128,3,57, -192,71,72,4,229,0,29,99,140,201,72,50,31,32,196,144,131,2,49,225,121,16, -240,184,132,120,82,64,65,102,252,0,233,239,200,20,62,176,78,248,0,255,148, -0,5,163,240,0,15,249,192,9,242,38,16,0,23,184,152,5,171,240,0,15,250,64,9, -242,200,16,0,23,187,32,5,179,240,0,15,250,194,15,72,0,0,0,0,0,0,0,64,15, -201,4,195,187,126,226,4,200,68,18,162,16,72,134,60,35,67,31,0,1,25,161,143, -128,1,8,144,199,192,0,196,40,99,224,0,130,4,49,240,0,84,255,252,36,100,16, -184,155,250,226,217,150,47,46,91,249,34,224,139,229,229,203,127,36,26,119, -32,203,203,150,254,72,52,97,221,147,102,157,217,192, +DUK_INTERNAL const duk_uint8_t duk_builtins_data[1955] = { +105,195,75,32,121,40,105,53,14,252,104,54,8,131,72,0,115,225,65,165,244,55, +243,6,145,32,210,24,210,186,25,249,35,120,216,99,226,13,79,33,116,177,164, +180,44,192,4,202,52,150,220,24,0,169,70,146,219,123,0,23,40,210,91,110,96, +3,37,26,75,109,172,0,108,163,73,109,177,128,14,148,105,45,181,176,1,242, +144,56,209,36,94,6,167,133,98,80,211,28,1,250,67,72,168,67,232,13,46,192, +47,162,52,165,0,62,80,163,72,128,61,40,107,26,7,37,20,53,201,131,88,0,66, +134,185,48,98,80,215,38,11,96,0,138,26,228,193,76,0,69,67,92,152,37,128,6, +168,107,147,4,48,1,165,13,114,96,118,0,44,161,174,76,12,192,7,148,53,201, +129,88,1,26,134,165,80,130,80,31,255,241,69,224,0,0,0,0,0,0,124,63,174,32, +0,0,0,0,0,0,120,63,175,98,7,140,16,116,194,7,12,48,108,196,6,140,80,100, +198,6,12,112,92,200,5,140,149,192,202,91,204,181,184,204,91,76,213,176,206, +90,204,240,84,208,5,13,9,124,210,43,13,24,64,226,131,205,112,56,216,3,77, +152,48,218,130,205,184,40,220,130,77,216,32,222,129,205,248,24,224,129,78, +25,214,164,2,90,81,17,104,67,37,157,8,150,100,18,89,78,201,100,60,37,140, +244,150,35,226,88,79,201,96,71,37,125,20,122,188,138,62,0,2,165,70,39,255, +255,193,43,67,0,0,80,127,192,58,182,220,80,0,21,59,170,64,0,107,77,8,172, +181,146,176,202,138,187,59,42,204,200,170,182,146,168,218,80,0,26,155,97, +42,77,68,168,181,20,0,6,160,210,74,123,89,64,0,127,255,4,10,153,219,157,70, +163,185,130,140,228,10,43,160,40,141,228,161,184,18,132,226,64,161,127,128, +0,63,225,1,109,74,8,137,71,58,5,4,221,20,3,147,233,249,193,240,80,255,192, +6,120,2,64,127,195,0,173,28,56,20,96,80,128,0,206,192,143,167,64,164,156, +131,2,112,14,125,55,9,4,216,40,19,80,180,77,3,9,51,13,94,153,7,159,76,64, +207,192,0,102,0,103,255,255,242,240,67,73,112,33,168,0,12,180,16,212,0,10, +88,8,106,0,7,43,4,53,0,4,149,4,31,128,0,202,66,15,255,255,194,137,254,0,50, +135,227,224,127,196,2,87,132,17,82,143,24,10,44,96,36,240,4,147,64,146,119, +4,125,49,131,52,152,65,154,128,0,201,97,9,36,133,36,142,25,18,40,114,77,98, +17,33,137,68,130,45,17,247,240,71,159,193,29,127,8,0,12,113,252,32,0,49, +184,208,70,162,144,20,95,240,0,7,252,80,37,120,193,81,196,194,0,3,69,19,0, +81,191,197,140,192,255,255,255,255,255,255,239,127,140,64,1,0,0,0,0,0,0,0, +139,192,0,0,0,0,0,0,248,127,138,192,0,0,0,0,0,0,240,127,139,64,0,0,0,0,0,0, +240,255,0,31,241,128,149,224,0,0,0,0,0,0,0,0,13,71,98,37,25,128,148,86,48, +69,23,201,19,94,36,73,132,129,71,255,0,56,136,233,34,3,223,208,241,192,3, +254,56,18,188,128,0,0,0,0,0,15,135,251,104,228,128,135,18,4,0,6,26,72,16,0, +42,49,32,64,0,225,132,129,0,4,133,146,4,0,21,210,72,16,0,103,65,32,64,1, +220,228,100,162,146,130,20,74,8,72,248,64,2,33,3,225,0,9,131,143,132,0,42, +12,62,16,0,184,40,248,64,3,32,131,225,0,13,129,143,132,0,58,4,62,16,0,248, +8,248,64,4,32,3,225,0,17,127,143,132,0,73,252,62,16,1,55,232,248,64,5,31, +131,225,0,21,125,143,132,0,89,244,62,16,1,119,201,0,31,4,68,123,144,148,0, +97,236,66,80,1,151,169,10,248,0,211,208,133,124,0,109,230,66,254,0,56,242, +33,127,0,29,120,144,207,128,15,60,8,103,192,7,221,228,37,0,32,119,16,148,0, +133,218,66,190,0,68,236,33,95,0,35,117,144,191,128,18,58,136,95,192,9,92, +195,225,0,38,114,144,148,0,156,41,31,224,0,15,249,1,138,144,65,192,2,22,0, +88,16,46,24,77,208,148,103,4,102,252,102,244,128,0,0,0,0,0,0,0,0,220,111, +68,113,61,146,142,248,0,164,255,128,0,63,228,133,109,16,89,178,65,18,235, +153,25,150,220,184,188,180,230,6,32,209,205,0,20,175,240,0,39,252,160,77, +162,184,54,72,34,0,82,255,192,0,159,242,193,54,138,222,217,32,136,1,76,255, +0,2,127,204,4,218,43,115,100,130,32,5,55,252,0,9,255,52,19,104,173,173,146, +8,128,20,239,240,0,39,252,224,77,162,182,54,72,34,0,83,255,192,0,159,243, +193,54,138,214,217,32,136,0,255,255,33,177,1,165,92,82,44,42,252,21,1,175, +0,89,86,214,238,197,172,9,1,173,3,188,231,235,249,8,187,152,253,171,3,250, +8,173,149,28,87,220,253,169,0,59,148,152,85,239,47,108,253,167,0,96,181,17, +83,236,132,37,1,165,3,52,237,253,154,122,131,152,253,163,3,52,237,253,154, +122,131,216,253,38,130,129,25,234,5,0,1,103,40,20,0,9,154,160,80,0,54,98, +146,25,106,5,0,4,101,40,20,0,21,146,160,80,0,102,66,129,64,1,216,234,5,0,8, +99,39,47,49,83,215,152,138,73,0,1,97,168,129,132,160,80,0,150,10,129,64,2, +152,10,5,0,11,95,168,20,0,48,31,255,224,5,17,72,66,249,37,129,127,255,0,0, +191,255,128,0,63,255,197,31,192,0,0,0,0,0,80,196,64,8,26,112,17,169,0,154, +80,1,171,28,124,88,65,233,49,7,133,100,29,149,15,14,138,71,135,37,3,195,66, +114,5,77,252,0,243,178,40,25,200,48,101,30,0,127,210,128,0,85,31,192,0,31, +244,224,5,71,22,8,0,13,20,88,1,85,127,0,0,127,212,128,21,29,220,32,0,52,87, +112,5,89,252,0,1,255,86,16,166,64,0,0,0,0,0,0,2,0,170,72,38,29,219,247,16, +49,75,32,193,52,130,244,193,225,114,96,248,0,8,249,48,124,0,8,90,152,62,0, +6,44,76,31,0,4,21,166,15,128,2,147,255,252,38,212,16,184,155,250,226,217, +150,47,46,91,249,54,96,139,229,229,203,127,36,26,119,32,203,203,150,254,72, +52,97,221,147,102,157,217,192,10,191,248,0,157,4,72,15,250,224,1,154,140, +36,0,8,43,31,224,0,15,251,0,16,55,139,164,0,192,220,46,144,2,3,104,186,64, +12,77,130,233,0,33,53,139,164,0,200,212,46,144,2,35,72,186,64,8,205,2,233, +0,36,51,140,180,0,192,204,50,208,2,3,40,203,64,12,76,131,45,0,33,49,140, +180,0,200,196,50,208,2,35,8,203,64,8,204,3,45,0,36,7,255,248,1,82,101,16, +112,24,72,0,8,86,159,193,56,192,0,0,0,0,0,0,240,63,1,151,246,96,0,21,183, +240,78,48,0,0,0,0,0,0,60,15,192,101,253,168,0,5,113,252,19,140,0,0,0,0,0,0, +15,3,240,25,127,110,0,1,93,127,4,227,0,0,0,0,0,0,0,1,0,6,95,220,128,0,87, +159,193,56,192,0,0,0,0,0,0,0,64,1,151,247,96,0,21,247,240,78,48,0,0,0,0,0, +0,4,16,0,101,253,232,0,5,129,252,19,140,0,0,0,0,0,0,1,4,0,25,127,126,0,1, +97,127,4,227,0,0,0,0,0,0,0,65,0,6,95,224,128,0,88,159,193,56,192,0,0,0,0,0, +0,32,64,1,151,248,96,0,22,55,240,5,157,170,33,68,178,69,10,193,20,10,104, +79,138,36,0,12,31,248,160,88,154,23,66,100,93,32,2,9,129,116,128,0,165,197, +210,0,18,150,23,72,0,138,84,93,32,3,41,65,116,128,1,36,197,210,0,20,146,23, +72,0,146,68,93,32,3,73,1,116,128,1,163,197,210,0,22,142,23,72,0,34,52,93, +32,1,136,193,118,128,2,162,197,218,0,26,138,23,104,0,170,36,93,160,3,168, +129,150,33,198,90,0,32,134,25,104,0,10,20,101,160,1,40,65,150,128,8,160, +198,90,0,50,130,25,104,0,18,4,101,160,1,72,1,150,128,9,31,198,90,0,52,126, +25,104,0,25,244,101,160,1,103,193,150,128,2,30,198,90,0,24,122,25,136,0,41, +228,102,32,1,167,129,152,128,10,157,198,98,0,59,71,91,99,157,104,9,213,118, +39,5,8,159,20,40,0,10,109,90,19,81,132,39,151,32, }; #ifdef DUK_USE_BUILTIN_INITJS DUK_INTERNAL const duk_uint8_t duk_initjs_data[187] = { @@ -10340,108 +12411,141 @@ DUK_INTERNAL const duk_uint8_t duk_initjs_data[187] = { }; #endif /* DUK_USE_BUILTIN_INITJS */ #elif defined(DUK_USE_DOUBLE_BE) -DUK_INTERNAL const duk_uint8_t duk_strings_data[1943] = { -55,86,227,24,145,55,102,120,144,3,63,94,228,54,100,137,186,26,20,164,137, -186,50,11,164,109,77,215,5,61,35,106,3,25,110,8,22,158,130,38,163,8,217, -200,158,76,156,210,117,128,153,203,210,70,46,137,187,18,27,164,187,201,209, -130,100,55,91,70,4,145,63,66,231,44,128,105,187,41,197,13,49,122,8,196,24, -71,75,70,138,104,115,77,215,5,36,20,201,214,209,107,79,104,209,144,168,105, -6,207,251,209,104,209,125,212,227,66,127,235,191,239,232,180,90,52,95,69, -247,83,141,9,255,174,255,191,162,211,80,210,253,23,221,78,52,39,254,183, -254,254,139,72,105,126,139,238,167,26,19,255,91,255,127,69,166,129,191,69, -247,83,141,9,255,175,255,191,162,213,26,50,23,232,190,234,113,161,63,245, -115,119,86,227,118,83,138,26,98,9,110,48,86,22,148,160,152,22,82,70,46,137, -44,8,180,163,32,104,98,206,32,17,7,16,88,101,100,206,42,70,36,108,205,18, -74,140,33,196,230,60,2,152,146,33,38,230,8,36,79,182,251,65,156,151,24,200, -33,145,162,25,80,209,24,67,0,166,68,52,174,61,73,25,33,205,25,27,84,177, -195,234,220,1,144,105,99,135,217,16,17,17,208,72,199,179,60,93,100,146,49, -232,162,64,76,135,19,152,244,44,136,223,98,67,4,18,33,247,217,158,36,0,209, -190,156,13,26,201,21,111,165,67,64,180,100,145,62,250,32,45,100,33,55,214, -1,229,223,65,19,72,187,236,206,137,35,125,120,190,201,104,105,15,190,201, -212,136,136,125,246,160,137,27,83,239,171,37,200,218,159,125,168,34,192,61, -27,233,93,22,1,114,78,250,28,76,130,112,200,93,245,164,188,207,190,204,17, -49,38,109,246,160,93,8,119,185,13,153,34,96,208,165,36,85,190,206,32,17,6, -9,129,75,67,73,214,209,129,36,80,84,44,157,104,24,65,60,69,148,192,37,59, -179,60,93,110,207,15,39,73,24,186,39,232,232,169,129,228,18,6,120,146,20, -68,72,157,105,241,116,221,173,58,68,159,95,23,77,211,195,201,215,20,238, -179,122,162,98,73,35,104,194,68,19,35,134,69,146,100,235,226,231,146,51, -192,206,9,23,175,139,175,131,8,11,89,8,206,161,181,2,208,63,160,232,193,50, -23,246,254,187,235,190,187,247,69,241,95,18,31,160,15,214,11,235,126,192, -95,87,246,1,251,4,253,111,80,210,161,168,158,19,245,125,67,74,134,162,120, -71,80,210,161,168,158,12,224,164,130,153,165,56,161,166,51,104,192,146,39, -11,156,178,1,169,163,70,66,161,164,26,101,56,161,166,65,112,57,129,164,148, -35,49,201,13,44,93,70,140,209,3,70,230,13,238,176,216,134,141,128,184,214, -227,20,171,115,162,50,93,227,19,164,65,17,11,40,38,6,253,145,1,48,52,128, -146,26,64,9,210,24,3,34,250,80,140,254,200,254,148,35,63,177,215,217,11, -207,65,188,183,27,236,126,192,133,242,220,111,178,32,252,182,253,145,60, -182,253,143,216,7,164,59,9,41,0,196,35,64,194,21,13,125,38,84,52,100,185, -62,163,239,254,235,234,82,176,74,125,67,70,75,165,148,92,208,180,52,138,65, -154,232,147,162,4,136,105,58,145,17,9,50,74,100,37,200,37,205,222,51,39,47, -78,40,105,143,34,79,184,32,34,115,18,125,193,1,19,77,222,76,156,213,205, -222,68,157,47,78,40,105,151,55,122,147,20,189,56,161,166,116,137,63,82,98, -47,168,181,247,4,4,87,34,79,165,162,215,220,16,17,92,137,63,82,98,103,156, -217,157,18,36,250,199,54,103,84,137,63,82,98,31,129,50,30,68,159,70,9,145, -114,36,253,73,136,254,117,35,36,72,147,233,221,72,201,178,36,253,73,137, -158,67,105,50,73,82,36,250,196,54,147,36,155,34,79,212,152,165,226,9,205, -28,149,34,79,178,32,156,209,202,82,36,253,73,137,158,66,214,137,16,78,104, -228,249,18,125,98,22,180,72,130,115,71,35,200,147,236,208,194,68,196,159, -102,134,19,46,105,58,226,150,68,156,140,73,250,147,19,60,133,173,18,32,156, -209,201,230,36,250,196,45,104,145,4,230,142,77,49,39,234,76,82,241,4,230, -142,74,49,39,217,16,78,104,228,211,18,126,164,196,207,33,180,153,36,163,18, -125,98,27,73,146,75,49,39,234,76,71,243,169,25,32,196,159,78,234,70,73,49, -39,234,76,67,240,48,99,18,125,24,48,163,18,126,164,196,63,2,100,57,137,62, -140,19,34,204,73,250,147,19,60,230,204,232,49,39,214,57,179,59,140,73,250, -147,17,125,69,175,184,32,34,179,18,125,45,22,190,224,128,137,204,73,246, -104,97,37,55,117,110,16,22,78,205,12,39,101,56,161,166,148,221,213,184,64, -89,58,48,76,157,148,226,134,153,147,119,102,134,19,178,156,80,211,50,110, -232,193,50,118,83,138,26,97,181,214,31,169,49,21,224,140,136,185,187,175, -137,4,137,33,205,108,221,210,93,238,105,27,52,1,103,155,186,84,92,131,143, -158,233,34,104,169,52,134,149,13,68,241,31,52,134,4,209,82,105,13,42,26, -137,224,125,104,58,212,249,136,110,170,5,208,137,243,1,125,84,11,161,13,42, -6,83,137,39,20,50,51,119,86,225,1,100,237,30,242,71,162,4,136,185,187,180, -123,201,30,136,18,36,102,238,173,194,2,201,213,186,196,143,68,9,17,115,119, -86,235,18,61,16,36,68,202,129,148,226,134,152,178,122,209,51,72,128,136, -142,120,145,235,0,136,86,2,98,59,86,225,1,100,232,156,199,130,36,80,142,8, -244,78,25,58,9,152,71,4,122,9,176,177,115,58,35,130,61,19,134,69,196,131, -160,137,216,160,199,153,162,65,208,68,49,80,185,146,35,96,30,114,186,61,32, -4,114,73,204,33,73,82,71,11,88,37,62,161,163,37,250,226,157,13,25,47,215, -20,244,108,142,130,204,210,122,208,34,18,78,140,203,37,160,68,44,142,130, -204,241,37,73,25,16,143,164,142,55,185,228,75,144,211,9,205,16,38,116,75, -160,140,65,132,130,38,163,8,217,200,194,2,214,72,144,40,104,200,32,45,101, -3,222,188,81,241,115,201,25,227,168,151,72,218,48,145,0,86,70,162,93,124, -93,55,79,15,39,92,87,28,18,235,172,222,190,46,121,35,60,30,160,93,9,215,21, -211,119,86,225,1,100,236,167,20,52,200,155,187,41,197,13,50,196,230,202, -113,160,166,232,142,68,152,204,73,168,141,163,9,16,5,100,96,156,210,160, -212,136,2,178,34,209,68,192,21,144,181,2,232,66,40,152,147,17,46,146,243, -35,100,128,172,136,68,186,88,187,36,106,17,46,200,128,89,7,23,196,149,35, -103,210,94,100,108,144,230,200,197,137,9,146,18,68,2,224,50,21,13,39,95,23, -60,145,154,9,39,12,133,67,73,215,197,207,36,103,131,10,36,4,201,51,18,125, -117,155,215,197,207,36,103,142,180,12,36,176,98,79,174,179,122,248,185,228, -140,241,209,146,66,138,31,55,69,198,36,250,248,186,110,158,30,78,184,169, -124,93,55,79,15,33,150,70,154,103,40,22,72,204,175,138,27,52,81,164,144, -128,242,24,146,16,30,73,17,162,112,201,234,69,2,243,152,247,52,141,154,72, -209,56,100,245,34,137,12,130,112,201,234,69,2,243,152,247,52,141,154,70,65, -56,100,245,34,132,34,93,42,26,137,144,168,151,90,14,181,79,4,100,78,149, -110,4,208,240,70,68,234,27,50,18,160,90,61,72,160,158,140,93,20,246,120, -121,58,72,197,209,95,101,134,204,23,233,35,23,69,221,137,10,72,145,162,39, -73,24,186,42,236,64,211,19,164,140,93,20,244,149,2,250,72,197,209,40,98,64, -40,130,4,136,81,2,98,58,4,230,205,13,161,16,50,6,134,49,34,113,144,160,162, -230,97,145,100,153,4,55,16,139,145,14,84,52,11,94,6,87,69,5,163,69,52,57, -162,65,68,134,169,13,148,192,209,17,197,27,73,99,68,147,164,90,105,89,19, -17,201,51,162,69,153,226,235,14,113,193,167,135,145,197,29,65,18,85,200,25, -108,116,44,132,178,38,114,137,96,148,138,39,54,83,33,27,70,24,151,123,163, -51,146,243,35,71,35,33,143,116,102,89,81,228,137,27,69,172,147,141,8,82, -129,114,34,144,199,172,140,35,103,36,161,179,36,74,1,16,107,36,206,240,9, -64,49,14,248,162,160,153,18,248,186,100,20,200,51,62,129,90,4,105,76,19,64, -139,132,17,99, +DUK_INTERNAL const duk_uint8_t duk_strings_data[2624] = { +55,86,227,24,145,55,102,120,144,3,63,94,228,54,100,137,186,50,11,164,109, +77,215,5,61,35,106,206,149,110,4,254,219,237,58,8,196,24,103,74,183,2,127, +103,246,93,4,98,12,47,180,67,103,246,127,101,208,70,32,194,186,134,207,236, +254,203,160,140,65,133,246,136,108,254,199,237,186,8,196,24,87,80,217,253, +143,219,116,17,136,49,30,209,13,159,220,116,75,3,30,65,244,17,136,48,174, +209,13,159,220,116,17,136,48,158,161,179,251,142,130,49,6,17,209,130,96, +237,80,75,47,160,140,65,142,134,133,41,34,110,134,133,41,34,3,25,110,8,22, +158,130,38,163,8,217,200,158,76,156,210,117,128,153,203,210,70,46,137,187, +18,27,164,187,201,209,130,100,55,91,70,4,145,63,66,231,44,128,105,187,41, +197,13,49,122,8,196,24,71,75,70,138,104,115,77,215,5,36,20,201,214,209,107, +79,104,209,144,168,105,6,207,251,209,104,209,125,212,227,66,127,235,191, +239,232,180,90,52,95,69,247,83,141,9,255,174,255,191,162,211,80,210,253,23, +221,78,52,39,254,183,254,254,139,72,105,126,139,238,167,26,19,255,91,255, +127,69,166,129,191,69,247,83,141,9,255,175,255,191,162,213,26,50,23,232, +190,234,113,161,63,245,115,119,86,227,118,83,138,26,98,9,110,48,86,22,148, +160,152,22,82,70,46,137,44,8,180,163,32,104,98,206,32,17,7,16,88,101,100, +206,42,70,36,108,205,18,74,140,33,196,230,60,2,152,146,33,38,230,8,36,79, +182,251,65,156,151,24,200,33,145,162,25,80,209,24,67,0,166,68,52,174,61,73, +25,33,205,25,27,84,177,195,234,220,1,144,105,99,135,217,16,17,17,208,72, +199,179,60,93,100,146,49,232,162,64,76,135,19,152,244,44,136,223,98,67,4, +18,33,247,217,158,36,0,209,190,156,13,26,201,21,111,165,67,64,180,100,145, +62,250,32,45,100,33,55,214,1,229,223,65,19,72,187,236,206,137,35,125,120, +190,201,104,105,15,190,201,212,136,136,125,246,160,137,27,83,239,171,37, +200,218,159,125,168,34,192,61,27,233,93,22,1,114,78,250,28,76,130,112,200, +93,245,164,188,207,190,204,17,49,38,109,246,160,93,8,119,185,13,153,34,173, +246,113,0,136,48,76,10,90,26,78,182,140,9,34,130,161,100,235,64,194,9,226, +44,166,1,41,221,153,226,235,118,120,121,58,72,197,209,63,71,69,76,15,34, +164,73,244,171,112,39,246,223,104,169,18,125,42,220,9,253,159,217,38,68, +159,104,134,207,236,254,201,18,36,250,134,207,236,254,201,50,36,251,68,54, +127,99,246,200,145,39,212,54,127,99,246,200,145,39,218,33,179,251,131,200, +147,234,27,63,184,81,137,62,149,110,4,254,219,237,20,98,79,165,91,129,63, +179,251,36,152,147,237,16,217,253,159,217,32,196,159,80,217,253,159,217,36, +196,159,104,134,207,236,126,217,6,36,250,134,207,236,126,217,6,36,251,68, +54,127,112,115,18,125,67,103,247,8,149,2,8,196,24,143,131,137,146,90,121, +35,162,44,140,35,102,160,226,100,235,138,89,18,102,13,10,82,68,200,151,106, +130,88,131,4,192,73,225,228,85,162,137,147,168,108,252,18,42,209,68,201, +212,54,126,89,23,104,162,100,245,17,230,207,193,34,237,20,76,158,162,60, +217,249,100,109,162,137,147,163,117,2,178,120,36,109,162,137,147,163,117,2, +178,121,100,101,162,137,147,165,91,129,63,4,140,180,81,50,116,171,112,39, +229,145,150,138,38,78,161,179,251,63,178,240,72,203,69,19,39,80,217,253, +159,217,121,100,109,162,137,147,212,71,155,63,179,251,47,4,141,180,81,50, +122,136,243,103,246,127,101,229,145,150,138,38,78,161,179,251,31,182,240, +72,203,69,19,39,80,217,253,143,219,121,100,109,162,137,147,212,71,155,63, +177,251,111,4,141,180,81,50,122,136,243,103,246,63,109,229,145,54,138,38, +78,161,179,251,133,90,40,153,61,68,121,179,251,132,196,128,31,80,217,248, +36,76,72,1,245,13,159,150,69,68,128,31,168,143,54,126,9,21,18,0,126,162,60, +217,249,100,100,72,1,244,110,160,86,79,4,140,137,0,62,141,212,10,201,229, +145,113,32,7,210,173,192,159,130,69,196,128,31,74,183,2,126,89,23,18,0,125, +67,103,246,127,101,224,145,113,32,7,212,54,127,103,246,94,89,25,18,0,126, +162,60,217,253,159,217,120,36,100,72,1,250,136,243,103,246,127,101,229,145, +113,32,7,212,54,127,99,246,222,9,23,18,0,125,67,103,246,63,109,229,145,145, +32,7,234,35,205,159,216,253,183,130,70,68,128,31,168,143,54,127,99,246,222, +89,17,18,0,125,67,103,247,9,137,0,63,81,30,108,254,224,130,115,240,98,66, +128,92,136,84,45,101,180,81,50,28,78,99,193,18,40,56,153,58,178,52,211,58, +17,46,134,133,41,34,164,75,164,104,156,52,52,199,37,222,232,206,66,64,207, +18,66,136,137,19,173,62,46,155,181,167,72,147,235,226,233,186,120,121,58, +226,157,214,111,84,76,73,36,109,24,72,130,100,112,200,178,76,157,124,92, +242,70,120,25,193,34,245,241,117,240,97,1,107,33,25,212,54,160,90,7,244,29, +24,38,66,254,223,215,125,119,215,126,232,190,43,226,67,244,1,250,193,125, +111,216,11,234,254,192,63,96,159,173,234,26,84,53,19,194,126,175,168,105, +80,212,79,8,234,26,84,53,19,193,156,20,144,83,52,167,20,52,198,109,24,18, +68,225,115,150,64,53,52,104,200,84,52,131,76,167,20,52,200,46,7,48,52,146, +132,102,57,33,165,139,168,209,154,32,104,220,193,189,214,27,16,209,176,23, +26,220,98,149,110,116,70,75,188,98,116,136,34,33,101,4,192,223,178,32,38,6, +144,18,67,72,1,58,67,0,100,95,74,17,159,217,31,210,132,103,246,58,251,33, +121,232,55,150,227,125,143,216,16,190,91,141,246,68,31,150,223,178,39,150, +223,177,251,0,244,135,97,37,32,24,132,104,24,66,161,175,164,202,134,140, +151,39,212,125,255,221,125,74,86,9,79,168,104,201,116,178,139,154,22,134, +145,72,51,93,18,116,64,145,13,39,82,34,33,38,73,76,132,185,4,185,187,198, +100,229,233,197,13,49,228,73,247,4,4,78,98,79,184,32,34,105,187,201,147, +154,185,187,200,147,165,233,197,13,50,230,239,82,98,151,167,20,52,206,145, +39,234,76,69,245,22,190,224,128,138,228,73,244,180,90,251,130,2,43,145,39, +234,76,76,243,155,51,162,68,159,88,230,204,234,145,39,234,76,67,240,38,67, +200,147,232,193,50,46,68,159,169,49,31,206,164,100,137,18,125,59,169,25,54, +68,159,169,49,51,200,109,38,73,42,68,159,88,134,210,100,147,100,73,250,147, +20,188,65,57,163,146,164,73,246,68,19,154,57,74,68,159,169,49,51,200,90, +209,34,9,205,28,159,34,79,172,66,214,137,16,78,104,228,121,18,125,154,24, +72,152,147,236,208,194,101,205,39,92,82,200,147,145,137,63,82,98,103,144, +181,162,68,19,154,57,60,196,159,88,133,173,18,32,156,209,201,166,36,253,73, +138,94,32,156,209,201,70,36,251,34,9,205,28,154,98,79,212,152,153,228,54, +147,36,148,98,79,172,67,105,50,73,102,36,253,73,136,254,117,35,36,24,147, +233,221,72,201,38,36,253,73,136,126,6,12,98,79,163,6,20,98,79,212,152,135, +224,76,135,49,39,209,130,100,89,137,63,82,98,103,156,217,157,6,36,250,199, +54,103,113,137,63,82,98,47,168,181,247,4,4,86,98,79,165,162,215,220,16,17, +57,137,62,205,12,36,166,238,173,194,2,201,217,161,132,236,167,20,52,210, +155,186,183,8,11,39,70,9,147,178,156,80,211,50,110,236,208,194,118,83,138, +26,102,77,221,24,38,78,202,113,67,76,54,186,195,245,38,34,188,17,145,23,55, +117,241,32,145,36,57,173,155,186,75,189,205,35,102,128,44,243,119,74,139, +144,113,243,221,36,77,21,38,144,210,161,168,158,35,230,144,192,154,42,77, +33,165,67,81,60,15,173,7,90,159,49,13,213,64,186,17,62,96,47,170,129,116, +33,165,64,202,113,36,226,134,70,110,234,220,32,44,157,163,222,72,244,64, +145,23,55,118,143,121,35,209,2,68,140,221,213,184,64,89,58,183,88,145,232, +129,34,46,110,234,221,98,71,162,4,136,153,80,50,156,80,211,22,79,90,38,105, +16,17,17,207,18,61,96,17,10,192,76,71,106,220,32,44,157,19,152,240,68,138, +17,193,30,137,195,39,65,51,8,224,143,65,54,22,46,103,68,112,71,162,112,200, +184,144,116,17,59,20,24,243,52,72,58,8,134,42,23,50,68,108,3,206,87,71,164, +0,142,73,57,132,41,42,72,225,107,4,167,212,52,100,191,92,83,161,163,37,250, +226,158,141,145,208,89,154,79,90,4,66,73,209,153,100,180,8,133,145,208,89, +158,36,169,35,34,17,244,145,198,247,60,137,114,26,97,57,162,4,206,137,116, +17,136,48,144,68,212,97,27,57,24,64,90,201,18,5,13,25,4,5,172,160,123,215, +138,62,46,121,35,60,117,18,233,27,70,18,32,10,200,212,75,175,139,166,233, +225,228,235,138,227,130,93,117,155,215,197,207,36,103,131,212,11,161,58, +226,186,110,234,220,32,44,157,148,226,134,153,19,119,101,56,161,166,88,156, +217,78,52,20,221,17,200,147,25,137,53,17,180,97,34,0,172,140,19,154,84,26, +145,0,86,68,90,40,152,2,178,22,160,93,8,69,19,18,98,37,210,94,100,108,144, +21,145,8,151,75,23,100,141,66,37,217,16,11,32,226,248,146,164,108,250,75, +204,141,146,28,217,24,177,33,50,66,72,128,92,6,66,161,164,235,226,231,146, +51,65,36,225,144,168,105,58,248,185,228,140,240,97,68,128,153,38,98,79,174, +179,122,248,185,228,140,241,214,129,132,150,12,73,245,214,111,95,23,60,145, +158,58,50,72,81,67,230,232,184,196,159,95,23,77,211,195,201,215,21,47,139, +166,233,225,228,50,200,211,76,229,2,201,25,149,241,67,102,138,52,146,16,30, +67,18,66,3,201,34,52,78,25,61,72,160,94,115,30,230,145,179,73,26,39,12,158, +164,81,33,144,78,25,61,72,160,94,115,30,230,145,179,72,200,39,12,158,164, +80,132,75,165,67,81,50,21,18,235,65,214,169,224,140,137,210,173,192,154,30, +8,200,157,67,102,66,84,11,71,169,20,19,209,139,162,158,207,15,39,73,24,186, +43,236,176,217,130,253,36,98,232,187,177,33,73,18,52,68,233,35,23,69,93, +136,26,98,116,145,139,162,158,146,160,95,73,24,186,37,12,72,5,16,64,145,10, +32,76,71,64,156,217,161,180,34,6,64,208,198,36,78,50,20,20,92,204,50,44, +147,32,134,226,17,114,33,202,134,129,107,192,202,232,160,180,104,166,135, +52,72,40,144,213,33,178,152,26,34,56,163,105,44,104,146,116,139,77,43,34, +98,57,38,116,72,179,60,93,97,206,56,52,240,242,56,163,168,34,81,57,178,153, +42,228,12,182,58,22,66,89,19,57,68,176,74,68,35,104,195,18,239,116,102,114, +94,100,104,228,100,49,238,140,203,42,60,145,35,104,181,146,113,161,10,80, +46,68,82,24,245,145,132,108,228,148,54,100,137,64,34,13,100,153,222,1,40,6, +33,223,20,84,19,34,95,23,76,130,153,6,103,208,43,64,141,41,130,104,17,112, +130,44,96, }; /* to convert a heap stridx to a token number, subtract * DUK_STRIDX_START_RESERVED and add DUK_TOK_START_RESERVED. */ -/* native functions: 128 */ -DUK_INTERNAL const duk_c_function duk_bi_native_functions[128] = { +/* native functions: 149 */ +DUK_INTERNAL const duk_c_function duk_bi_native_functions[149] = { duk_bi_array_constructor, duk_bi_array_constructor_is_array, duk_bi_array_prototype_concat, @@ -10458,10 +12562,17 @@ DUK_INTERNAL const duk_c_function duk_bi_native_functions[128] = { duk_bi_array_prototype_splice, duk_bi_array_prototype_to_string, duk_bi_array_prototype_unshift, + duk_bi_arraybuffer_constructor, + duk_bi_arraybuffer_isview, duk_bi_boolean_constructor, duk_bi_boolean_prototype_tostring_shared, + duk_bi_buffer_compare_shared, duk_bi_buffer_constructor, duk_bi_buffer_prototype_tostring_shared, + duk_bi_buffer_readfield, + duk_bi_buffer_slice_shared, + duk_bi_buffer_writefield, + duk_bi_dataview_constructor, duk_bi_date_constructor, duk_bi_date_constructor_now, duk_bi_date_constructor_parse, @@ -10482,9 +12593,11 @@ DUK_INTERNAL const duk_c_function duk_bi_native_functions[128] = { duk_bi_duktape_object_info, duk_bi_error_constructor_shared, duk_bi_error_prototype_filename_getter, + duk_bi_error_prototype_filename_setter, duk_bi_error_prototype_linenumber_getter, - duk_bi_error_prototype_nop_setter, + duk_bi_error_prototype_linenumber_setter, duk_bi_error_prototype_stack_getter, + duk_bi_error_prototype_stack_setter, duk_bi_error_prototype_to_string, duk_bi_function_constructor, duk_bi_function_prototype, @@ -10516,6 +12629,16 @@ DUK_INTERNAL const duk_c_function duk_bi_native_functions[128] = { duk_bi_math_object_onearg_shared, duk_bi_math_object_random, duk_bi_math_object_twoarg_shared, + duk_bi_nodejs_buffer_byte_length, + duk_bi_nodejs_buffer_concat, + duk_bi_nodejs_buffer_constructor, + duk_bi_nodejs_buffer_copy, + duk_bi_nodejs_buffer_fill, + duk_bi_nodejs_buffer_is_buffer, + duk_bi_nodejs_buffer_is_encoding, + duk_bi_nodejs_buffer_tojson, + duk_bi_nodejs_buffer_tostring, + duk_bi_nodejs_buffer_write, duk_bi_number_constructor, duk_bi_number_prototype_to_exponential, duk_bi_number_prototype_to_fixed, @@ -10570,68 +12693,96 @@ DUK_INTERNAL const duk_c_function duk_bi_native_functions[128] = { duk_bi_thread_resume, duk_bi_thread_yield, duk_bi_type_error_thrower, + duk_bi_typedarray_constructor, + duk_bi_typedarray_set, }; -DUK_INTERNAL const duk_uint8_t duk_builtins_data[1341] = { -105,195,74,136,77,40,105,44,9,124,104,45,3,3,72,0,71,225,65,165,168,33,243, -6,145,0,122,24,210,148,14,249,35,120,160,55,226,13,76,192,196,177,164,152, -22,192,4,202,52,147,72,152,0,169,70,146,105,11,0,23,40,210,77,32,96,3,37, -26,73,163,236,0,108,163,73,52,121,128,14,148,105,38,142,176,1,242,144,56, -208,254,84,6,166,82,242,80,210,246,1,250,67,72,144,15,232,13,44,96,47,162, -52,160,128,62,80,160,255,253,102,76,7,255,128,0,0,0,0,0,3,84,7,255,0,0,0,0, -0,0,3,124,64,153,132,18,49,2,38,48,64,200,7,153,64,227,48,26,103,3,13,0,89, -165,34,53,36,38,180,128,216,143,155,81,227,114,58,111,2,142,0,73,194,94,56, -202,167,33,209,195,114,70,206,209,26,58,36,100,228,145,131,130,69,204,137, -22,51,36,84,208,145,67,82,68,205,137,18,62,36,68,240,122,32,120,62,0,2,87, -61,39,255,254,9,46,24,0,10,31,224,29,13,91,40,0,9,101,137,32,0,48,197,84, -66,214,9,10,82,68,37,81,144,133,52,65,214,137,6,90,40,0,12,21,100,144,69, -114,64,213,202,0,3,2,86,36,5,96,160,0,63,254,16,37,135,91,98,25,242,192,7, -194,248,30,236,32,123,46,17,234,186,71,162,241,5,23,240,0,15,241,1,70,74,3, -8,249,49,3,204,185,15,35,3,231,137,121,240,163,254,0,46,224,18,7,248,192, -42,249,14,3,224,20,32,0,46,208,35,231,96,41,29,96,192,117,3,159,58,66,64, -232,10,3,156,45,14,96,194,57,67,87,156,129,231,206,48,51,240,0,23,16,25, -255,255,251,132,16,209,192,8,106,0,2,223,4,53,0,2,111,2,26,128,1,183,65,13, -64,1,27,129,7,224,0,45,176,131,255,255,241,73,252,0,91,77,103,193,254,64, -36,200,64,101,31,47,32,123,188,129,178,218,70,195,113,29,173,231,206,55,3, -71,19,129,168,0,11,93,196,141,103,34,53,92,208,212,116,35,157,213,13,55, -100,52,158,16,209,108,3,65,176,12,246,192,128,0,179,155,2,0,2,205,122,3,49, -221,2,151,248,0,7,249,64,147,35,4,249,17,8,0,11,220,68,2,155,248,172,184, -15,253,255,255,255,255,255,255,236,168,0,0,0,0,0,0,0,0,44,152,15,255,0,0,0, -0,0,0,12,120,15,254,0,0,0,0,0,0,12,136,31,254,0,0,0,0,0,0,0,7,249,128,147, -32,0,0,0,0,0,0,0,0,12,249,79,35,225,52,143,117,0,49,147,8,197,75,35,17,56, -130,159,248,1,176,197,136,194,23,254,96,138,128,63,206,4,153,33,255,224,0, -0,0,0,0,2,215,200,232,24,3,161,0,1,95,142,132,0,9,240,58,16,0,53,240,232, -64,1,23,163,161,0,5,77,142,132,0,25,52,58,16,0,116,200,225,30,227,192,94, -15,1,118,48,16,0,133,208,192,64,2,87,35,1,0,10,92,12,4,0,45,110,48,16,0, -197,176,192,64,3,86,163,1,0,14,90,12,4,0,61,102,48,16,1,5,144,192,64,4,86, -35,1,0,18,88,12,4,0,77,94,48,16,1,69,112,192,64,5,85,163,1,0,22,86,12,4,0, -93,86,50,5,80,217,21,35,69,0,24,84,13,20,0,101,78,52,190,0,52,166,26,95,0, -27,82,141,63,128,14,41,6,159,192,7,84,99,83,224,3,202,33,169,240,1,245,8, -209,64,8,20,3,69,0,33,79,141,47,128,17,39,134,151,192,8,211,163,79,224,4, -137,193,167,240,2,84,192,192,64,9,146,227,69,0,39,21,31,192,0,63,208,24, -147,4,12,0,32,41,56,72,240,60,100,148,100,140,100,132,128,0,0,0,0,0,0,0,0, -210,172,228,74,52,17,242,210,1,83,252,0,3,253,33,81,132,11,69,144,24,166, -229,69,37,23,39,41,40,57,65,72,47,146,176,10,175,224,0,159,234,4,140,41,18, -44,128,192,10,191,224,0,159,235,4,140,41,10,44,128,192,10,207,224,0,159, -236,4,140,41,2,44,128,192,10,223,224,0,159,237,4,140,40,250,44,128,192,10, -239,224,0,159,238,4,140,40,242,44,128,192,10,255,224,0,159,239,4,140,40, -234,44,128,192,7,255,228,34,160,32,2,223,133,69,138,43,180,162,96,32,1,53, -216,221,218,170,139,34,32,31,243,23,33,127,125,28,247,161,224,31,251,138, -163,178,149,193,127,33,160,31,237,229,189,138,147,114,135,33,96,32,4,144, -253,170,34,22,140,33,32,31,243,80,79,51,63,157,230,160,224,31,251,80,79,51, -63,157,230,164,130,71,34,5,28,160,0,40,4,114,128,1,31,209,202,0,6,126,73, -65,245,28,160,0,135,196,114,128,2,158,209,202,0,12,122,71,40,0,57,229,28, -160,1,7,132,85,227,186,50,241,217,37,32,0,39,84,128,29,17,202,0,18,115,71, -40,0,81,201,28,160,1,103,20,114,128,6,7,255,224,4,195,63,65,193,1,130,255, -248,0,11,255,224,0,31,255,138,52,128,129,135,218,0,0,0,0,0,3,57,192,71,72, -4,229,0,29,99,140,201,72,50,31,32,196,144,131,2,49,225,121,16,240,184,132, -120,82,64,65,102,252,0,233,239,200,20,62,176,78,248,0,255,148,0,5,163,240, -0,15,249,192,9,242,38,16,0,23,184,152,5,171,240,0,15,250,64,9,242,200,16,0, -23,187,32,5,179,240,0,15,250,194,15,72,64,0,0,0,0,0,0,0,15,201,4,195,187, -126,226,4,200,68,18,162,16,72,134,60,35,67,31,0,1,25,161,143,128,1,8,144, -199,192,0,196,40,99,224,0,130,4,49,240,0,84,255,252,36,100,16,184,155,250, -226,217,150,47,46,91,249,34,224,139,229,229,203,127,36,26,119,32,203,203, -150,254,72,52,97,221,147,102,157,217,192, +DUK_INTERNAL const duk_uint8_t duk_builtins_data[1955] = { +105,195,75,32,121,40,105,53,14,252,104,54,8,131,72,0,115,225,65,165,244,55, +243,6,145,32,210,24,210,186,25,249,35,120,216,99,226,13,79,33,116,177,164, +180,44,192,4,202,52,150,220,24,0,169,70,146,219,123,0,23,40,210,91,110,96, +3,37,26,75,109,172,0,108,163,73,109,177,128,14,148,105,45,181,176,1,242, +144,56,209,36,94,6,167,133,98,80,211,28,1,250,67,72,168,67,232,13,46,192, +47,162,52,165,0,62,80,163,72,128,61,40,107,26,7,37,20,53,201,131,88,0,66, +134,185,48,98,80,215,38,11,96,0,138,26,228,193,76,0,69,67,92,152,37,128,6, +168,107,147,4,48,1,165,13,114,96,118,0,44,161,174,76,12,192,7,148,53,201, +129,88,1,26,134,165,80,130,80,31,255,241,69,224,63,252,0,0,0,0,0,0,46,32, +63,248,0,0,0,0,0,0,47,98,7,140,16,116,194,7,12,48,108,196,6,140,80,100,198, +6,12,112,92,200,5,140,149,192,202,91,204,181,184,204,91,76,213,176,206,90, +204,240,84,208,5,13,9,124,210,43,13,24,64,226,131,205,112,56,216,3,77,152, +48,218,130,205,184,40,220,130,77,216,32,222,129,205,248,24,224,129,78,25, +214,164,2,90,81,17,104,67,37,157,8,150,100,18,89,78,201,100,60,37,140,244, +150,35,226,88,79,201,96,71,37,125,20,122,188,138,62,0,2,165,70,39,255,255, +193,43,67,0,0,80,127,192,58,182,220,80,0,21,59,170,64,0,107,77,8,172,181, +146,176,202,138,187,59,42,204,200,170,182,146,168,218,80,0,26,155,97,42,77, +68,168,181,20,0,6,160,210,74,123,89,64,0,127,255,4,10,153,219,157,70,163, +185,130,140,228,10,43,160,40,141,228,161,184,18,132,226,64,161,127,128,0, +63,225,1,109,74,8,137,71,58,5,4,221,20,3,147,233,249,193,240,80,255,192,6, +120,2,64,127,195,0,173,28,56,20,96,80,128,0,206,192,143,167,64,164,156,131, +2,112,14,125,55,9,4,216,40,19,80,180,77,3,9,51,13,94,153,7,159,76,64,207, +192,0,102,0,103,255,255,242,240,67,73,112,33,168,0,12,180,16,212,0,10,88,8, +106,0,7,43,4,53,0,4,149,4,31,128,0,202,66,15,255,255,194,137,254,0,50,135, +227,224,127,196,2,87,132,17,82,143,24,10,44,96,36,240,4,147,64,146,119,4, +125,49,131,52,152,65,154,128,0,201,97,9,36,133,36,142,25,18,40,114,77,98, +17,33,137,68,130,45,17,247,240,71,159,193,29,127,8,0,12,113,252,32,0,49, +184,208,70,162,144,20,95,240,0,7,252,80,37,120,193,81,196,194,0,3,69,19,0, +81,191,197,140,192,127,239,255,255,255,255,255,255,140,64,0,0,0,0,0,0,0,1, +139,192,127,248,0,0,0,0,0,0,138,192,127,240,0,0,0,0,0,0,139,64,255,240,0,0, +0,0,0,0,0,31,241,128,149,224,0,0,0,0,0,0,0,0,13,71,98,37,25,128,148,86,48, +69,23,201,19,94,36,73,132,129,71,255,0,56,136,233,34,3,223,208,241,192,3, +254,56,18,188,135,255,128,0,0,0,0,0,11,104,228,128,135,18,4,0,6,26,72,16,0, +42,49,32,64,0,225,132,129,0,4,133,146,4,0,21,210,72,16,0,103,65,32,64,1, +220,228,100,162,146,130,20,74,8,72,248,64,2,33,3,225,0,9,131,143,132,0,42, +12,62,16,0,184,40,248,64,3,32,131,225,0,13,129,143,132,0,58,4,62,16,0,248, +8,248,64,4,32,3,225,0,17,127,143,132,0,73,252,62,16,1,55,232,248,64,5,31, +131,225,0,21,125,143,132,0,89,244,62,16,1,119,201,0,31,4,68,123,144,148,0, +97,236,66,80,1,151,169,10,248,0,211,208,133,124,0,109,230,66,254,0,56,242, +33,127,0,29,120,144,207,128,15,60,8,103,192,7,221,228,37,0,32,119,16,148,0, +133,218,66,190,0,68,236,33,95,0,35,117,144,191,128,18,58,136,95,192,9,92, +195,225,0,38,114,144,148,0,156,41,31,224,0,15,249,1,138,144,65,192,2,22,0, +88,16,46,24,77,208,148,103,4,102,252,102,244,128,0,0,0,0,0,0,0,0,220,111, +68,113,61,146,142,248,0,164,255,128,0,63,228,133,109,16,89,178,65,18,235, +153,25,150,220,184,188,180,230,6,32,209,205,0,20,175,240,0,39,252,160,77, +162,184,54,72,34,0,82,255,192,0,159,242,193,54,138,222,217,32,136,1,76,255, +0,2,127,204,4,218,43,115,100,130,32,5,55,252,0,9,255,52,19,104,173,173,146, +8,128,20,239,240,0,39,252,224,77,162,182,54,72,34,0,83,255,192,0,159,243, +193,54,138,214,217,32,136,0,255,255,33,177,1,0,22,252,42,44,81,93,165,175, +1,0,9,174,198,238,213,84,89,173,0,255,152,185,11,251,232,231,189,171,0,255, +220,85,29,148,174,11,249,169,0,255,111,45,236,84,155,148,57,167,1,0,36,135, +237,81,16,180,97,165,0,255,154,130,121,153,252,239,53,163,0,255,218,130, +121,153,252,239,53,38,130,129,25,234,5,0,1,103,40,20,0,9,154,160,80,0,54, +98,146,25,106,5,0,4,101,40,20,0,21,146,160,80,0,102,66,129,64,1,216,234,5, +0,8,99,39,47,49,83,215,152,138,73,0,1,97,168,129,132,160,80,0,150,10,129, +64,2,152,10,5,0,11,95,168,20,0,48,31,255,224,5,17,72,66,249,37,129,127,255, +0,0,191,255,128,0,63,255,197,31,192,64,196,80,0,0,0,0,0,8,26,112,17,169,0, +154,80,1,171,28,124,88,65,233,49,7,133,100,29,149,15,14,138,71,135,37,3, +195,66,114,5,77,252,0,243,178,40,25,200,48,101,30,0,127,210,128,0,85,31, +192,0,31,244,224,5,71,22,8,0,13,20,88,1,85,127,0,0,127,212,128,21,29,220, +32,0,52,87,112,5,89,252,0,1,255,86,16,166,66,0,0,0,0,0,0,0,0,170,72,38,29, +219,247,16,49,75,32,193,52,130,244,193,225,114,96,248,0,8,249,48,124,0,8, +90,152,62,0,6,44,76,31,0,4,21,166,15,128,2,147,255,252,38,212,16,184,155, +250,226,217,150,47,46,91,249,54,96,139,229,229,203,127,36,26,119,32,203, +203,150,254,72,52,97,221,147,102,157,217,192,10,191,248,0,157,4,72,15,250, +224,1,154,140,36,0,8,43,31,224,0,15,251,0,16,55,139,164,0,192,220,46,144,2, +3,104,186,64,12,77,130,233,0,33,53,139,164,0,200,212,46,144,2,35,72,186,64, +8,205,2,233,0,36,51,140,180,0,192,204,50,208,2,3,40,203,64,12,76,131,45,0, +33,49,140,180,0,200,196,50,208,2,35,8,203,64,8,204,3,45,0,36,7,255,248,1, +82,101,16,112,24,72,0,8,86,159,193,56,192,63,240,0,0,0,0,0,0,1,151,246,96, +0,21,183,240,78,48,15,252,0,0,0,0,0,0,0,101,253,168,0,5,113,252,19,140,3, +255,0,0,0,0,0,0,0,25,127,110,0,1,93,127,4,227,1,0,0,0,0,0,0,0,0,6,95,220, +128,0,87,159,193,56,192,64,0,0,0,0,0,0,0,1,151,247,96,0,21,247,240,78,48, +16,4,0,0,0,0,0,0,0,101,253,232,0,5,129,252,19,140,4,1,0,0,0,0,0,0,0,25,127, +126,0,1,97,127,4,227,1,0,64,0,0,0,0,0,0,6,95,224,128,0,88,159,193,56,192, +64,32,0,0,0,0,0,0,1,151,248,96,0,22,55,240,5,157,170,33,68,178,69,10,193, +20,10,104,79,138,36,0,12,31,248,160,88,154,23,66,100,93,32,2,9,129,116,128, +0,165,197,210,0,18,150,23,72,0,138,84,93,32,3,41,65,116,128,1,36,197,210,0, +20,146,23,72,0,146,68,93,32,3,73,1,116,128,1,163,197,210,0,22,142,23,72,0, +34,52,93,32,1,136,193,118,128,2,162,197,218,0,26,138,23,104,0,170,36,93, +160,3,168,129,150,33,198,90,0,32,134,25,104,0,10,20,101,160,1,40,65,150, +128,8,160,198,90,0,50,130,25,104,0,18,4,101,160,1,72,1,150,128,9,31,198,90, +0,52,126,25,104,0,25,244,101,160,1,103,193,150,128,2,30,198,90,0,24,122,25, +136,0,41,228,102,32,1,167,129,152,128,10,157,198,98,0,59,71,91,99,157,104, +9,213,118,39,5,8,159,20,40,0,10,109,90,19,81,132,39,151,32, }; #ifdef DUK_USE_BUILTIN_INITJS DUK_INTERNAL const duk_uint8_t duk_initjs_data[187] = { @@ -10647,108 +12798,141 @@ DUK_INTERNAL const duk_uint8_t duk_initjs_data[187] = { }; #endif /* DUK_USE_BUILTIN_INITJS */ #elif defined(DUK_USE_DOUBLE_ME) -DUK_INTERNAL const duk_uint8_t duk_strings_data[1943] = { -55,86,227,24,145,55,102,120,144,3,63,94,228,54,100,137,186,26,20,164,137, -186,50,11,164,109,77,215,5,61,35,106,3,25,110,8,22,158,130,38,163,8,217, -200,158,76,156,210,117,128,153,203,210,70,46,137,187,18,27,164,187,201,209, -130,100,55,91,70,4,145,63,66,231,44,128,105,187,41,197,13,49,122,8,196,24, -71,75,70,138,104,115,77,215,5,36,20,201,214,209,107,79,104,209,144,168,105, -6,207,251,209,104,209,125,212,227,66,127,235,191,239,232,180,90,52,95,69, -247,83,141,9,255,174,255,191,162,211,80,210,253,23,221,78,52,39,254,183, -254,254,139,72,105,126,139,238,167,26,19,255,91,255,127,69,166,129,191,69, -247,83,141,9,255,175,255,191,162,213,26,50,23,232,190,234,113,161,63,245, -115,119,86,227,118,83,138,26,98,9,110,48,86,22,148,160,152,22,82,70,46,137, -44,8,180,163,32,104,98,206,32,17,7,16,88,101,100,206,42,70,36,108,205,18, -74,140,33,196,230,60,2,152,146,33,38,230,8,36,79,182,251,65,156,151,24,200, -33,145,162,25,80,209,24,67,0,166,68,52,174,61,73,25,33,205,25,27,84,177, -195,234,220,1,144,105,99,135,217,16,17,17,208,72,199,179,60,93,100,146,49, -232,162,64,76,135,19,152,244,44,136,223,98,67,4,18,33,247,217,158,36,0,209, -190,156,13,26,201,21,111,165,67,64,180,100,145,62,250,32,45,100,33,55,214, -1,229,223,65,19,72,187,236,206,137,35,125,120,190,201,104,105,15,190,201, -212,136,136,125,246,160,137,27,83,239,171,37,200,218,159,125,168,34,192,61, -27,233,93,22,1,114,78,250,28,76,130,112,200,93,245,164,188,207,190,204,17, -49,38,109,246,160,93,8,119,185,13,153,34,96,208,165,36,85,190,206,32,17,6, -9,129,75,67,73,214,209,129,36,80,84,44,157,104,24,65,60,69,148,192,37,59, -179,60,93,110,207,15,39,73,24,186,39,232,232,169,129,228,18,6,120,146,20, -68,72,157,105,241,116,221,173,58,68,159,95,23,77,211,195,201,215,20,238, -179,122,162,98,73,35,104,194,68,19,35,134,69,146,100,235,226,231,146,51, -192,206,9,23,175,139,175,131,8,11,89,8,206,161,181,2,208,63,160,232,193,50, -23,246,254,187,235,190,187,247,69,241,95,18,31,160,15,214,11,235,126,192, -95,87,246,1,251,4,253,111,80,210,161,168,158,19,245,125,67,74,134,162,120, -71,80,210,161,168,158,12,224,164,130,153,165,56,161,166,51,104,192,146,39, -11,156,178,1,169,163,70,66,161,164,26,101,56,161,166,65,112,57,129,164,148, -35,49,201,13,44,93,70,140,209,3,70,230,13,238,176,216,134,141,128,184,214, -227,20,171,115,162,50,93,227,19,164,65,17,11,40,38,6,253,145,1,48,52,128, -146,26,64,9,210,24,3,34,250,80,140,254,200,254,148,35,63,177,215,217,11, -207,65,188,183,27,236,126,192,133,242,220,111,178,32,252,182,253,145,60, -182,253,143,216,7,164,59,9,41,0,196,35,64,194,21,13,125,38,84,52,100,185, -62,163,239,254,235,234,82,176,74,125,67,70,75,165,148,92,208,180,52,138,65, -154,232,147,162,4,136,105,58,145,17,9,50,74,100,37,200,37,205,222,51,39,47, -78,40,105,143,34,79,184,32,34,115,18,125,193,1,19,77,222,76,156,213,205, -222,68,157,47,78,40,105,151,55,122,147,20,189,56,161,166,116,137,63,82,98, -47,168,181,247,4,4,87,34,79,165,162,215,220,16,17,92,137,63,82,98,103,156, -217,157,18,36,250,199,54,103,84,137,63,82,98,31,129,50,30,68,159,70,9,145, -114,36,253,73,136,254,117,35,36,72,147,233,221,72,201,178,36,253,73,137, -158,67,105,50,73,82,36,250,196,54,147,36,155,34,79,212,152,165,226,9,205, -28,149,34,79,178,32,156,209,202,82,36,253,73,137,158,66,214,137,16,78,104, -228,249,18,125,98,22,180,72,130,115,71,35,200,147,236,208,194,68,196,159, -102,134,19,46,105,58,226,150,68,156,140,73,250,147,19,60,133,173,18,32,156, -209,201,230,36,250,196,45,104,145,4,230,142,77,49,39,234,76,82,241,4,230, -142,74,49,39,217,16,78,104,228,211,18,126,164,196,207,33,180,153,36,163,18, -125,98,27,73,146,75,49,39,234,76,71,243,169,25,32,196,159,78,234,70,73,49, -39,234,76,67,240,48,99,18,125,24,48,163,18,126,164,196,63,2,100,57,137,62, -140,19,34,204,73,250,147,19,60,230,204,232,49,39,214,57,179,59,140,73,250, -147,17,125,69,175,184,32,34,179,18,125,45,22,190,224,128,137,204,73,246, -104,97,37,55,117,110,16,22,78,205,12,39,101,56,161,166,148,221,213,184,64, -89,58,48,76,157,148,226,134,153,147,119,102,134,19,178,156,80,211,50,110, -232,193,50,118,83,138,26,97,181,214,31,169,49,21,224,140,136,185,187,175, -137,4,137,33,205,108,221,210,93,238,105,27,52,1,103,155,186,84,92,131,143, -158,233,34,104,169,52,134,149,13,68,241,31,52,134,4,209,82,105,13,42,26, -137,224,125,104,58,212,249,136,110,170,5,208,137,243,1,125,84,11,161,13,42, -6,83,137,39,20,50,51,119,86,225,1,100,237,30,242,71,162,4,136,185,187,180, -123,201,30,136,18,36,102,238,173,194,2,201,213,186,196,143,68,9,17,115,119, -86,235,18,61,16,36,68,202,129,148,226,134,152,178,122,209,51,72,128,136, -142,120,145,235,0,136,86,2,98,59,86,225,1,100,232,156,199,130,36,80,142,8, -244,78,25,58,9,152,71,4,122,9,176,177,115,58,35,130,61,19,134,69,196,131, -160,137,216,160,199,153,162,65,208,68,49,80,185,146,35,96,30,114,186,61,32, -4,114,73,204,33,73,82,71,11,88,37,62,161,163,37,250,226,157,13,25,47,215, -20,244,108,142,130,204,210,122,208,34,18,78,140,203,37,160,68,44,142,130, -204,241,37,73,25,16,143,164,142,55,185,228,75,144,211,9,205,16,38,116,75, -160,140,65,132,130,38,163,8,217,200,194,2,214,72,144,40,104,200,32,45,101, -3,222,188,81,241,115,201,25,227,168,151,72,218,48,145,0,86,70,162,93,124, -93,55,79,15,39,92,87,28,18,235,172,222,190,46,121,35,60,30,160,93,9,215,21, -211,119,86,225,1,100,236,167,20,52,200,155,187,41,197,13,50,196,230,202, -113,160,166,232,142,68,152,204,73,168,141,163,9,16,5,100,96,156,210,160, -212,136,2,178,34,209,68,192,21,144,181,2,232,66,40,152,147,17,46,146,243, -35,100,128,172,136,68,186,88,187,36,106,17,46,200,128,89,7,23,196,149,35, -103,210,94,100,108,144,230,200,197,137,9,146,18,68,2,224,50,21,13,39,95,23, -60,145,154,9,39,12,133,67,73,215,197,207,36,103,131,10,36,4,201,51,18,125, -117,155,215,197,207,36,103,142,180,12,36,176,98,79,174,179,122,248,185,228, -140,241,209,146,66,138,31,55,69,198,36,250,248,186,110,158,30,78,184,169, -124,93,55,79,15,33,150,70,154,103,40,22,72,204,175,138,27,52,81,164,144, -128,242,24,146,16,30,73,17,162,112,201,234,69,2,243,152,247,52,141,154,72, -209,56,100,245,34,137,12,130,112,201,234,69,2,243,152,247,52,141,154,70,65, -56,100,245,34,132,34,93,42,26,137,144,168,151,90,14,181,79,4,100,78,149, -110,4,208,240,70,68,234,27,50,18,160,90,61,72,160,158,140,93,20,246,120, -121,58,72,197,209,95,101,134,204,23,233,35,23,69,221,137,10,72,145,162,39, -73,24,186,42,236,64,211,19,164,140,93,20,244,149,2,250,72,197,209,40,98,64, -40,130,4,136,81,2,98,58,4,230,205,13,161,16,50,6,134,49,34,113,144,160,162, -230,97,145,100,153,4,55,16,139,145,14,84,52,11,94,6,87,69,5,163,69,52,57, -162,65,68,134,169,13,148,192,209,17,197,27,73,99,68,147,164,90,105,89,19, -17,201,51,162,69,153,226,235,14,113,193,167,135,145,197,29,65,18,85,200,25, -108,116,44,132,178,38,114,137,96,148,138,39,54,83,33,27,70,24,151,123,163, -51,146,243,35,71,35,33,143,116,102,89,81,228,137,27,69,172,147,141,8,82, -129,114,34,144,199,172,140,35,103,36,161,179,36,74,1,16,107,36,206,240,9, -64,49,14,248,162,160,153,18,248,186,100,20,200,51,62,129,90,4,105,76,19,64, -139,132,17,99, +DUK_INTERNAL const duk_uint8_t duk_strings_data[2624] = { +55,86,227,24,145,55,102,120,144,3,63,94,228,54,100,137,186,50,11,164,109, +77,215,5,61,35,106,206,149,110,4,254,219,237,58,8,196,24,103,74,183,2,127, +103,246,93,4,98,12,47,180,67,103,246,127,101,208,70,32,194,186,134,207,236, +254,203,160,140,65,133,246,136,108,254,199,237,186,8,196,24,87,80,217,253, +143,219,116,17,136,49,30,209,13,159,220,116,75,3,30,65,244,17,136,48,174, +209,13,159,220,116,17,136,48,158,161,179,251,142,130,49,6,17,209,130,96, +237,80,75,47,160,140,65,142,134,133,41,34,110,134,133,41,34,3,25,110,8,22, +158,130,38,163,8,217,200,158,76,156,210,117,128,153,203,210,70,46,137,187, +18,27,164,187,201,209,130,100,55,91,70,4,145,63,66,231,44,128,105,187,41, +197,13,49,122,8,196,24,71,75,70,138,104,115,77,215,5,36,20,201,214,209,107, +79,104,209,144,168,105,6,207,251,209,104,209,125,212,227,66,127,235,191, +239,232,180,90,52,95,69,247,83,141,9,255,174,255,191,162,211,80,210,253,23, +221,78,52,39,254,183,254,254,139,72,105,126,139,238,167,26,19,255,91,255, +127,69,166,129,191,69,247,83,141,9,255,175,255,191,162,213,26,50,23,232, +190,234,113,161,63,245,115,119,86,227,118,83,138,26,98,9,110,48,86,22,148, +160,152,22,82,70,46,137,44,8,180,163,32,104,98,206,32,17,7,16,88,101,100, +206,42,70,36,108,205,18,74,140,33,196,230,60,2,152,146,33,38,230,8,36,79, +182,251,65,156,151,24,200,33,145,162,25,80,209,24,67,0,166,68,52,174,61,73, +25,33,205,25,27,84,177,195,234,220,1,144,105,99,135,217,16,17,17,208,72, +199,179,60,93,100,146,49,232,162,64,76,135,19,152,244,44,136,223,98,67,4, +18,33,247,217,158,36,0,209,190,156,13,26,201,21,111,165,67,64,180,100,145, +62,250,32,45,100,33,55,214,1,229,223,65,19,72,187,236,206,137,35,125,120, +190,201,104,105,15,190,201,212,136,136,125,246,160,137,27,83,239,171,37, +200,218,159,125,168,34,192,61,27,233,93,22,1,114,78,250,28,76,130,112,200, +93,245,164,188,207,190,204,17,49,38,109,246,160,93,8,119,185,13,153,34,173, +246,113,0,136,48,76,10,90,26,78,182,140,9,34,130,161,100,235,64,194,9,226, +44,166,1,41,221,153,226,235,118,120,121,58,72,197,209,63,71,69,76,15,34, +164,73,244,171,112,39,246,223,104,169,18,125,42,220,9,253,159,217,38,68, +159,104,134,207,236,254,201,18,36,250,134,207,236,254,201,50,36,251,68,54, +127,99,246,200,145,39,212,54,127,99,246,200,145,39,218,33,179,251,131,200, +147,234,27,63,184,81,137,62,149,110,4,254,219,237,20,98,79,165,91,129,63, +179,251,36,152,147,237,16,217,253,159,217,32,196,159,80,217,253,159,217,36, +196,159,104,134,207,236,126,217,6,36,250,134,207,236,126,217,6,36,251,68, +54,127,112,115,18,125,67,103,247,8,149,2,8,196,24,143,131,137,146,90,121, +35,162,44,140,35,102,160,226,100,235,138,89,18,102,13,10,82,68,200,151,106, +130,88,131,4,192,73,225,228,85,162,137,147,168,108,252,18,42,209,68,201, +212,54,126,89,23,104,162,100,245,17,230,207,193,34,237,20,76,158,162,60, +217,249,100,109,162,137,147,163,117,2,178,120,36,109,162,137,147,163,117,2, +178,121,100,101,162,137,147,165,91,129,63,4,140,180,81,50,116,171,112,39, +229,145,150,138,38,78,161,179,251,63,178,240,72,203,69,19,39,80,217,253, +159,217,121,100,109,162,137,147,212,71,155,63,179,251,47,4,141,180,81,50, +122,136,243,103,246,127,101,229,145,150,138,38,78,161,179,251,31,182,240, +72,203,69,19,39,80,217,253,143,219,121,100,109,162,137,147,212,71,155,63, +177,251,111,4,141,180,81,50,122,136,243,103,246,63,109,229,145,54,138,38, +78,161,179,251,133,90,40,153,61,68,121,179,251,132,196,128,31,80,217,248, +36,76,72,1,245,13,159,150,69,68,128,31,168,143,54,126,9,21,18,0,126,162,60, +217,249,100,100,72,1,244,110,160,86,79,4,140,137,0,62,141,212,10,201,229, +145,113,32,7,210,173,192,159,130,69,196,128,31,74,183,2,126,89,23,18,0,125, +67,103,246,127,101,224,145,113,32,7,212,54,127,103,246,94,89,25,18,0,126, +162,60,217,253,159,217,120,36,100,72,1,250,136,243,103,246,127,101,229,145, +113,32,7,212,54,127,99,246,222,9,23,18,0,125,67,103,246,63,109,229,145,145, +32,7,234,35,205,159,216,253,183,130,70,68,128,31,168,143,54,127,99,246,222, +89,17,18,0,125,67,103,247,9,137,0,63,81,30,108,254,224,130,115,240,98,66, +128,92,136,84,45,101,180,81,50,28,78,99,193,18,40,56,153,58,178,52,211,58, +17,46,134,133,41,34,164,75,164,104,156,52,52,199,37,222,232,206,66,64,207, +18,66,136,137,19,173,62,46,155,181,167,72,147,235,226,233,186,120,121,58, +226,157,214,111,84,76,73,36,109,24,72,130,100,112,200,178,76,157,124,92, +242,70,120,25,193,34,245,241,117,240,97,1,107,33,25,212,54,160,90,7,244,29, +24,38,66,254,223,215,125,119,215,126,232,190,43,226,67,244,1,250,193,125, +111,216,11,234,254,192,63,96,159,173,234,26,84,53,19,194,126,175,168,105, +80,212,79,8,234,26,84,53,19,193,156,20,144,83,52,167,20,52,198,109,24,18, +68,225,115,150,64,53,52,104,200,84,52,131,76,167,20,52,200,46,7,48,52,146, +132,102,57,33,165,139,168,209,154,32,104,220,193,189,214,27,16,209,176,23, +26,220,98,149,110,116,70,75,188,98,116,136,34,33,101,4,192,223,178,32,38,6, +144,18,67,72,1,58,67,0,100,95,74,17,159,217,31,210,132,103,246,58,251,33, +121,232,55,150,227,125,143,216,16,190,91,141,246,68,31,150,223,178,39,150, +223,177,251,0,244,135,97,37,32,24,132,104,24,66,161,175,164,202,134,140, +151,39,212,125,255,221,125,74,86,9,79,168,104,201,116,178,139,154,22,134, +145,72,51,93,18,116,64,145,13,39,82,34,33,38,73,76,132,185,4,185,187,198, +100,229,233,197,13,49,228,73,247,4,4,78,98,79,184,32,34,105,187,201,147, +154,185,187,200,147,165,233,197,13,50,230,239,82,98,151,167,20,52,206,145, +39,234,76,69,245,22,190,224,128,138,228,73,244,180,90,251,130,2,43,145,39, +234,76,76,243,155,51,162,68,159,88,230,204,234,145,39,234,76,67,240,38,67, +200,147,232,193,50,46,68,159,169,49,31,206,164,100,137,18,125,59,169,25,54, +68,159,169,49,51,200,109,38,73,42,68,159,88,134,210,100,147,100,73,250,147, +20,188,65,57,163,146,164,73,246,68,19,154,57,74,68,159,169,49,51,200,90, +209,34,9,205,28,159,34,79,172,66,214,137,16,78,104,228,121,18,125,154,24, +72,152,147,236,208,194,101,205,39,92,82,200,147,145,137,63,82,98,103,144, +181,162,68,19,154,57,60,196,159,88,133,173,18,32,156,209,201,166,36,253,73, +138,94,32,156,209,201,70,36,251,34,9,205,28,154,98,79,212,152,153,228,54, +147,36,148,98,79,172,67,105,50,73,102,36,253,73,136,254,117,35,36,24,147, +233,221,72,201,38,36,253,73,136,126,6,12,98,79,163,6,20,98,79,212,152,135, +224,76,135,49,39,209,130,100,89,137,63,82,98,103,156,217,157,6,36,250,199, +54,103,113,137,63,82,98,47,168,181,247,4,4,86,98,79,165,162,215,220,16,17, +57,137,62,205,12,36,166,238,173,194,2,201,217,161,132,236,167,20,52,210, +155,186,183,8,11,39,70,9,147,178,156,80,211,50,110,236,208,194,118,83,138, +26,102,77,221,24,38,78,202,113,67,76,54,186,195,245,38,34,188,17,145,23,55, +117,241,32,145,36,57,173,155,186,75,189,205,35,102,128,44,243,119,74,139, +144,113,243,221,36,77,21,38,144,210,161,168,158,35,230,144,192,154,42,77, +33,165,67,81,60,15,173,7,90,159,49,13,213,64,186,17,62,96,47,170,129,116, +33,165,64,202,113,36,226,134,70,110,234,220,32,44,157,163,222,72,244,64, +145,23,55,118,143,121,35,209,2,68,140,221,213,184,64,89,58,183,88,145,232, +129,34,46,110,234,221,98,71,162,4,136,153,80,50,156,80,211,22,79,90,38,105, +16,17,17,207,18,61,96,17,10,192,76,71,106,220,32,44,157,19,152,240,68,138, +17,193,30,137,195,39,65,51,8,224,143,65,54,22,46,103,68,112,71,162,112,200, +184,144,116,17,59,20,24,243,52,72,58,8,134,42,23,50,68,108,3,206,87,71,164, +0,142,73,57,132,41,42,72,225,107,4,167,212,52,100,191,92,83,161,163,37,250, +226,158,141,145,208,89,154,79,90,4,66,73,209,153,100,180,8,133,145,208,89, +158,36,169,35,34,17,244,145,198,247,60,137,114,26,97,57,162,4,206,137,116, +17,136,48,144,68,212,97,27,57,24,64,90,201,18,5,13,25,4,5,172,160,123,215, +138,62,46,121,35,60,117,18,233,27,70,18,32,10,200,212,75,175,139,166,233, +225,228,235,138,227,130,93,117,155,215,197,207,36,103,131,212,11,161,58, +226,186,110,234,220,32,44,157,148,226,134,153,19,119,101,56,161,166,88,156, +217,78,52,20,221,17,200,147,25,137,53,17,180,97,34,0,172,140,19,154,84,26, +145,0,86,68,90,40,152,2,178,22,160,93,8,69,19,18,98,37,210,94,100,108,144, +21,145,8,151,75,23,100,141,66,37,217,16,11,32,226,248,146,164,108,250,75, +204,141,146,28,217,24,177,33,50,66,72,128,92,6,66,161,164,235,226,231,146, +51,65,36,225,144,168,105,58,248,185,228,140,240,97,68,128,153,38,98,79,174, +179,122,248,185,228,140,241,214,129,132,150,12,73,245,214,111,95,23,60,145, +158,58,50,72,81,67,230,232,184,196,159,95,23,77,211,195,201,215,21,47,139, +166,233,225,228,50,200,211,76,229,2,201,25,149,241,67,102,138,52,146,16,30, +67,18,66,3,201,34,52,78,25,61,72,160,94,115,30,230,145,179,73,26,39,12,158, +164,81,33,144,78,25,61,72,160,94,115,30,230,145,179,72,200,39,12,158,164, +80,132,75,165,67,81,50,21,18,235,65,214,169,224,140,137,210,173,192,154,30, +8,200,157,67,102,66,84,11,71,169,20,19,209,139,162,158,207,15,39,73,24,186, +43,236,176,217,130,253,36,98,232,187,177,33,73,18,52,68,233,35,23,69,93, +136,26,98,116,145,139,162,158,146,160,95,73,24,186,37,12,72,5,16,64,145,10, +32,76,71,64,156,217,161,180,34,6,64,208,198,36,78,50,20,20,92,204,50,44, +147,32,134,226,17,114,33,202,134,129,107,192,202,232,160,180,104,166,135, +52,72,40,144,213,33,178,152,26,34,56,163,105,44,104,146,116,139,77,43,34, +98,57,38,116,72,179,60,93,97,206,56,52,240,242,56,163,168,34,81,57,178,153, +42,228,12,182,58,22,66,89,19,57,68,176,74,68,35,104,195,18,239,116,102,114, +94,100,104,228,100,49,238,140,203,42,60,145,35,104,181,146,113,161,10,80, +46,68,82,24,245,145,132,108,228,148,54,100,137,64,34,13,100,153,222,1,40,6, +33,223,20,84,19,34,95,23,76,130,153,6,103,208,43,64,141,41,130,104,17,112, +130,44,96, }; /* to convert a heap stridx to a token number, subtract * DUK_STRIDX_START_RESERVED and add DUK_TOK_START_RESERVED. */ -/* native functions: 128 */ -DUK_INTERNAL const duk_c_function duk_bi_native_functions[128] = { +/* native functions: 149 */ +DUK_INTERNAL const duk_c_function duk_bi_native_functions[149] = { duk_bi_array_constructor, duk_bi_array_constructor_is_array, duk_bi_array_prototype_concat, @@ -10765,10 +12949,17 @@ DUK_INTERNAL const duk_c_function duk_bi_native_functions[128] = { duk_bi_array_prototype_splice, duk_bi_array_prototype_to_string, duk_bi_array_prototype_unshift, + duk_bi_arraybuffer_constructor, + duk_bi_arraybuffer_isview, duk_bi_boolean_constructor, duk_bi_boolean_prototype_tostring_shared, + duk_bi_buffer_compare_shared, duk_bi_buffer_constructor, duk_bi_buffer_prototype_tostring_shared, + duk_bi_buffer_readfield, + duk_bi_buffer_slice_shared, + duk_bi_buffer_writefield, + duk_bi_dataview_constructor, duk_bi_date_constructor, duk_bi_date_constructor_now, duk_bi_date_constructor_parse, @@ -10789,9 +12980,11 @@ DUK_INTERNAL const duk_c_function duk_bi_native_functions[128] = { duk_bi_duktape_object_info, duk_bi_error_constructor_shared, duk_bi_error_prototype_filename_getter, + duk_bi_error_prototype_filename_setter, duk_bi_error_prototype_linenumber_getter, - duk_bi_error_prototype_nop_setter, + duk_bi_error_prototype_linenumber_setter, duk_bi_error_prototype_stack_getter, + duk_bi_error_prototype_stack_setter, duk_bi_error_prototype_to_string, duk_bi_function_constructor, duk_bi_function_prototype, @@ -10823,6 +13016,16 @@ DUK_INTERNAL const duk_c_function duk_bi_native_functions[128] = { duk_bi_math_object_onearg_shared, duk_bi_math_object_random, duk_bi_math_object_twoarg_shared, + duk_bi_nodejs_buffer_byte_length, + duk_bi_nodejs_buffer_concat, + duk_bi_nodejs_buffer_constructor, + duk_bi_nodejs_buffer_copy, + duk_bi_nodejs_buffer_fill, + duk_bi_nodejs_buffer_is_buffer, + duk_bi_nodejs_buffer_is_encoding, + duk_bi_nodejs_buffer_tojson, + duk_bi_nodejs_buffer_tostring, + duk_bi_nodejs_buffer_write, duk_bi_number_constructor, duk_bi_number_prototype_to_exponential, duk_bi_number_prototype_to_fixed, @@ -10877,68 +13080,96 @@ DUK_INTERNAL const duk_c_function duk_bi_native_functions[128] = { duk_bi_thread_resume, duk_bi_thread_yield, duk_bi_type_error_thrower, + duk_bi_typedarray_constructor, + duk_bi_typedarray_set, }; -DUK_INTERNAL const duk_uint8_t duk_builtins_data[1341] = { -105,195,74,136,77,40,105,44,9,124,104,45,3,3,72,0,71,225,65,165,168,33,243, -6,145,0,122,24,210,148,14,249,35,120,160,55,226,13,76,192,196,177,164,152, -22,192,4,202,52,147,72,152,0,169,70,146,105,11,0,23,40,210,77,32,96,3,37, -26,73,163,236,0,108,163,73,52,121,128,14,148,105,38,142,176,1,242,144,56, -208,254,84,6,166,82,242,80,210,246,1,250,67,72,144,15,232,13,44,96,47,162, -52,160,128,62,80,160,255,253,102,76,0,0,15,135,240,0,0,0,3,84,0,0,15,7,240, -0,0,0,3,124,64,153,132,18,49,2,38,48,64,200,7,153,64,227,48,26,103,3,13,0, -89,165,34,53,36,38,180,128,216,143,155,81,227,114,58,111,2,142,0,73,194,94, -56,202,167,33,209,195,114,70,206,209,26,58,36,100,228,145,131,130,69,204, -137,22,51,36,84,208,145,67,82,68,205,137,18,62,36,68,240,122,32,120,62,0,2, -87,61,39,255,254,9,46,24,0,10,31,224,29,13,91,40,0,9,101,137,32,0,48,197, -84,66,214,9,10,82,68,37,81,144,133,52,65,214,137,6,90,40,0,12,21,100,144, -69,114,64,213,202,0,3,2,86,36,5,96,160,0,63,254,16,37,135,91,98,25,242,192, -7,194,248,30,236,32,123,46,17,234,186,71,162,241,5,23,240,0,15,241,1,70,74, -3,8,249,49,3,204,185,15,35,3,231,137,121,240,163,254,0,46,224,18,7,248,192, -42,249,14,3,224,20,32,0,46,208,35,231,96,41,29,96,192,117,3,159,58,66,64, -232,10,3,156,45,14,96,194,57,67,87,156,129,231,206,48,51,240,0,23,16,25, -255,255,251,132,16,209,192,8,106,0,2,223,4,53,0,2,111,2,26,128,1,183,65,13, -64,1,27,129,7,224,0,45,176,131,255,255,241,73,252,0,91,77,103,193,254,64, -36,200,64,101,31,47,32,123,188,129,178,218,70,195,113,29,173,231,206,55,3, -71,19,129,168,0,11,93,196,141,103,34,53,92,208,212,116,35,157,213,13,55, -100,52,158,16,209,108,3,65,176,12,246,192,128,0,179,155,2,0,2,205,122,3,49, -221,2,151,248,0,7,249,64,147,35,4,249,17,8,0,11,220,68,2,155,248,172,184, -31,255,253,239,255,255,255,255,236,168,0,0,0,0,0,32,0,0,12,152,0,0,31,15, -224,0,0,0,12,120,0,0,30,15,224,0,0,0,12,136,0,0,30,31,224,0,0,0,0,7,249, -128,147,32,0,0,0,0,0,0,0,0,12,249,79,35,225,52,143,117,0,49,147,8,197,75, -35,17,56,130,159,248,1,176,197,136,194,23,254,96,138,128,63,206,4,153,32,0, -3,225,252,0,0,0,2,215,200,232,24,3,161,0,1,95,142,132,0,9,240,58,16,0,53, -240,232,64,1,23,163,161,0,5,77,142,132,0,25,52,58,16,0,116,200,225,30,227, -192,94,15,1,118,48,16,0,133,208,192,64,2,87,35,1,0,10,92,12,4,0,45,110,48, -16,0,197,176,192,64,3,86,163,1,0,14,90,12,4,0,61,102,48,16,1,5,144,192,64, -4,86,35,1,0,18,88,12,4,0,77,94,48,16,1,69,112,192,64,5,85,163,1,0,22,86,12, -4,0,93,86,50,5,80,217,21,35,69,0,24,84,13,20,0,101,78,52,190,0,52,166,26, -95,0,27,82,141,63,128,14,41,6,159,192,7,84,99,83,224,3,202,33,169,240,1, -245,8,209,64,8,20,3,69,0,33,79,141,47,128,17,39,134,151,192,8,211,163,79, -224,4,137,193,167,240,2,84,192,192,64,9,146,227,69,0,39,21,31,192,0,63,208, -24,147,4,12,0,32,41,56,72,240,60,100,148,100,140,100,132,128,0,0,0,0,0,0,0, -0,210,172,228,74,52,17,242,210,1,83,252,0,3,253,33,81,132,11,69,144,24,166, -229,69,37,23,39,41,40,57,65,72,47,146,176,10,175,224,0,159,234,4,140,41,18, -44,128,192,10,191,224,0,159,235,4,140,41,10,44,128,192,10,207,224,0,159, -236,4,140,41,2,44,128,192,10,223,224,0,159,237,4,140,40,250,44,128,192,10, -239,224,0,159,238,4,140,40,242,44,128,192,10,255,224,0,159,239,4,140,40, -234,44,128,192,7,255,228,34,160,5,95,130,160,52,171,138,69,162,96,88,181, -129,32,11,42,218,221,162,32,33,23,115,31,247,156,253,127,33,224,35,138,251, -159,255,65,21,178,161,160,61,229,237,159,135,114,147,10,161,96,125,144,132, -160,12,22,162,42,33,32,79,80,115,31,230,157,191,179,32,224,79,80,123,31, -230,157,191,179,36,130,71,34,5,28,160,0,40,4,114,128,1,31,209,202,0,6,126, -73,65,245,28,160,0,135,196,114,128,2,158,209,202,0,12,122,71,40,0,57,229, -28,160,1,7,132,85,227,186,50,241,217,37,32,0,39,84,128,29,17,202,0,18,115, -71,40,0,81,201,28,160,1,103,20,114,128,6,7,255,224,4,195,63,65,193,1,130, -255,248,0,11,255,224,0,31,255,138,52,128,1,219,134,128,0,0,0,0,3,57,192,71, -72,4,229,0,29,99,140,201,72,50,31,32,196,144,131,2,49,225,121,16,240,184, -132,120,82,64,65,102,252,0,233,239,200,20,62,176,78,248,0,255,148,0,5,163, -240,0,15,249,192,9,242,38,16,0,23,184,152,5,171,240,0,15,250,64,9,242,200, -16,0,23,187,32,5,179,240,0,15,250,194,15,72,0,0,0,64,0,0,0,0,15,201,4,195, -187,126,226,4,200,68,18,162,16,72,134,60,35,67,31,0,1,25,161,143,128,1,8, -144,199,192,0,196,40,99,224,0,130,4,49,240,0,84,255,252,36,100,16,184,155, -250,226,217,150,47,46,91,249,34,224,139,229,229,203,127,36,26,119,32,203, -203,150,254,72,52,97,221,147,102,157,217,192, +DUK_INTERNAL const duk_uint8_t duk_builtins_data[1955] = { +105,195,75,32,121,40,105,53,14,252,104,54,8,131,72,0,115,225,65,165,244,55, +243,6,145,32,210,24,210,186,25,249,35,120,216,99,226,13,79,33,116,177,164, +180,44,192,4,202,52,150,220,24,0,169,70,146,219,123,0,23,40,210,91,110,96, +3,37,26,75,109,172,0,108,163,73,109,177,128,14,148,105,45,181,176,1,242, +144,56,209,36,94,6,167,133,98,80,211,28,1,250,67,72,168,67,232,13,46,192, +47,162,52,165,0,62,80,163,72,128,61,40,107,26,7,37,20,53,201,131,88,0,66, +134,185,48,98,80,215,38,11,96,0,138,26,228,193,76,0,69,67,92,152,37,128,6, +168,107,147,4,48,1,165,13,114,96,118,0,44,161,174,76,12,192,7,148,53,201, +129,88,1,26,134,165,80,130,80,31,255,241,69,224,0,0,124,63,128,0,0,0,46,32, +0,0,120,63,128,0,0,0,47,98,7,140,16,116,194,7,12,48,108,196,6,140,80,100, +198,6,12,112,92,200,5,140,149,192,202,91,204,181,184,204,91,76,213,176,206, +90,204,240,84,208,5,13,9,124,210,43,13,24,64,226,131,205,112,56,216,3,77, +152,48,218,130,205,184,40,220,130,77,216,32,222,129,205,248,24,224,129,78, +25,214,164,2,90,81,17,104,67,37,157,8,150,100,18,89,78,201,100,60,37,140, +244,150,35,226,88,79,201,96,71,37,125,20,122,188,138,62,0,2,165,70,39,255, +255,193,43,67,0,0,80,127,192,58,182,220,80,0,21,59,170,64,0,107,77,8,172, +181,146,176,202,138,187,59,42,204,200,170,182,146,168,218,80,0,26,155,97, +42,77,68,168,181,20,0,6,160,210,74,123,89,64,0,127,255,4,10,153,219,157,70, +163,185,130,140,228,10,43,160,40,141,228,161,184,18,132,226,64,161,127,128, +0,63,225,1,109,74,8,137,71,58,5,4,221,20,3,147,233,249,193,240,80,255,192, +6,120,2,64,127,195,0,173,28,56,20,96,80,128,0,206,192,143,167,64,164,156, +131,2,112,14,125,55,9,4,216,40,19,80,180,77,3,9,51,13,94,153,7,159,76,64, +207,192,0,102,0,103,255,255,242,240,67,73,112,33,168,0,12,180,16,212,0,10, +88,8,106,0,7,43,4,53,0,4,149,4,31,128,0,202,66,15,255,255,194,137,254,0,50, +135,227,224,127,196,2,87,132,17,82,143,24,10,44,96,36,240,4,147,64,146,119, +4,125,49,131,52,152,65,154,128,0,201,97,9,36,133,36,142,25,18,40,114,77,98, +17,33,137,68,130,45,17,247,240,71,159,193,29,127,8,0,12,113,252,32,0,49, +184,208,70,162,144,20,95,240,0,7,252,80,37,120,193,81,196,194,0,3,69,19,0, +81,191,197,140,192,255,255,239,127,255,255,255,255,140,64,0,0,0,0,1,0,0,0, +139,192,0,0,248,127,0,0,0,0,138,192,0,0,240,127,0,0,0,0,139,64,0,0,240,255, +0,0,0,0,0,31,241,128,149,224,0,0,0,0,0,0,0,0,13,71,98,37,25,128,148,86,48, +69,23,201,19,94,36,73,132,129,71,255,0,56,136,233,34,3,223,208,241,192,3, +254,56,18,188,128,0,15,135,240,0,0,0,11,104,228,128,135,18,4,0,6,26,72,16, +0,42,49,32,64,0,225,132,129,0,4,133,146,4,0,21,210,72,16,0,103,65,32,64,1, +220,228,100,162,146,130,20,74,8,72,248,64,2,33,3,225,0,9,131,143,132,0,42, +12,62,16,0,184,40,248,64,3,32,131,225,0,13,129,143,132,0,58,4,62,16,0,248, +8,248,64,4,32,3,225,0,17,127,143,132,0,73,252,62,16,1,55,232,248,64,5,31, +131,225,0,21,125,143,132,0,89,244,62,16,1,119,201,0,31,4,68,123,144,148,0, +97,236,66,80,1,151,169,10,248,0,211,208,133,124,0,109,230,66,254,0,56,242, +33,127,0,29,120,144,207,128,15,60,8,103,192,7,221,228,37,0,32,119,16,148,0, +133,218,66,190,0,68,236,33,95,0,35,117,144,191,128,18,58,136,95,192,9,92, +195,225,0,38,114,144,148,0,156,41,31,224,0,15,249,1,138,144,65,192,2,22,0, +88,16,46,24,77,208,148,103,4,102,252,102,244,128,0,0,0,0,0,0,0,0,220,111, +68,113,61,146,142,248,0,164,255,128,0,63,228,133,109,16,89,178,65,18,235, +153,25,150,220,184,188,180,230,6,32,209,205,0,20,175,240,0,39,252,160,77, +162,184,54,72,34,0,82,255,192,0,159,242,193,54,138,222,217,32,136,1,76,255, +0,2,127,204,4,218,43,115,100,130,32,5,55,252,0,9,255,52,19,104,173,173,146, +8,128,20,239,240,0,39,252,224,77,162,182,54,72,34,0,83,255,192,0,159,243, +193,54,138,214,217,32,136,0,255,255,33,177,0,42,252,21,1,165,92,82,45,175, +2,197,172,9,0,89,86,214,237,173,1,8,187,152,255,188,231,235,249,171,1,28, +87,220,255,250,8,173,149,169,1,239,47,108,252,59,148,152,85,167,3,236,132, +37,0,96,181,17,81,165,2,122,131,152,255,52,237,253,153,163,2,122,131,216, +255,52,237,253,153,38,130,129,25,234,5,0,1,103,40,20,0,9,154,160,80,0,54, +98,146,25,106,5,0,4,101,40,20,0,21,146,160,80,0,102,66,129,64,1,216,234,5, +0,8,99,39,47,49,83,215,152,138,73,0,1,97,168,129,132,160,80,0,150,10,129, +64,2,152,10,5,0,11,95,168,20,0,48,31,255,224,5,17,72,66,249,37,129,127,255, +0,0,191,255,128,0,63,255,197,31,192,0,80,196,64,0,0,0,0,8,26,112,17,169,0, +154,80,1,171,28,124,88,65,233,49,7,133,100,29,149,15,14,138,71,135,37,3, +195,66,114,5,77,252,0,243,178,40,25,200,48,101,30,0,127,210,128,0,85,31, +192,0,31,244,224,5,71,22,8,0,13,20,88,1,85,127,0,0,127,212,128,21,29,220, +32,0,52,87,112,5,89,252,0,1,255,86,16,166,64,0,0,2,0,0,0,0,0,170,72,38,29, +219,247,16,49,75,32,193,52,130,244,193,225,114,96,248,0,8,249,48,124,0,8, +90,152,62,0,6,44,76,31,0,4,21,166,15,128,2,147,255,252,38,212,16,184,155, +250,226,217,150,47,46,91,249,54,96,139,229,229,203,127,36,26,119,32,203, +203,150,254,72,52,97,221,147,102,157,217,192,10,191,248,0,157,4,72,15,250, +224,1,154,140,36,0,8,43,31,224,0,15,251,0,16,55,139,164,0,192,220,46,144,2, +3,104,186,64,12,77,130,233,0,33,53,139,164,0,200,212,46,144,2,35,72,186,64, +8,205,2,233,0,36,51,140,180,0,192,204,50,208,2,3,40,203,64,12,76,131,45,0, +33,49,140,180,0,200,196,50,208,2,35,8,203,64,8,204,3,45,0,36,7,255,248,1, +82,101,16,112,24,72,0,8,86,159,193,56,192,0,0,240,63,0,0,0,0,1,151,246,96, +0,21,183,240,78,48,0,0,60,15,192,0,0,0,0,101,253,168,0,5,113,252,19,140,0, +0,15,3,240,0,0,0,0,25,127,110,0,1,93,127,4,227,0,0,0,1,0,0,0,0,0,6,95,220, +128,0,87,159,193,56,192,0,0,0,64,0,0,0,0,1,151,247,96,0,21,247,240,78,48,0, +0,4,16,0,0,0,0,0,101,253,232,0,5,129,252,19,140,0,0,1,4,0,0,0,0,0,25,127, +126,0,1,97,127,4,227,0,0,0,65,0,0,0,0,0,6,95,224,128,0,88,159,193,56,192,0, +0,32,64,0,0,0,0,1,151,248,96,0,22,55,240,5,157,170,33,68,178,69,10,193,20, +10,104,79,138,36,0,12,31,248,160,88,154,23,66,100,93,32,2,9,129,116,128,0, +165,197,210,0,18,150,23,72,0,138,84,93,32,3,41,65,116,128,1,36,197,210,0, +20,146,23,72,0,146,68,93,32,3,73,1,116,128,1,163,197,210,0,22,142,23,72,0, +34,52,93,32,1,136,193,118,128,2,162,197,218,0,26,138,23,104,0,170,36,93, +160,3,168,129,150,33,198,90,0,32,134,25,104,0,10,20,101,160,1,40,65,150, +128,8,160,198,90,0,50,130,25,104,0,18,4,101,160,1,72,1,150,128,9,31,198,90, +0,52,126,25,104,0,25,244,101,160,1,103,193,150,128,2,30,198,90,0,24,122,25, +136,0,41,228,102,32,1,167,129,152,128,10,157,198,98,0,59,71,91,99,157,104, +9,213,118,39,5,8,159,20,40,0,10,109,90,19,81,132,39,151,32, }; #ifdef DUK_USE_BUILTIN_INITJS DUK_INTERNAL const duk_uint8_t duk_initjs_data[187] = { @@ -10965,9 +13196,9 @@ DUK_INTERNAL const duk_uint8_t duk_initjs_data[187] = { #define DUK__ERRFMT_BUFSIZE 256 /* size for formatting buffers */ -#ifdef DUK_USE_VERBOSE_ERRORS +#if defined(DUK_USE_VERBOSE_ERRORS) -#ifdef DUK_USE_VARIADIC_MACROS +#if defined(DUK_USE_VARIADIC_MACROS) DUK_INTERNAL void duk_err_handle_error(const char *filename, duk_int_t line, duk_hthread *thr, duk_errcode_t code, const char *fmt, ...) { va_list ap; char msg[DUK__ERRFMT_BUFSIZE]; @@ -11007,7 +13238,7 @@ DUK_INTERNAL void duk_err_handle_error_stash(duk_hthread *thr, duk_errcode_t cod #else /* DUK_USE_VERBOSE_ERRORS */ -#ifdef DUK_USE_VARIADIC_MACROS +#if defined(DUK_USE_VARIADIC_MACROS) DUK_INTERNAL void duk_err_handle_error(duk_hthread *thr, duk_errcode_t code) { duk_err_create_and_throw(thr, code); } @@ -11028,13 +13259,50 @@ DUK_INTERNAL void duk_err_handle_error_nonverbose2(const char *filename, duk_int #endif /* DUK_USE_VERBOSE_ERRORS */ +/* + * Error throwing helpers + */ + +#if defined(DUK_USE_VERBOSE_ERRORS) +#if defined(DUK_USE_PARANOID_ERRORS) +DUK_INTERNAL void duk_err_require_type_index(const char *filename, duk_int_t linenumber, duk_hthread *thr, duk_idx_t index, const char *expect_name) { + DUK_ERROR_RAW(filename, linenumber, thr, DUK_ERR_TYPE_ERROR, "%s required, found %s (stack index %ld)", + expect_name, duk_get_type_name((duk_context *) thr, index), (long) index); +} +#else +DUK_INTERNAL void duk_err_require_type_index(const char *filename, duk_int_t linenumber, duk_hthread *thr, duk_idx_t index, const char *expect_name) { + DUK_ERROR_RAW(filename, linenumber, thr, DUK_ERR_TYPE_ERROR, "%s required, found %s (stack index %ld)", + expect_name, duk_push_string_readable((duk_context *) thr, index), (long) index); +} +#endif +DUK_INTERNAL void duk_err_api_index(const char *filename, duk_int_t linenumber, duk_hthread *thr, duk_idx_t index) { + DUK_ERROR_RAW(filename, linenumber, thr, DUK_ERR_API_ERROR, "invalid stack index %ld", (long) (index)); +} +DUK_INTERNAL void duk_err_api(const char *filename, duk_int_t linenumber, duk_hthread *thr, const char *message) { + DUK_ERROR_RAW(filename, linenumber, thr, DUK_ERR_API_ERROR, message); +} +#else +DUK_INTERNAL void duk_err_require_type_index(const char *filename, duk_int_t linenumber, duk_hthread *thr, const char *message) { + DUK_UNREF(filename); DUK_UNREF(linenumber); DUK_UNREF(message); + DUK_ERROR_RAW(filename, linenumber, thr, DUK_ERR_TYPE_ERROR, message); +} +DUK_INTERNAL void duk_err_api_index(const char *filename, duk_int_t linenumber, duk_hthread *thr) { + DUK_UNREF(filename); DUK_UNREF(linenumber); + DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX); +} +DUK_INTERNAL void duk_err_api(const char *filename, duk_int_t linenumber, duk_hthread *thr, const char *message) { + DUK_UNREF(filename); DUK_UNREF(linenumber); DUK_UNREF(message); + DUK_ERROR_RAW(filename, linenumber, thr, DUK_ERR_API_ERROR, message); +} +#endif + /* * Default fatal error handler */ DUK_INTERNAL void duk_default_fatal_handler(duk_context *ctx, duk_errcode_t code, const char *msg) { DUK_UNREF(ctx); -#ifdef DUK_USE_FILE_IO +#if defined(DUK_USE_FILE_IO) DUK_FPRINTF(DUK_STDERR, "FATAL %ld: %s\n", (long) code, (const char *) (msg ? msg : "null")); DUK_FFLUSH(DUK_STDERR); #else @@ -11051,7 +13319,7 @@ DUK_INTERNAL void duk_default_fatal_handler(duk_context *ctx, duk_errcode_t code #if !defined(DUK_USE_PANIC_HANDLER) DUK_INTERNAL void duk_default_panic_handler(duk_errcode_t code, const char *msg) { -#ifdef DUK_USE_FILE_IO +#if defined(DUK_USE_FILE_IO) DUK_FPRINTF(DUK_STDERR, "PANIC %ld: %s (" #if defined(DUK_USE_PANIC_ABORT) "calling abort" @@ -11125,6 +13393,28 @@ DUK_INTERNAL duk_small_int_t duk_unicode_get_xutf8_length(duk_ucodepoint_t cp) { } } +#if defined(DUK_USE_ASSERTIONS) +DUK_INTERNAL duk_small_int_t duk_unicode_get_cesu8_length(duk_ucodepoint_t cp) { + duk_uint_fast32_t x = (duk_uint_fast32_t) cp; + if (x < 0x80UL) { + /* 7 bits */ + return 1; + } else if (x < 0x800UL) { + /* 11 bits */ + return 2; + } else if (x < 0x10000UL) { + /* 16 bits */ + return 3; + } else { + /* Encoded as surrogate pair, each encoding to 3 bytes for + * 6 bytes total. Codepoints above U+10FFFF encode as 6 bytes + * too, see duk_unicode_encode_cesu8(). + */ + return 3 + 3; + } +} +#endif /* DUK_USE_ASSERTIONS */ + DUK_INTERNAL duk_uint8_t duk_unicode_xutf8_markers[7] = { 0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe }; @@ -11322,26 +13612,117 @@ DUK_INTERNAL duk_ucodepoint_t duk_unicode_decode_xutf8_checked(duk_hthread *thr, return 0; } -/* (extended) utf-8 length without codepoint encoding validation, used - * for string interning (should probably be inlined). +/* Compute (extended) utf-8 length without codepoint encoding validation, + * used for string interning. + * + * NOTE: This algorithm is performance critical, more so than string hashing + * in some cases. It is needed when interning a string and needs to scan + * every byte of the string with no skipping. Having an ASCII fast path + * is useful if possible in the algorithm. The current algorithms were + * chosen from several variants, based on x64 gcc -O2 testing. See: + * https://github.com/svaarala/duktape/pull/422 */ -DUK_INTERNAL duk_size_t duk_unicode_unvalidated_utf8_length(const duk_uint8_t *data, duk_size_t blen) { - const duk_uint8_t *p = data; - const duk_uint8_t *p_end = data + blen; - duk_size_t clen = 0; - while (p < p_end) { - duk_uint8_t x = *p++; - if (x < 0x80 || x >= 0xc0) { - /* 10xxxxxx = continuation chars (0x80...0xbf), above - * and below that initial bytes. - */ - clen++; +#if defined(DUK_USE_PREFER_SIZE) +/* Small variant; roughly 150 bytes smaller than the fast variant. */ +DUK_INTERNAL duk_size_t duk_unicode_unvalidated_utf8_length(const duk_uint8_t *data, duk_size_t blen) { + const duk_uint8_t *p; + const duk_uint8_t *p_end; + duk_size_t ncont; + duk_size_t clen; + + p = data; + p_end = data + blen; + ncont = 0; + while (p != p_end) { + duk_uint8_t x; + x = *p++; + if (DUK_UNLIKELY(x >= 0x80 && x <= 0xbf)) { + ncont++; } } + DUK_ASSERT(ncont <= blen); + clen = blen - ncont; + DUK_ASSERT(clen <= blen); return clen; } +#else /* DUK_USE_PREFER_SIZE */ +/* This seems like a good overall approach. Fast path for ASCII in 4 byte + * blocks. + */ +DUK_INTERNAL duk_size_t duk_unicode_unvalidated_utf8_length(const duk_uint8_t *data, duk_size_t blen) { + const duk_uint8_t *p; + const duk_uint8_t *p_end; + const duk_uint32_t *p32_end; + const duk_uint32_t *p32; + duk_size_t ncont; + duk_size_t clen; + + ncont = 0; /* number of continuation (non-initial) bytes in [0x80,0xbf] */ + p = data; + p_end = data + blen; + if (blen < 16) { + goto skip_fastpath; + } + + /* Align 'p' to 4; the input data may have arbitrary alignment. + * End of string check not needed because blen >= 16. + */ + while (((duk_uintptr_t) (const void *) p) & 0x03) { + duk_uint8_t x; + x = *p++; + if (DUK_UNLIKELY(x >= 0x80 && x <= 0xbf)) { + ncont++; + } + } + + /* Full, aligned 4-byte reads. */ + p32_end = (const duk_uint32_t *) (const void *) (p + ((duk_size_t) (p_end - p) & (duk_size_t) (~0x03))); + p32 = (const duk_uint32_t *) (const void *) p; + while (p32 != (const duk_uint32_t *) p32_end) { + duk_uint32_t x; + x = *p32++; + if (DUK_LIKELY((x & 0x80808080UL) == 0)) { + ; /* ASCII fast path */ + } else { + /* Flip highest bit of each byte which changes + * the bit pattern 10xxxxxx into 00xxxxxx which + * allows an easy bit mask test. + */ + x ^= 0x80808080UL; + if (DUK_UNLIKELY(!(x & 0xc0000000UL))) { + ncont++; + } + if (DUK_UNLIKELY(!(x & 0x00c00000UL))) { + ncont++; + } + if (DUK_UNLIKELY(!(x & 0x0000c000UL))) { + ncont++; + } + if (DUK_UNLIKELY(!(x & 0x000000c0UL))) { + ncont++; + } + } + } + p = (const duk_uint8_t *) p32; + /* Fall through to handle the rest. */ + + skip_fastpath: + while (p != p_end) { + duk_uint8_t x; + x = *p++; + if (DUK_UNLIKELY(x >= 0x80 && x <= 0xbf)) { + ncont++; + } + } + + DUK_ASSERT(ncont <= blen); + clen = blen - ncont; + DUK_ASSERT(clen <= blen); + return clen; +} +#endif /* DUK_USE_PREFER_SIZE */ /* * Unicode range matcher @@ -11376,7 +13757,7 @@ DUK_LOCAL duk_small_int_t duk__uni_range_match(const duk_uint8_t *unitab, duk_si duk_codepoint_t prev_re; DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx)); - bd_ctx.data = (duk_uint8_t *) unitab; + bd_ctx.data = (const duk_uint8_t *) unitab; bd_ctx.length = (duk_size_t) unilen; prev_re = 0; @@ -11752,7 +14133,7 @@ DUK_INTERNAL duk_small_int_t duk_unicode_is_letter(duk_codepoint_t cp) { DUK_LOCAL duk_codepoint_t duk__slow_case_conversion(duk_hthread *thr, - duk_hbuffer_dynamic *buf, + duk_bufwriter_ctx *bw, duk_codepoint_t cp, duk_bitdecoder_ctx *bd_ctx) { duk_small_int_t skip = 0; @@ -11763,6 +14144,9 @@ duk_codepoint_t duk__slow_case_conversion(duk_hthread *thr, duk_codepoint_t start_i; duk_codepoint_t start_o; + DUK_UNREF(thr); + DUK_ASSERT(bd_ctx != NULL); + DUK_DDD(DUK_DDDPRINT("slow case conversion for codepoint: %ld", (long) cp)); /* range conversion with a "skip" */ @@ -11818,11 +14202,10 @@ duk_codepoint_t duk__slow_case_conversion(duk_hthread *thr, DUK_DDD(DUK_DDDPRINT("1:n conversion %ld -> %ld chars", (long) start_i, (long) t)); if (cp == start_i) { DUK_DDD(DUK_DDDPRINT("1:n matches input codepoint")); - if (buf) { + if (bw != NULL) { while (t--) { tmp_cp = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16); - DUK_ASSERT(buf != NULL); - duk_hbuffer_append_xutf8(thr, buf, (duk_ucodepoint_t) tmp_cp); + DUK_BW_WRITE_RAW_XUTF8(thr, bw, (duk_ucodepoint_t) tmp_cp); } } return -1; @@ -11838,8 +14221,8 @@ duk_codepoint_t duk__slow_case_conversion(duk_hthread *thr, /* fall through */ single: - if (buf) { - duk_hbuffer_append_xutf8(thr, buf, cp); + if (bw != NULL) { + DUK_BW_WRITE_RAW_XUTF8(thr, bw, (duk_ucodepoint_t) cp); } return cp; } @@ -11856,7 +14239,7 @@ duk_codepoint_t duk__slow_case_conversion(duk_hthread *thr, */ DUK_LOCAL duk_codepoint_t duk__case_transform_helper(duk_hthread *thr, - duk_hbuffer_dynamic *buf, + duk_bufwriter_ctx *bw, duk_codepoint_t cp, duk_codepoint_t prev, duk_codepoint_t next, @@ -11880,7 +14263,11 @@ duk_codepoint_t duk__case_transform_helper(duk_hthread *thr, cp = cp - 'A' + 'a'; } } - goto singlechar; + + if (bw != NULL) { + DUK_BW_WRITE_RAW_U8(thr, bw, (duk_uint8_t) cp); + } + return cp; } /* context and locale specific rules which cannot currently be represented @@ -11915,17 +14302,17 @@ duk_codepoint_t duk__case_transform_helper(duk_hthread *thr, /* 1:1 or special conversions, but not locale/context specific: script generated rules */ DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx)); if (uppercase) { - bd_ctx.data = (duk_uint8_t *) duk_unicode_caseconv_uc; + bd_ctx.data = (const duk_uint8_t *) duk_unicode_caseconv_uc; bd_ctx.length = (duk_size_t) sizeof(duk_unicode_caseconv_uc); } else { - bd_ctx.data = (duk_uint8_t *) duk_unicode_caseconv_lc; + bd_ctx.data = (const duk_uint8_t *) duk_unicode_caseconv_lc; bd_ctx.length = (duk_size_t) sizeof(duk_unicode_caseconv_lc); } - return duk__slow_case_conversion(thr, buf, cp, &bd_ctx); + return duk__slow_case_conversion(thr, bw, cp, &bd_ctx); singlechar: - if (buf) { - duk_hbuffer_append_xutf8(thr, buf, cp); + if (bw != NULL) { + DUK_BW_WRITE_RAW_XUTF8(thr, bw, (duk_ucodepoint_t) cp); } return cp; @@ -11943,24 +14330,20 @@ duk_codepoint_t duk__case_transform_helper(duk_hthread *thr, DUK_INTERNAL void duk_unicode_case_convert_string(duk_hthread *thr, duk_small_int_t uppercase) { duk_context *ctx = (duk_context *) thr; duk_hstring *h_input; - duk_hbuffer_dynamic *h_buf; + duk_bufwriter_ctx bw_alloc; + duk_bufwriter_ctx *bw; const duk_uint8_t *p, *p_start, *p_end; duk_codepoint_t prev, curr, next; h_input = duk_require_hstring(ctx, -1); DUK_ASSERT(h_input != NULL); - /* XXX: should init the buffer with a spare of at least h_input->blen - * to avoid unnecessary growth steps. - */ - duk_push_dynamic_buffer(ctx, 0); - h_buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1); - DUK_ASSERT(h_buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(h_buf)); + bw = &bw_alloc; + DUK_BW_INIT_PUSHBUF(thr, bw, DUK_HSTRING_GET_BYTELEN(h_input)); /* [ ... input buffer ] */ - p_start = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input); + p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input); p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input); p = p_start; @@ -11982,9 +14365,15 @@ DUK_INTERNAL void duk_unicode_case_convert_string(duk_hthread *thr, duk_small_in /* on first round, skip */ if (curr >= 0) { - /* may generate any number of output codepoints */ + /* XXX: could add a fast path to process chunks of input codepoints, + * but relative benefit would be quite small. + */ + + /* Ensure space for maximum multi-character result; estimate is overkill. */ + DUK_BW_ENSURE(thr, bw, 8 * DUK_UNICODE_MAX_XUTF8_LENGTH); + duk__case_transform_helper(thr, - h_buf, + bw, (duk_codepoint_t) curr, prev, next, @@ -11992,6 +14381,7 @@ DUK_INTERNAL void duk_unicode_case_convert_string(duk_hthread *thr, duk_small_in } } + DUK_BW_COMPACT(thr, bw); duk_to_string(ctx, -1); /* invalidates h_buf pointer */ duk_remove(ctx, -2); } @@ -12006,10 +14396,19 @@ DUK_INTERNAL void duk_unicode_case_convert_string(duk_hthread *thr, duk_small_in */ DUK_INTERNAL duk_codepoint_t duk_unicode_re_canonicalize_char(duk_hthread *thr, duk_codepoint_t cp) { +#if defined(DUK_USE_REGEXP_CANON_WORKAROUND) + /* Fast canonicalization lookup at the cost of 128kB footprint. */ + DUK_ASSERT(cp >= 0); + DUK_UNREF(thr); + if (DUK_LIKELY(cp < 0x10000L)) { + return (duk_codepoint_t) duk_unicode_re_canon_lookup[cp]; + } + return cp; +#else /* DUK_USE_REGEXP_CANON_WORKAROUND */ duk_codepoint_t y; y = duk__case_transform_helper(thr, - NULL, /* buf */ + NULL, /* NULL is allowed, no output */ cp, /* curr char */ -1, /* prev char */ -1, /* next char */ @@ -12023,6 +14422,7 @@ DUK_INTERNAL duk_codepoint_t duk_unicode_re_canonicalize_char(duk_hthread *thr, } return y; +#endif /* DUK_USE_REGEXP_CANON_WORKAROUND */ } /* @@ -12110,24 +14510,31 @@ DUK_INTERNAL duk_uint16_t duk_unicode_re_ranges_not_wordchar[10] = { * hex nybble table. */ -DUK_INTERNAL duk_uint8_t duk_lc_digits[36] = { - '0', '1', '2', '3', '4', '5', '6', '7', - '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', - 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', - 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', - 'w', 'x', 'y', 'z' +DUK_INTERNAL const duk_uint8_t duk_lc_digits[36] = { + DUK_ASC_0, DUK_ASC_1, DUK_ASC_2, DUK_ASC_3, + DUK_ASC_4, DUK_ASC_5, DUK_ASC_6, DUK_ASC_7, + DUK_ASC_8, DUK_ASC_9, DUK_ASC_LC_A, DUK_ASC_LC_B, + DUK_ASC_LC_C, DUK_ASC_LC_D, DUK_ASC_LC_E, DUK_ASC_LC_F, + DUK_ASC_LC_G, DUK_ASC_LC_H, DUK_ASC_LC_I, DUK_ASC_LC_J, + DUK_ASC_LC_K, DUK_ASC_LC_L, DUK_ASC_LC_M, DUK_ASC_LC_N, + DUK_ASC_LC_O, DUK_ASC_LC_P, DUK_ASC_LC_Q, DUK_ASC_LC_R, + DUK_ASC_LC_S, DUK_ASC_LC_T, DUK_ASC_LC_U, DUK_ASC_LC_V, + DUK_ASC_LC_W, DUK_ASC_LC_X, DUK_ASC_LC_Y, DUK_ASC_LC_Z }; -DUK_INTERNAL duk_uint8_t duk_uc_nybbles[16] = { - '0', '1', '2', '3', '4', '5', '6', '7', - '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' +DUK_INTERNAL const duk_uint8_t duk_uc_nybbles[16] = { + DUK_ASC_0, DUK_ASC_1, DUK_ASC_2, DUK_ASC_3, + DUK_ASC_4, DUK_ASC_5, DUK_ASC_6, DUK_ASC_7, + DUK_ASC_8, DUK_ASC_9, DUK_ASC_UC_A, DUK_ASC_UC_B, + DUK_ASC_UC_C, DUK_ASC_UC_D, DUK_ASC_UC_E, DUK_ASC_UC_F }; /* - * Table for decoding ASCII hex digits, -1 if invalid. + * Table for hex decoding ASCII hex digits */ -DUK_INTERNAL duk_int8_t duk_hex_dectab[256] = { +DUK_INTERNAL const duk_int8_t duk_hex_dectab[256] = { + /* -1 if invalid */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x00-0x0f */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x10-0x1f */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x20-0x2f */ @@ -12146,6 +14553,154 @@ DUK_INTERNAL duk_int8_t duk_hex_dectab[256] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 /* 0xf0-0xff */ }; +#if defined(DUK_USE_HEX_FASTPATH) +/* Preshifted << 4. Must use 16-bit entry to allow negative value signaling. */ +DUK_INTERNAL const duk_int16_t duk_hex_dectab_shift4[256] = { + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x00-0x0f */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x10-0x1f */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x20-0x2f */ + 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, -1, -1, -1, -1, -1, -1, /* 0x30-0x3f */ + -1, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x40-0x4f */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x50-0x5f */ + -1, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x60-0x6f */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x70-0x7f */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x80-0x8f */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x90-0x9f */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xa0-0xaf */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xb0-0xbf */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xc0-0xcf */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xd0-0xdf */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xe0-0xef */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 /* 0xf0-0xff */ +}; +#endif + +/* + * Table for hex encoding bytes + */ + +#if defined(DUK_USE_HEX_FASTPATH) +/* Lookup to encode one byte directly into 2 characters: + * + * def genhextab(bswap): + * for i in xrange(256): + * t = chr(i).encode('hex') + * if bswap: + * t = t[1] + t[0] + * print('0x' + t.encode('hex') + 'U') + * print('big endian'); genhextab(False) + * print('little endian'); genhextab(True) +*/ +DUK_INTERNAL const duk_uint16_t duk_hex_enctab[256] = { +#if defined(DUK_USE_INTEGER_BE) + 0x3030U, 0x3031U, 0x3032U, 0x3033U, 0x3034U, 0x3035U, 0x3036U, 0x3037U, + 0x3038U, 0x3039U, 0x3061U, 0x3062U, 0x3063U, 0x3064U, 0x3065U, 0x3066U, + 0x3130U, 0x3131U, 0x3132U, 0x3133U, 0x3134U, 0x3135U, 0x3136U, 0x3137U, + 0x3138U, 0x3139U, 0x3161U, 0x3162U, 0x3163U, 0x3164U, 0x3165U, 0x3166U, + 0x3230U, 0x3231U, 0x3232U, 0x3233U, 0x3234U, 0x3235U, 0x3236U, 0x3237U, + 0x3238U, 0x3239U, 0x3261U, 0x3262U, 0x3263U, 0x3264U, 0x3265U, 0x3266U, + 0x3330U, 0x3331U, 0x3332U, 0x3333U, 0x3334U, 0x3335U, 0x3336U, 0x3337U, + 0x3338U, 0x3339U, 0x3361U, 0x3362U, 0x3363U, 0x3364U, 0x3365U, 0x3366U, + 0x3430U, 0x3431U, 0x3432U, 0x3433U, 0x3434U, 0x3435U, 0x3436U, 0x3437U, + 0x3438U, 0x3439U, 0x3461U, 0x3462U, 0x3463U, 0x3464U, 0x3465U, 0x3466U, + 0x3530U, 0x3531U, 0x3532U, 0x3533U, 0x3534U, 0x3535U, 0x3536U, 0x3537U, + 0x3538U, 0x3539U, 0x3561U, 0x3562U, 0x3563U, 0x3564U, 0x3565U, 0x3566U, + 0x3630U, 0x3631U, 0x3632U, 0x3633U, 0x3634U, 0x3635U, 0x3636U, 0x3637U, + 0x3638U, 0x3639U, 0x3661U, 0x3662U, 0x3663U, 0x3664U, 0x3665U, 0x3666U, + 0x3730U, 0x3731U, 0x3732U, 0x3733U, 0x3734U, 0x3735U, 0x3736U, 0x3737U, + 0x3738U, 0x3739U, 0x3761U, 0x3762U, 0x3763U, 0x3764U, 0x3765U, 0x3766U, + 0x3830U, 0x3831U, 0x3832U, 0x3833U, 0x3834U, 0x3835U, 0x3836U, 0x3837U, + 0x3838U, 0x3839U, 0x3861U, 0x3862U, 0x3863U, 0x3864U, 0x3865U, 0x3866U, + 0x3930U, 0x3931U, 0x3932U, 0x3933U, 0x3934U, 0x3935U, 0x3936U, 0x3937U, + 0x3938U, 0x3939U, 0x3961U, 0x3962U, 0x3963U, 0x3964U, 0x3965U, 0x3966U, + 0x6130U, 0x6131U, 0x6132U, 0x6133U, 0x6134U, 0x6135U, 0x6136U, 0x6137U, + 0x6138U, 0x6139U, 0x6161U, 0x6162U, 0x6163U, 0x6164U, 0x6165U, 0x6166U, + 0x6230U, 0x6231U, 0x6232U, 0x6233U, 0x6234U, 0x6235U, 0x6236U, 0x6237U, + 0x6238U, 0x6239U, 0x6261U, 0x6262U, 0x6263U, 0x6264U, 0x6265U, 0x6266U, + 0x6330U, 0x6331U, 0x6332U, 0x6333U, 0x6334U, 0x6335U, 0x6336U, 0x6337U, + 0x6338U, 0x6339U, 0x6361U, 0x6362U, 0x6363U, 0x6364U, 0x6365U, 0x6366U, + 0x6430U, 0x6431U, 0x6432U, 0x6433U, 0x6434U, 0x6435U, 0x6436U, 0x6437U, + 0x6438U, 0x6439U, 0x6461U, 0x6462U, 0x6463U, 0x6464U, 0x6465U, 0x6466U, + 0x6530U, 0x6531U, 0x6532U, 0x6533U, 0x6534U, 0x6535U, 0x6536U, 0x6537U, + 0x6538U, 0x6539U, 0x6561U, 0x6562U, 0x6563U, 0x6564U, 0x6565U, 0x6566U, + 0x6630U, 0x6631U, 0x6632U, 0x6633U, 0x6634U, 0x6635U, 0x6636U, 0x6637U, + 0x6638U, 0x6639U, 0x6661U, 0x6662U, 0x6663U, 0x6664U, 0x6665U, 0x6666U +#else /* DUK_USE_INTEGER_BE */ + 0x3030U, 0x3130U, 0x3230U, 0x3330U, 0x3430U, 0x3530U, 0x3630U, 0x3730U, + 0x3830U, 0x3930U, 0x6130U, 0x6230U, 0x6330U, 0x6430U, 0x6530U, 0x6630U, + 0x3031U, 0x3131U, 0x3231U, 0x3331U, 0x3431U, 0x3531U, 0x3631U, 0x3731U, + 0x3831U, 0x3931U, 0x6131U, 0x6231U, 0x6331U, 0x6431U, 0x6531U, 0x6631U, + 0x3032U, 0x3132U, 0x3232U, 0x3332U, 0x3432U, 0x3532U, 0x3632U, 0x3732U, + 0x3832U, 0x3932U, 0x6132U, 0x6232U, 0x6332U, 0x6432U, 0x6532U, 0x6632U, + 0x3033U, 0x3133U, 0x3233U, 0x3333U, 0x3433U, 0x3533U, 0x3633U, 0x3733U, + 0x3833U, 0x3933U, 0x6133U, 0x6233U, 0x6333U, 0x6433U, 0x6533U, 0x6633U, + 0x3034U, 0x3134U, 0x3234U, 0x3334U, 0x3434U, 0x3534U, 0x3634U, 0x3734U, + 0x3834U, 0x3934U, 0x6134U, 0x6234U, 0x6334U, 0x6434U, 0x6534U, 0x6634U, + 0x3035U, 0x3135U, 0x3235U, 0x3335U, 0x3435U, 0x3535U, 0x3635U, 0x3735U, + 0x3835U, 0x3935U, 0x6135U, 0x6235U, 0x6335U, 0x6435U, 0x6535U, 0x6635U, + 0x3036U, 0x3136U, 0x3236U, 0x3336U, 0x3436U, 0x3536U, 0x3636U, 0x3736U, + 0x3836U, 0x3936U, 0x6136U, 0x6236U, 0x6336U, 0x6436U, 0x6536U, 0x6636U, + 0x3037U, 0x3137U, 0x3237U, 0x3337U, 0x3437U, 0x3537U, 0x3637U, 0x3737U, + 0x3837U, 0x3937U, 0x6137U, 0x6237U, 0x6337U, 0x6437U, 0x6537U, 0x6637U, + 0x3038U, 0x3138U, 0x3238U, 0x3338U, 0x3438U, 0x3538U, 0x3638U, 0x3738U, + 0x3838U, 0x3938U, 0x6138U, 0x6238U, 0x6338U, 0x6438U, 0x6538U, 0x6638U, + 0x3039U, 0x3139U, 0x3239U, 0x3339U, 0x3439U, 0x3539U, 0x3639U, 0x3739U, + 0x3839U, 0x3939U, 0x6139U, 0x6239U, 0x6339U, 0x6439U, 0x6539U, 0x6639U, + 0x3061U, 0x3161U, 0x3261U, 0x3361U, 0x3461U, 0x3561U, 0x3661U, 0x3761U, + 0x3861U, 0x3961U, 0x6161U, 0x6261U, 0x6361U, 0x6461U, 0x6561U, 0x6661U, + 0x3062U, 0x3162U, 0x3262U, 0x3362U, 0x3462U, 0x3562U, 0x3662U, 0x3762U, + 0x3862U, 0x3962U, 0x6162U, 0x6262U, 0x6362U, 0x6462U, 0x6562U, 0x6662U, + 0x3063U, 0x3163U, 0x3263U, 0x3363U, 0x3463U, 0x3563U, 0x3663U, 0x3763U, + 0x3863U, 0x3963U, 0x6163U, 0x6263U, 0x6363U, 0x6463U, 0x6563U, 0x6663U, + 0x3064U, 0x3164U, 0x3264U, 0x3364U, 0x3464U, 0x3564U, 0x3664U, 0x3764U, + 0x3864U, 0x3964U, 0x6164U, 0x6264U, 0x6364U, 0x6464U, 0x6564U, 0x6664U, + 0x3065U, 0x3165U, 0x3265U, 0x3365U, 0x3465U, 0x3565U, 0x3665U, 0x3765U, + 0x3865U, 0x3965U, 0x6165U, 0x6265U, 0x6365U, 0x6465U, 0x6565U, 0x6665U, + 0x3066U, 0x3166U, 0x3266U, 0x3366U, 0x3466U, 0x3566U, 0x3666U, 0x3766U, + 0x3866U, 0x3966U, 0x6166U, 0x6266U, 0x6366U, 0x6466U, 0x6566U, 0x6666U +#endif /* DUK_USE_INTEGER_BE */ +}; +#endif /* DUK_USE_HEX_FASTPATH */ + +/* + * Table for base-64 encoding + */ + +#if defined(DUK_USE_BASE64_FASTPATH) +DUK_INTERNAL const duk_uint8_t duk_base64_enctab[64] = { + 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, /* A...P */ + 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, /* Q...f */ + 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, /* g...v */ + 0x77, 0x78, 0x79, 0x7a, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f /* w.../ */ +}; +#endif /* DUK_USE_BASE64_FASTPATH */ + +/* + * Table for base-64 decoding + */ + +#if defined(DUK_USE_BASE64_FASTPATH) +DUK_INTERNAL const duk_int8_t duk_base64_dectab[256] = { + /* -1 = error, -2 = allowed whitespace, -3 = padding ('='), 0...63 decoded bytes */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -2, -1, -1, -2, -1, -1, /* 0x00...0x0f */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x10...0x1f */ + -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, /* 0x20...0x2f */ + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -3, -1, -1, /* 0x30...0x3f */ + -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, /* 0x40...0x4f */ + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, /* 0x50...0x5f */ + -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, /* 0x60...0x6f */ + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1, /* 0x70...0x7f */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x80...0x8f */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x90...0x9f */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xa0...0xaf */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xb0...0xbf */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xc0...0xcf */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xd0...0xdf */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xe0...0xef */ + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 /* 0xf0...0xff */ +}; +#endif /* DUK_USE_BASE64_FASTPATH */ + /* * Arbitrary byteswap for potentially unaligned values * @@ -12251,7 +14806,6 @@ DUK_INTERNAL duk_uint32_t duk_util_get_hash_prime(duk_uint32_t size) { /* include removed: duk_internal.h */ -/* Maybe better to check these elsewhere */ #if (DUK_STRIDX_UC_ARGUMENTS > 255) #error constant too large #endif @@ -12291,6 +14845,54 @@ DUK_INTERNAL duk_uint32_t duk_util_get_hash_prime(duk_uint32_t size) { #if (DUK_STRIDX_GLOBAL > 255) #error constant too large #endif +#if (DUK_STRIDX_OBJ_ENV > 255) +#error constant too large +#endif +#if (DUK_STRIDX_DEC_ENV > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UC_BUFFER > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UC_POINTER > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UC_THREAD > 255) +#error constant too large +#endif +#if (DUK_STRIDX_ARRAY_BUFFER > 255) +#error constant too large +#endif +#if (DUK_STRIDX_DATA_VIEW > 255) +#error constant too large +#endif +#if (DUK_STRIDX_INT8_ARRAY > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UINT8_ARRAY > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UINT8_CLAMPED_ARRAY > 255) +#error constant too large +#endif +#if (DUK_STRIDX_INT16_ARRAY > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UINT16_ARRAY > 255) +#error constant too large +#endif +#if (DUK_STRIDX_INT32_ARRAY > 255) +#error constant too large +#endif +#if (DUK_STRIDX_UINT32_ARRAY > 255) +#error constant too large +#endif +#if (DUK_STRIDX_FLOAT32_ARRAY > 255) +#error constant too large +#endif +#if (DUK_STRIDX_FLOAT64_ARRAY > 255) +#error constant too large +#endif #if (DUK_STRIDX_EMPTY_STRING > 255) #error constant too large #endif @@ -12315,18 +14917,18 @@ DUK_INTERNAL duk_uint8_t duk_class_number_to_stridx[32] = { DUK_STRIDX_DEC_ENV, DUK_STRIDX_UC_BUFFER, DUK_STRIDX_UC_POINTER, - DUK_STRIDX_UC_THREAD, /* UNUSED, intentionally empty */ - DUK_STRIDX_EMPTY_STRING, /* UNUSED, intentionally empty */ - DUK_STRIDX_EMPTY_STRING, /* UNUSED, intentionally empty */ - DUK_STRIDX_EMPTY_STRING, /* UNUSED, intentionally empty */ - DUK_STRIDX_EMPTY_STRING, /* UNUSED, intentionally empty */ - DUK_STRIDX_EMPTY_STRING, /* UNUSED, intentionally empty */ - DUK_STRIDX_EMPTY_STRING, /* UNUSED, intentionally empty */ - DUK_STRIDX_EMPTY_STRING, /* UNUSED, intentionally empty */ - DUK_STRIDX_EMPTY_STRING, /* UNUSED, intentionally empty */ - DUK_STRIDX_EMPTY_STRING, /* UNUSED, intentionally empty */ - DUK_STRIDX_EMPTY_STRING, /* UNUSED, intentionally empty */ - DUK_STRIDX_EMPTY_STRING, /* UNUSED, intentionally empty */ + DUK_STRIDX_UC_THREAD, + DUK_STRIDX_ARRAY_BUFFER, + DUK_STRIDX_DATA_VIEW, + DUK_STRIDX_INT8_ARRAY, + DUK_STRIDX_UINT8_ARRAY, + DUK_STRIDX_UINT8_CLAMPED_ARRAY, + DUK_STRIDX_INT16_ARRAY, + DUK_STRIDX_UINT16_ARRAY, + DUK_STRIDX_INT32_ARRAY, + DUK_STRIDX_UINT32_ARRAY, + DUK_STRIDX_FLOAT32_ARRAY, + DUK_STRIDX_FLOAT64_ARRAY, DUK_STRIDX_EMPTY_STRING, /* UNUSED, intentionally empty */ DUK_STRIDX_EMPTY_STRING, /* UNUSED, intentionally empty */ }; @@ -12374,20 +14976,797 @@ DUK_EXTERNAL void *duk_resize_buffer(duk_context *ctx, duk_idx_t index, duk_size duk_hthread *thr = (duk_hthread *) ctx; duk_hbuffer_dynamic *h; + DUK_ASSERT_CTX_VALID(ctx); + + h = (duk_hbuffer_dynamic *) duk_require_hbuffer(ctx, index); + DUK_ASSERT(h != NULL); + + if (!(DUK_HBUFFER_HAS_DYNAMIC(h) && !DUK_HBUFFER_HAS_EXTERNAL(h))) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_WRONG_BUFFER_TYPE); + } + + /* maximum size check is handled by callee */ + duk_hbuffer_resize(thr, h, new_size); + + return DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h); +} + +DUK_EXTERNAL void *duk_steal_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hbuffer_dynamic *h; + void *ptr; + duk_size_t sz; + DUK_ASSERT(ctx != NULL); h = (duk_hbuffer_dynamic *) duk_require_hbuffer(ctx, index); DUK_ASSERT(h != NULL); - if (!DUK_HBUFFER_HAS_DYNAMIC(h)) { - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_BUFFER_NOT_DYNAMIC); + if (!(DUK_HBUFFER_HAS_DYNAMIC(h) && !DUK_HBUFFER_HAS_EXTERNAL(h))) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_WRONG_BUFFER_TYPE); } - /* maximum size check is handled by callee */ - duk_hbuffer_resize(thr, h, new_size, new_size); /* snug */ + /* Forget the previous allocation, setting size to 0 and alloc to + * NULL. Caller is responsible for freeing the previous allocation. + * Getting the allocation and clearing it is done in the same API + * call to avoid any chance of a realloc. + */ + ptr = DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h); + sz = DUK_HBUFFER_DYNAMIC_GET_SIZE(h); + if (out_size) { + *out_size = sz; + } + DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(thr->heap, h); + DUK_HBUFFER_DYNAMIC_SET_SIZE(h, 0); - return DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h); + return ptr; } + +DUK_EXTERNAL void duk_config_buffer(duk_context *ctx, duk_idx_t index, void *ptr, duk_size_t len) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hbuffer_external *h; + + DUK_ASSERT(ctx != NULL); + + h = (duk_hbuffer_external *) duk_require_hbuffer(ctx, index); + DUK_ASSERT(h != NULL); + + if (!DUK_HBUFFER_HAS_EXTERNAL(h)) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_WRONG_BUFFER_TYPE); + } + DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(h)); + + DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(thr->heap, h, ptr); + DUK_HBUFFER_EXTERNAL_SET_SIZE(h, len); +} +#line 1 "duk_api_bytecode.c" +/* + * Bytecode dump/load + * + * The bytecode load primitive is more important performance-wise than the + * dump primitive. + * + * Unlike most Duktape API calls, bytecode dump/load is not guaranteed to be + * memory safe for invalid arguments - caller beware! There's little point + * in trying to achieve memory safety unless bytecode instructions are also + * validated which is not easy to do with indirect register references etc. + */ + +/* include removed: duk_internal.h */ + +#if defined(DUK_USE_BYTECODE_DUMP_SUPPORT) + +#define DUK__SER_MARKER 0xff +#define DUK__SER_VERSION 0x00 +#define DUK__SER_STRING 0x00 +#define DUK__SER_NUMBER 0x01 +#define DUK__BYTECODE_INITIAL_ALLOC 256 + +/* + * Dump/load helpers, xxx_raw() helpers do no buffer checks + */ + +DUK_LOCAL duk_uint8_t *duk__load_string_raw(duk_context *ctx, duk_uint8_t *p) { + duk_uint32_t len; + + len = DUK_RAW_READ_U32_BE(p); + duk_push_lstring(ctx, (const char *) p, len); + p += len; + return p; +} + +DUK_LOCAL duk_uint8_t *duk__load_buffer_raw(duk_context *ctx, duk_uint8_t *p) { + duk_uint32_t len; + duk_uint8_t *buf; + + len = DUK_RAW_READ_U32_BE(p); + buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, (duk_size_t) len); + DUK_ASSERT(buf != NULL); + DUK_MEMCPY((void *) buf, (const void *) p, (size_t) len); + p += len; + return p; +} + +DUK_LOCAL duk_uint8_t *duk__dump_hstring_raw(duk_uint8_t *p, duk_hstring *h) { + duk_size_t len; + duk_uint32_t tmp32; + + DUK_ASSERT(h != NULL); + + len = DUK_HSTRING_GET_BYTELEN(h); + DUK_ASSERT(len <= 0xffffffffUL); /* string limits */ + tmp32 = (duk_uint32_t) len; + DUK_RAW_WRITE_U32_BE(p, tmp32); + DUK_MEMCPY((void *) p, + (const void *) DUK_HSTRING_GET_DATA(h), + len); + p += len; + return p; +} + +DUK_LOCAL duk_uint8_t *duk__dump_hbuffer_raw(duk_hthread *thr, duk_uint8_t *p, duk_hbuffer *h) { + duk_size_t len; + duk_uint32_t tmp32; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(h != NULL); + DUK_UNREF(thr); + + len = DUK_HBUFFER_GET_SIZE(h); + DUK_ASSERT(len <= 0xffffffffUL); /* buffer limits */ + tmp32 = (duk_uint32_t) len; + DUK_RAW_WRITE_U32_BE(p, tmp32); + DUK_MEMCPY((void *) p, + (const void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h), + len); + p += len; + return p; +} + +DUK_LOCAL duk_uint8_t *duk__dump_string_prop(duk_hthread *thr, duk_uint8_t *p, duk_bufwriter_ctx *bw_ctx, duk_hobject *func, duk_small_uint_t stridx) { + duk_hstring *h_str; + duk_tval *tv; + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, (duk_hobject *) func, DUK_HTHREAD_GET_STRING(thr, stridx)); + if (tv != NULL && DUK_TVAL_IS_STRING(tv)) { + h_str = DUK_TVAL_GET_STRING(tv); + DUK_ASSERT(h_str != NULL); + } else { + h_str = DUK_HTHREAD_STRING_EMPTY_STRING(thr); + DUK_ASSERT(h_str != NULL); + } + DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL); /* ensures no overflow */ + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4 + DUK_HSTRING_GET_BYTELEN(h_str), p); + p = duk__dump_hstring_raw(p, h_str); + return p; +} + +DUK_LOCAL duk_uint8_t *duk__dump_buffer_prop(duk_hthread *thr, duk_uint8_t *p, duk_bufwriter_ctx *bw_ctx, duk_hobject *func, duk_small_uint_t stridx) { + duk_tval *tv; + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, (duk_hobject *) func, DUK_HTHREAD_GET_STRING(thr, stridx)); + if (tv != NULL && DUK_TVAL_IS_BUFFER(tv)) { + duk_hbuffer *h_buf; + h_buf = DUK_TVAL_GET_BUFFER(tv); + DUK_ASSERT(h_buf != NULL); + DUK_ASSERT(DUK_HBUFFER_MAX_BYTELEN <= 0x7fffffffUL); /* ensures no overflow */ + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4 + DUK_HBUFFER_GET_SIZE(h_buf), p); + p = duk__dump_hbuffer_raw(thr, p, h_buf); + } else { + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4, p); + DUK_RAW_WRITE_U32_BE(p, 0); + } + return p; +} + +DUK_LOCAL duk_uint8_t *duk__dump_uint32_prop(duk_hthread *thr, duk_uint8_t *p, duk_bufwriter_ctx *bw_ctx, duk_hobject *func, duk_small_uint_t stridx, duk_uint32_t def_value) { + duk_tval *tv; + duk_uint32_t val; + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, (duk_hobject *) func, DUK_HTHREAD_GET_STRING(thr, stridx)); + if (tv != NULL && DUK_TVAL_IS_NUMBER(tv)) { + val = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv); + } else { + val = def_value; + } + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4, p); + DUK_RAW_WRITE_U32_BE(p, val); + return p; +} + +DUK_LOCAL duk_uint8_t *duk__dump_varmap(duk_hthread *thr, duk_uint8_t *p, duk_bufwriter_ctx *bw_ctx, duk_hobject *func) { + duk_tval *tv; + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, (duk_hobject *) func, DUK_HTHREAD_STRING_INT_VARMAP(thr)); + if (tv != NULL && DUK_TVAL_IS_OBJECT(tv)) { + duk_hobject *h; + duk_uint_fast32_t i; + + h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + + /* We know _Varmap only has own properties so walk property + * table directly. We also know _Varmap is dense and all + * values are numbers; assert for these. GC and finalizers + * shouldn't affect _Varmap so side effects should be fine. + */ + for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h); i++) { + duk_hstring *key; + duk_tval *tv_val; + duk_uint32_t val; + + key = DUK_HOBJECT_E_GET_KEY(thr->heap, h, i); + DUK_ASSERT(key != NULL); /* _Varmap is dense */ + DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, h, i)); + tv_val = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, h, i); + DUK_ASSERT(tv_val != NULL); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_val)); /* known to be number; in fact an integer */ +#if defined(DUK_USE_FASTINT) + DUK_ASSERT(DUK_TVAL_IS_FASTINT(tv_val)); + DUK_ASSERT(DUK_TVAL_GET_FASTINT(tv_val) == (duk_int64_t) DUK_TVAL_GET_FASTINT_U32(tv_val)); /* known to be 32-bit */ + val = DUK_TVAL_GET_FASTINT_U32(tv_val); +#else + val = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv_val); +#endif + + DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL); /* ensures no overflow */ + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4 + DUK_HSTRING_GET_BYTELEN(key) + 4, p); + p = duk__dump_hstring_raw(p, key); + DUK_RAW_WRITE_U32_BE(p, val); + } + } + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4, p); + DUK_RAW_WRITE_U32_BE(p, 0); /* end of _Varmap */ + return p; +} + +DUK_LOCAL duk_uint8_t *duk__dump_formals(duk_hthread *thr, duk_uint8_t *p, duk_bufwriter_ctx *bw_ctx, duk_hobject *func) { + duk_tval *tv; + + tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, (duk_hobject *) func, DUK_HTHREAD_STRING_INT_FORMALS(thr)); + if (tv != NULL && DUK_TVAL_IS_OBJECT(tv)) { + duk_hobject *h; + duk_uint_fast32_t i; + + h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + + /* We know _Formals is dense and all entries will be in the + * array part. GC and finalizers shouldn't affect _Formals + * so side effects should be fine. + */ + for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(h); i++) { + duk_tval *tv_val; + duk_hstring *varname; + + tv_val = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, h, i); + DUK_ASSERT(tv_val != NULL); + if (DUK_TVAL_IS_STRING(tv_val)) { + /* Array is dense and contains only strings, but ASIZE may + * be larger than used part and there are UNUSED entries. + */ + varname = DUK_TVAL_GET_STRING(tv_val); + DUK_ASSERT(varname != NULL); + + DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL); /* ensures no overflow */ + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4 + DUK_HSTRING_GET_BYTELEN(varname), p); + p = duk__dump_hstring_raw(p, varname); + } + } + } + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4, p); + DUK_RAW_WRITE_U32_BE(p, 0); /* end of _Formals */ + return p; +} + +static duk_uint8_t *duk__dump_func(duk_context *ctx, duk_hcompiledfunction *func, duk_bufwriter_ctx *bw_ctx, duk_uint8_t *p) { + duk_hthread *thr; + duk_tval *tv, *tv_end; + duk_instr_t *ins, *ins_end; + duk_hobject **fn, **fn_end; + duk_hstring *h_str; + duk_uint32_t count_instr; + duk_uint32_t tmp32; + duk_uint16_t tmp16; + duk_double_t d; + + thr = (duk_hthread *) ctx; + DUK_UNREF(ctx); + DUK_UNREF(thr); + + DUK_DD(DUK_DDPRINT("dumping function %p to %p: " + "consts=[%p,%p[ (%ld bytes, %ld items), " + "funcs=[%p,%p[ (%ld bytes, %ld items), " + "code=[%p,%p[ (%ld bytes, %ld items)", + (void *) func, + (void *) p, + (void *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, func), + (void *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(thr->heap, func), + (long) DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE(thr->heap, func), + (long) DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT(thr->heap, func), + (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, func), + (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(thr->heap, func), + (long) DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE(thr->heap, func), + (long) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(thr->heap, func), + (void *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, func), + (void *) DUK_HCOMPILEDFUNCTION_GET_CODE_END(thr->heap, func), + (long) DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE(thr->heap, func), + (long) DUK_HCOMPILEDFUNCTION_GET_CODE_COUNT(thr->heap, func))); + + DUK_ASSERT(DUK_USE_ESBC_MAX_BYTES <= 0x7fffffffUL); /* ensures no overflow */ + count_instr = (duk_uint32_t) DUK_HCOMPILEDFUNCTION_GET_CODE_COUNT(thr->heap, func); + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 3 * 4 + 2 * 2 + 3 * 4 + count_instr * 4, p); + + /* Fixed header info. */ + tmp32 = count_instr; + DUK_RAW_WRITE_U32_BE(p, tmp32); + tmp32 = (duk_uint32_t) DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT(thr->heap, func); + DUK_RAW_WRITE_U32_BE(p, tmp32); + tmp32 = (duk_uint32_t) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(thr->heap, func); + DUK_RAW_WRITE_U32_BE(p, tmp32); + tmp16 = func->nregs; + DUK_RAW_WRITE_U16_BE(p, tmp16); + tmp16 = func->nargs; + DUK_RAW_WRITE_U16_BE(p, tmp16); +#if defined(DUK_USE_DEBUGGER_SUPPORT) + tmp32 = func->start_line; + DUK_RAW_WRITE_U32_BE(p, tmp32); + tmp32 = func->end_line; + DUK_RAW_WRITE_U32_BE(p, tmp32); +#else + DUK_RAW_WRITE_U32_BE(p, 0); + DUK_RAW_WRITE_U32_BE(p, 0); +#endif + tmp32 = ((duk_heaphdr *) func)->h_flags & DUK_HEAPHDR_FLAGS_FLAG_MASK; + DUK_RAW_WRITE_U32_BE(p, tmp32); + + /* Bytecode instructions: endian conversion needed unless + * platform is big endian. + */ + ins = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, func); + ins_end = DUK_HCOMPILEDFUNCTION_GET_CODE_END(thr->heap, func); + DUK_ASSERT((duk_size_t) (ins_end - ins) == (duk_size_t) count_instr); +#if defined(DUK_USE_INTEGER_BE) + DUK_MEMCPY((void *) p, (const void *) ins, (size_t) (ins_end - ins)); + p += (size_t) (ins_end - ins); +#else + while (ins != ins_end) { + tmp32 = (duk_uint32_t) (*ins); + DUK_RAW_WRITE_U32_BE(p, tmp32); + ins++; + } +#endif + + /* Constants: variable size encoding. */ + tv = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, func); + tv_end = DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(thr->heap, func); + while (tv != tv_end) { + /* constants are strings or numbers now */ + DUK_ASSERT(DUK_TVAL_IS_STRING(tv) || + DUK_TVAL_IS_NUMBER(tv)); + + if (DUK_TVAL_IS_STRING(tv)) { + h_str = DUK_TVAL_GET_STRING(tv); + DUK_ASSERT(h_str != NULL); + DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL); /* ensures no overflow */ + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 1 + 4 + DUK_HSTRING_GET_BYTELEN(h_str), p), + *p++ = DUK__SER_STRING; + p = duk__dump_hstring_raw(p, h_str); + } else { + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 1 + 8, p); + *p++ = DUK__SER_NUMBER; + d = DUK_TVAL_GET_NUMBER(tv); + DUK_RAW_WRITE_DOUBLE_BE(p, d); + } + tv++; + } + + /* Inner functions recursively. */ + fn = (duk_hobject **) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, func); + fn_end = (duk_hobject **) DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(thr->heap, func); + while (fn != fn_end) { + /* XXX: This causes recursion up to inner function depth + * which is normally not an issue, e.g. mark-and-sweep uses + * a recursion limiter to avoid C stack issues. Avoiding + * this would mean some sort of a work list or just refusing + * to serialize deep functions. + */ + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(*fn)); + p = duk__dump_func(ctx, (duk_hcompiledfunction *) *fn, bw_ctx, p); + fn++; + } + + /* Object extra properties. + * + * There are some difference between function templates and functions. + * For example, function templates don't have .length and nargs is + * normally used to instantiate the functions. + */ + + p = duk__dump_uint32_prop(thr, p, bw_ctx, (duk_hobject *) func, DUK_STRIDX_LENGTH, (duk_uint32_t) func->nargs); + p = duk__dump_string_prop(thr, p, bw_ctx, (duk_hobject *) func, DUK_STRIDX_NAME); + p = duk__dump_string_prop(thr, p, bw_ctx, (duk_hobject *) func, DUK_STRIDX_FILE_NAME); + p = duk__dump_buffer_prop(thr, p, bw_ctx, (duk_hobject *) func, DUK_STRIDX_INT_PC2LINE); + p = duk__dump_varmap(thr, p, bw_ctx, (duk_hobject *) func); + p = duk__dump_formals(thr, p, bw_ctx, (duk_hobject *) func); + + DUK_DD(DUK_DDPRINT("serialized function %p -> final pointer %p", (void *) func, (void *) p)); + + return p; +} + +/* Load a function from bytecode. The function object returned here must + * match what is created by duk_js_push_closure() with respect to its flags, + * properties, etc. + * + * NOTE: there are intentionally no input buffer length / bound checks. + * Adding them would be easy but wouldn't ensure memory safety as untrusted + * or broken bytecode is unsafe during execution unless the opcodes themselves + * are validated (which is quite complex, especially for indirect opcodes). + */ + +#define DUK__ASSERT_LEFT(n) do { \ + DUK_ASSERT((duk_size_t) (p_end - p) >= (duk_size_t) (n)); \ + } while (0) + +static duk_uint8_t *duk__load_func(duk_context *ctx, duk_uint8_t *p, duk_uint8_t *p_end) { + duk_hthread *thr; + duk_hcompiledfunction *h_fun; + duk_hbuffer *h_data; + duk_size_t data_size; + duk_uint32_t count_instr, count_const, count_funcs; + duk_uint32_t n; + duk_uint32_t tmp32; + duk_small_uint_t const_type; + duk_uint8_t *fun_data; + duk_uint8_t *q; + duk_idx_t idx_base; + duk_tval *tv1; + duk_uarridx_t arr_idx; + + /* XXX: There's some overlap with duk_js_closure() here, but + * seems difficult to share code. Ensure that the final function + * looks the same as created by duk_js_closure(). + */ + + DUK_ASSERT(ctx != NULL); + thr = (duk_hthread *) ctx; + + DUK_DD(DUK_DDPRINT("loading function, p=%p, p_end=%p", (void *) p, (void *) p_end)); + + DUK__ASSERT_LEFT(3 * 4); + count_instr = DUK_RAW_READ_U32_BE(p); + count_const = DUK_RAW_READ_U32_BE(p); + count_funcs = DUK_RAW_READ_U32_BE(p); + + data_size = sizeof(duk_tval) * count_const + + sizeof(duk_hobject *) * count_funcs + + sizeof(duk_instr_t) * count_instr; + + DUK_DD(DUK_DDPRINT("instr=%ld, const=%ld, funcs=%ld, data_size=%ld", + (long) count_instr, (long) count_const, + (long) count_const, (long) data_size)); + + /* Value stack is used to ensure reachability of constants and + * inner functions being loaded. Require enough space to handle + * large functions correctly. + */ + duk_require_stack(ctx, 2 + count_const + count_funcs); + idx_base = duk_get_top(ctx); + + /* Push function object, init flags etc. This must match + * duk_js_push_closure() quite carefully. + */ + duk_push_compiledfunction(ctx); + h_fun = duk_get_hcompiledfunction(ctx, -1); + DUK_ASSERT(h_fun != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) h_fun)); + DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, h_fun) == NULL); + DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_FUNCS(thr->heap, h_fun) == NULL); + DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_BYTECODE(thr->heap, h_fun) == NULL); + + h_fun->nregs = DUK_RAW_READ_U16_BE(p); + h_fun->nargs = DUK_RAW_READ_U16_BE(p); +#if defined(DUK_USE_DEBUGGER_SUPPORT) + h_fun->start_line = DUK_RAW_READ_U32_BE(p); + h_fun->end_line = DUK_RAW_READ_U32_BE(p); +#else + p += 8; /* skip line info */ +#endif + + /* duk_hcompiledfunction flags; quite version specific */ + tmp32 = DUK_RAW_READ_U32_BE(p); + DUK_HEAPHDR_SET_FLAGS((duk_heaphdr *) h_fun, tmp32); + + /* standard prototype */ + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, &h_fun->obj, thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]); + + /* assert just a few critical flags */ + DUK_ASSERT(DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) h_fun) == DUK_HTYPE_OBJECT); + DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(&h_fun->obj)); + DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(&h_fun->obj)); + DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(&h_fun->obj)); + DUK_ASSERT(!DUK_HOBJECT_HAS_THREAD(&h_fun->obj)); + DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARRAY(&h_fun->obj)); + DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(&h_fun->obj)); + DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(&h_fun->obj)); + + /* Create function 'data' buffer but don't attach it yet. */ + fun_data = (duk_uint8_t *) duk_push_fixed_buffer(ctx, data_size); + DUK_ASSERT(fun_data != NULL); + + /* Load bytecode instructions. */ + DUK_ASSERT(sizeof(duk_instr_t) == 4); + DUK__ASSERT_LEFT(count_instr * sizeof(duk_instr_t)); +#if defined(DUK_USE_INTEGER_BE) + q = fun_data + sizeof(duk_tval) * count_const + sizeof(duk_hobject *) * count_funcs; + DUK_MEMCPY((void *) q, + (const void *) p, + sizeof(duk_instr_t) * count_instr); + p += sizeof(duk_instr_t) * count_instr; +#else + q = fun_data + sizeof(duk_tval) * count_const + sizeof(duk_hobject *) * count_funcs; + for (n = count_instr; n > 0; n--) { + *((duk_instr_t *) (void *) q) = DUK_RAW_READ_U32_BE(p); + q += sizeof(duk_instr_t); + } +#endif + + /* Load constants onto value stack but don't yet copy to buffer. */ + for (n = count_const; n > 0; n--) { + DUK__ASSERT_LEFT(1); + const_type = DUK_RAW_READ_U8(p); + switch (const_type) { + case DUK__SER_STRING: { + p = duk__load_string_raw(ctx, p); + break; + } + case DUK__SER_NUMBER: { + /* Important to do a fastint check so that constants are + * properly read back as fastints. + */ + duk_tval tv_tmp; + duk_double_t val; + DUK__ASSERT_LEFT(8); + val = DUK_RAW_READ_DOUBLE_BE(p); + DUK_TVAL_SET_NUMBER_CHKFAST(&tv_tmp, val); + duk_push_tval(ctx, &tv_tmp); + break; + } + default: { + goto format_error; + } + } + } + + /* Load inner functions to value stack, but don't yet copy to buffer. */ + for (n = count_funcs; n > 0; n--) { + p = duk__load_func(ctx, p, p_end); + if (p == NULL) { + goto format_error; + } + } + + /* With constants and inner functions on value stack, we can now + * atomically finish the function 'data' buffer, bump refcounts, + * etc. + * + * Here we take advantage of the value stack being just a duk_tval + * array: we can just memcpy() the constants as long as we incref + * them afterwards. + */ + + h_data = (duk_hbuffer *) duk_get_hbuffer(ctx, idx_base + 1); + DUK_ASSERT(h_data != NULL); + DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC(h_data)); + DUK_HCOMPILEDFUNCTION_SET_DATA(thr->heap, h_fun, h_data); + DUK_HBUFFER_INCREF(thr, h_data); + + tv1 = duk_get_tval(ctx, idx_base + 2); /* may be NULL if no constants or inner funcs */ + DUK_ASSERT((count_const == 0 && count_funcs == 0) || tv1 != NULL); + + q = fun_data; + if (count_const > 0) { + /* Explicit zero size check to avoid NULL 'tv1'. */ + DUK_MEMCPY((void *) q, (const void *) tv1, sizeof(duk_tval) * count_const); + for (n = count_const; n > 0; n--) { + DUK_TVAL_INCREF_FAST(thr, (duk_tval *) (void *) q); /* no side effects */ + q += sizeof(duk_tval); + } + tv1 += count_const; + } + + DUK_HCOMPILEDFUNCTION_SET_FUNCS(thr->heap, h_fun, (duk_hobject **) (void *) q); + for (n = count_funcs; n > 0; n--) { + duk_hobject *h_obj; + + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv1)); + h_obj = DUK_TVAL_GET_OBJECT(tv1); + DUK_ASSERT(h_obj != NULL); + tv1++; + DUK_HOBJECT_INCREF(thr, h_obj); + + *((duk_hobject **) (void *) q) = h_obj; + q += sizeof(duk_hobject *); + } + + DUK_HCOMPILEDFUNCTION_SET_BYTECODE(thr->heap, h_fun, (duk_instr_t *) (void *) q); + + /* The function object is now reachable and refcounts are fine, + * so we can pop off all the temporaries. + */ + DUK_DDD(DUK_DDDPRINT("function is reachable, reset top; func: %!iT", duk_get_tval(ctx, idx_base))); + duk_set_top(ctx, idx_base + 1); + + /* Setup function properties. */ + tmp32 = DUK_RAW_READ_U32_BE(p); + duk_push_u32(ctx, tmp32); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE); + + p = duk__load_string_raw(ctx, p); + if (DUK_HOBJECT_HAS_NAMEBINDING((duk_hobject *) h_fun)) { + /* Original function instance/template had NAMEBINDING. + * Must create a lexical environment on loading to allow + * recursive functions like 'function foo() { foo(); }'. + */ + duk_hobject *proto; + + proto = thr->builtins[DUK_BIDX_GLOBAL_ENV]; + (void) duk_push_object_helper_proto(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV), + proto); + duk_dup(ctx, -2); /* -> [ func funcname env funcname ] */ + duk_dup(ctx, idx_base); /* -> [ func funcname env funcname func ] */ + duk_xdef_prop(ctx, -3, DUK_PROPDESC_FLAGS_NONE); /* -> [ func funcname env ] */ + duk_xdef_prop_stridx(ctx, idx_base, DUK_STRIDX_INT_LEXENV, DUK_PROPDESC_FLAGS_WC); + /* since closure has NEWENV, never define DUK_STRIDX_INT_VARENV, as it + * will be ignored anyway + */ + } + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE); + + p = duk__load_string_raw(ctx, p); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC); + + duk_push_object(ctx); + duk_dup(ctx, -2); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_CONSTRUCTOR, DUK_PROPDESC_FLAGS_WC); /* func.prototype.constructor = func */ + duk_compact(ctx, -1); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_PROTOTYPE, DUK_PROPDESC_FLAGS_W); + + p = duk__load_buffer_raw(ctx, p); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_PC2LINE, DUK_PROPDESC_FLAGS_WC); + + duk_push_object(ctx); /* _Varmap */ + for (;;) { + /* XXX: awkward */ + p = duk__load_string_raw(ctx, p); + if (duk_get_length(ctx, -1) == 0) { + duk_pop(ctx); + break; + } + tmp32 = DUK_RAW_READ_U32_BE(p); + duk_push_u32(ctx, tmp32); + duk_put_prop(ctx, -3); + } + duk_compact(ctx, -1); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VARMAP, DUK_PROPDESC_FLAGS_NONE); + + duk_push_array(ctx); /* _Formals */ + for (arr_idx = 0; ; arr_idx++) { + /* XXX: awkward */ + p = duk__load_string_raw(ctx, p); + if (duk_get_length(ctx, -1) == 0) { + duk_pop(ctx); + break; + } + duk_put_prop_index(ctx, -2, arr_idx); + } + duk_compact(ctx, -1); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_FORMALS, DUK_PROPDESC_FLAGS_NONE); + + /* Return with final function pushed on stack top. */ + DUK_DD(DUK_DDPRINT("final loaded function: %!iT", duk_get_tval(ctx, -1))); + DUK_ASSERT_TOP(ctx, idx_base + 1); + return p; + + format_error: + return NULL; +} + +DUK_EXTERNAL void duk_dump_function(duk_context *ctx) { + duk_hthread *thr; + duk_hcompiledfunction *func; + duk_bufwriter_ctx bw_ctx_alloc; + duk_bufwriter_ctx *bw_ctx = &bw_ctx_alloc; + duk_uint8_t *p; + + DUK_ASSERT(ctx != NULL); + thr = (duk_hthread *) ctx; + + /* Bound functions don't have all properties so we'd either need to + * lookup the non-bound target function or reject bound functions. + * For now, bound functions are rejected. + */ + func = duk_require_hcompiledfunction(ctx, -1); + DUK_ASSERT(func != NULL); + DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(&func->obj)); + + /* Estimating the result size beforehand would be costly, so + * start with a reasonable size and extend as needed. + */ + DUK_BW_INIT_PUSHBUF(thr, bw_ctx, DUK__BYTECODE_INITIAL_ALLOC); + p = DUK_BW_GET_PTR(thr, bw_ctx); + *p++ = DUK__SER_MARKER; + *p++ = DUK__SER_VERSION; + p = duk__dump_func(ctx, func, bw_ctx, p); + DUK_BW_SET_PTR(thr, bw_ctx, p); + DUK_BW_COMPACT(thr, bw_ctx); + + DUK_DD(DUK_DDPRINT("serialized result: %!T", duk_get_tval(ctx, -1))); + + duk_remove(ctx, -2); /* [ ... func buf ] -> [ ... buf ] */ +} + +DUK_EXTERNAL void duk_load_function(duk_context *ctx) { + duk_hthread *thr; + duk_uint8_t *p_buf, *p, *p_end; + duk_size_t sz; + + DUK_ASSERT(ctx != NULL); + thr = (duk_hthread *) ctx; + DUK_UNREF(ctx); + + p_buf = (duk_uint8_t *) duk_require_buffer(ctx, -1, &sz); + DUK_ASSERT(p_buf != NULL); + + /* The caller is responsible for being sure that bytecode being loaded + * is valid and trusted. Invalid bytecode can cause memory unsafe + * behavior directly during loading or later during bytecode execution + * (instruction validation would be quite complex to implement). + * + * This signature check is the only sanity check for detecting + * accidental invalid inputs. The initial 0xFF byte ensures no + * ordinary string will be accepted by accident. + */ + p = p_buf; + p_end = p_buf + sz; + if (sz < 2 || p[0] != DUK__SER_MARKER || p[1] != DUK__SER_VERSION) { + goto format_error; + } + p += 2; + + p = duk__load_func(ctx, p, p_end); + if (p == NULL) { + goto format_error; + } + + duk_remove(ctx, -2); /* [ ... buf func ] -> [ ... func ] */ + return; + + format_error: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_DECODE_FAILED); +} + +#undef DUK__SER_MARKER +#undef DUK__SER_VERSION +#undef DUK__SER_STRING +#undef DUK__SER_NUMBER +#undef DUK__BYTECODE_INITIAL_ALLOC + +#else /* DUK_USE_BYTECODE_DUMP_SUPPORT */ + +DUK_EXTERNAL void duk_dump_function(duk_context *ctx) { + DUK_ERROR((duk_hthread *) ctx, DUK_ERR_ERROR, DUK_STR_UNSUPPORTED); +} + +DUK_EXTERNAL void duk_load_function(duk_context *ctx) { + DUK_ERROR((duk_hthread *) ctx, DUK_ERR_ERROR, DUK_STR_UNSUPPORTED); +} + +#endif /* DUK_USE_BYTECODE_DUMP_SUPPORT */ #line 1 "duk_api_call.c" /* * Calls. @@ -12401,6 +15780,8 @@ DUK_EXTERNAL void *duk_resize_buffer(duk_context *ctx, duk_idx_t index, duk_size * May currently throw an error e.g. when getting the property. */ DUK_LOCAL void duk__call_prop_prep_stack(duk_context *ctx, duk_idx_t normalized_obj_index, duk_idx_t nargs) { + DUK_ASSERT_CTX_VALID(ctx); + DUK_DDD(DUK_DDDPRINT("duk__call_prop_prep_stack, normalized_obj_index=%ld, nargs=%ld, stacktop=%ld", (long) normalized_obj_index, (long) nargs, (long) duk_get_top(ctx))); @@ -12428,9 +15809,8 @@ DUK_EXTERNAL void duk_call(duk_context *ctx, duk_idx_t nargs) { duk_hthread *thr = (duk_hthread *) ctx; duk_small_uint_t call_flags; duk_idx_t idx_func; - duk_int_t rc; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr != NULL); idx_func = duk_get_top(ctx) - nargs - 1; @@ -12447,19 +15827,17 @@ DUK_EXTERNAL void duk_call(duk_context *ctx, duk_idx_t nargs) { call_flags = 0; /* not protected, respect reclimit, not constructor */ - rc = duk_handle_call(thr, /* thread */ - nargs, /* num_stack_args */ - call_flags); /* call_flags */ - DUK_UNREF(rc); + duk_handle_call_unprotected(thr, /* thread */ + nargs, /* num_stack_args */ + call_flags); /* call_flags */ } DUK_EXTERNAL void duk_call_method(duk_context *ctx, duk_idx_t nargs) { duk_hthread *thr = (duk_hthread *) ctx; duk_small_uint_t call_flags; duk_idx_t idx_func; - duk_int_t rc; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr != NULL); idx_func = duk_get_top(ctx) - nargs - 2; /* must work for nargs <= 0 */ @@ -12470,10 +15848,9 @@ DUK_EXTERNAL void duk_call_method(duk_context *ctx, duk_idx_t nargs) { call_flags = 0; /* not protected, respect reclimit, not constructor */ - rc = duk_handle_call(thr, /* thread */ - nargs, /* num_stack_args */ - call_flags); /* call_flags */ - DUK_UNREF(rc); + duk_handle_call_unprotected(thr, /* thread */ + nargs, /* num_stack_args */ + call_flags); /* call_flags */ } DUK_EXTERNAL void duk_call_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs) { @@ -12484,6 +15861,8 @@ DUK_EXTERNAL void duk_call_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t * is now done "in-place", so this is not a trivial change. */ + DUK_ASSERT_CTX_VALID(ctx); + obj_index = duk_require_normalize_index(ctx, obj_index); /* make absolute */ duk__call_prop_prep_stack(ctx, obj_index, nargs); @@ -12497,7 +15876,7 @@ DUK_EXTERNAL duk_int_t duk_pcall(duk_context *ctx, duk_idx_t nargs) { duk_idx_t idx_func; duk_int_t rc; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr != NULL); idx_func = duk_get_top(ctx) - nargs - 1; /* must work for nargs <= 0 */ @@ -12520,11 +15899,11 @@ DUK_EXTERNAL duk_int_t duk_pcall(duk_context *ctx, duk_idx_t nargs) { duk_push_undefined(ctx); duk_insert(ctx, idx_func + 1); - call_flags = DUK_CALL_FLAG_PROTECTED; /* protected, respect reclimit, not constructor */ + call_flags = 0; /* respect reclimit, not constructor */ - rc = duk_handle_call(thr, /* thread */ - nargs, /* num_stack_args */ - call_flags); /* call_flags */ + rc = duk_handle_call_protected(thr, /* thread */ + nargs, /* num_stack_args */ + call_flags); /* call_flags */ return rc; } @@ -12535,7 +15914,7 @@ DUK_EXTERNAL duk_int_t duk_pcall_method(duk_context *ctx, duk_idx_t nargs) { duk_idx_t idx_func; duk_int_t rc; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr != NULL); idx_func = duk_get_top(ctx) - nargs - 2; /* must work for nargs <= 0 */ @@ -12545,11 +15924,11 @@ DUK_EXTERNAL duk_int_t duk_pcall_method(duk_context *ctx, duk_idx_t nargs) { return DUK_EXEC_ERROR; /* unreachable */ } - call_flags = DUK_CALL_FLAG_PROTECTED; /* protected, respect reclimit, not constructor */ + call_flags = 0; /* respect reclimit, not constructor */ - rc = duk_handle_call(thr, /* thread */ - nargs, /* num_stack_args */ - call_flags); /* call_flags */ + rc = duk_handle_call_protected(thr, /* thread */ + nargs, /* num_stack_args */ + call_flags); /* call_flags */ return rc; } @@ -12562,6 +15941,8 @@ DUK_LOCAL duk_ret_t duk__pcall_prop_raw(duk_context *ctx) { * index so the stack must have the same top when we use it. */ + DUK_ASSERT_CTX_VALID(ctx); + obj_index = (duk_idx_t) duk_get_int(ctx, -2); nargs = (duk_idx_t) duk_get_int(ctx, -1); duk_pop_2(ctx); @@ -12578,6 +15959,8 @@ DUK_EXTERNAL duk_int_t duk_pcall_prop(duk_context *ctx, duk_idx_t obj_index, duk * and property lookup, not just the call itself. */ + DUK_ASSERT_CTX_VALID(ctx); + duk_push_idx(ctx, obj_index); duk_push_idx(ctx, nargs); @@ -12592,7 +15975,7 @@ DUK_EXTERNAL duk_int_t duk_safe_call(duk_context *ctx, duk_safe_call_function fu duk_hthread *thr = (duk_hthread *) ctx; duk_int_t rc; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr != NULL); if (duk_get_top(ctx) < nargs || nrets < 0) { @@ -12654,7 +16037,8 @@ DUK_EXTERNAL void duk_new(duk_context *ctx, duk_idx_t nargs) { duk_hobject *fallback; duk_idx_t idx_cons; duk_small_uint_t call_flags; - duk_int_t rc; + + DUK_ASSERT_CTX_VALID(ctx); /* [... constructor arg1 ... argN] */ @@ -12746,15 +16130,13 @@ DUK_EXTERNAL void duk_new(duk_context *ctx, duk_idx_t nargs) { call_flags = DUK_CALL_FLAG_CONSTRUCTOR_CALL; /* not protected, respect reclimit, is a constructor call */ - rc = duk_handle_call(thr, /* thread */ - nargs, /* num_stack_args */ - call_flags); /* call_flags */ - DUK_UNREF(rc); + duk_handle_call_unprotected(thr, /* thread */ + nargs, /* num_stack_args */ + call_flags); /* call_flags */ /* [... fallback retval] */ - DUK_DDD(DUK_DDDPRINT("constructor call finished, rc=%ld, fallback=%!iT, retval=%!iT", - (long) rc, + DUK_DDD(DUK_DDDPRINT("constructor call finished, fallback=%!iT, retval=%!iT", (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1))); @@ -12776,6 +16158,7 @@ DUK_EXTERNAL void duk_new(duk_context *ctx, duk_idx_t nargs) { */ #ifdef DUK_USE_AUGMENT_ERROR_CREATE + duk_hthread_sync_currpc(thr); duk_err_augment_error_create(thr, thr, NULL, 0, 1 /*noblame_fileline*/); #endif @@ -12787,11 +16170,39 @@ DUK_EXTERNAL void duk_new(duk_context *ctx, duk_idx_t nargs) { DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_CONSTRUCTABLE); } +DUK_LOCAL duk_ret_t duk__pnew_helper(duk_context *ctx) { + duk_uint_t nargs; + + nargs = duk_to_uint(ctx, -1); + duk_pop(ctx); + + duk_new(ctx, nargs); + return 1; +} + +DUK_EXTERNAL duk_int_t duk_pnew(duk_context *ctx, duk_idx_t nargs) { + duk_int_t rc; + + DUK_ASSERT_CTX_VALID(ctx); + + /* For now, just use duk_safe_call() to wrap duk_new(). We can't + * simply use a protected duk_handle_call() because there's post + * processing which might throw. It should be possible to ensure + * the post processing never throws (except in internal errors and + * out of memory etc which are always allowed) and then remove this + * wrapper. + */ + + duk_push_uint(ctx, nargs); + rc = duk_safe_call(ctx, duk__pnew_helper, nargs + 2 /*nargs*/, 1 /*nrets*/); + return rc; +} + DUK_EXTERNAL duk_bool_t duk_is_constructor_call(duk_context *ctx) { duk_hthread *thr = (duk_hthread *) ctx; duk_activation *act; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr != NULL); DUK_ASSERT_DISABLE(thr->callstack_top >= 0); @@ -12813,7 +16224,7 @@ DUK_EXTERNAL duk_bool_t duk_is_strict_call(duk_context *ctx) { * the internal call sites. */ - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr != NULL); DUK_ASSERT_DISABLE(thr->callstack_top >= 0); @@ -12834,7 +16245,7 @@ DUK_EXTERNAL duk_int_t duk_get_current_magic(duk_context *ctx) { duk_activation *act; duk_hobject *func; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr != NULL); DUK_ASSERT_DISABLE(thr->callstack_top >= 0); @@ -12862,7 +16273,7 @@ DUK_EXTERNAL duk_int_t duk_get_magic(duk_context *ctx, duk_idx_t index) { duk_tval *tv; duk_hobject *h; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_require_tval(ctx, index); if (DUK_TVAL_IS_OBJECT(tv)) { @@ -12886,7 +16297,7 @@ DUK_EXTERNAL duk_int_t duk_get_magic(duk_context *ctx, duk_idx_t index) { DUK_EXTERNAL void duk_set_magic(duk_context *ctx, duk_idx_t index, duk_int_t magic) { duk_hnativefunction *nf; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); nf = duk_require_hnativefunction(ctx, index); DUK_ASSERT(nf != NULL); @@ -12897,18 +16308,89 @@ DUK_EXTERNAL void duk_set_magic(duk_context *ctx, duk_idx_t index, duk_int_t mag * Encoding and decoding basic formats: hex, base64. * * These are in-place operations which may allow an optimized implementation. + * + * Base-64: https://tools.ietf.org/html/rfc4648#section-4 */ /* include removed: duk_internal.h */ -/* dst length must be exactly ceil(len/3)*4 */ -DUK_LOCAL void duk__base64_encode_helper(const duk_uint8_t *src, const duk_uint8_t *src_end, - duk_uint8_t *dst, duk_uint8_t *dst_end) { - duk_small_uint_t i, snip; - duk_uint_fast32_t t; - duk_uint_fast8_t x, y; +/* Shared handling for encode/decode argument. Fast path handling for + * buffer and string values because they're the most common. In particular, + * avoid creating a temporary string or buffer when possible. + */ +DUK_LOCAL const duk_uint8_t *duk__prep_codec_arg(duk_context *ctx, duk_idx_t index, duk_size_t *out_len) { + DUK_ASSERT(duk_is_valid_index(ctx, index)); /* checked by caller */ + if (duk_is_buffer(ctx, index)) { + return (const duk_uint8_t *) duk_get_buffer(ctx, index, out_len); + } else { + return (const duk_uint8_t *) duk_to_lstring(ctx, index, out_len); + } +} - DUK_UNREF(dst_end); +#if defined(DUK_USE_BASE64_FASTPATH) +DUK_LOCAL void duk__base64_encode_helper(const duk_uint8_t *src, duk_size_t srclen, duk_uint8_t *dst) { + duk_uint_t t; + duk_size_t n_full, n_full3, n_final; + const duk_uint8_t *src_end_fast; + + n_full = srclen / 3; /* full 3-byte -> 4-char conversions */ + n_full3 = n_full * 3; + n_final = srclen - n_full3; + DUK_ASSERT_DISABLE(n_final >= 0); + DUK_ASSERT(n_final <= 2); + + src_end_fast = src + n_full3; + while (DUK_UNLIKELY(src != src_end_fast)) { + t = (duk_uint_t) (*src++); + t = (t << 8) + (duk_uint_t) (*src++); + t = (t << 8) + (duk_uint_t) (*src++); + + *dst++ = duk_base64_enctab[t >> 18]; + *dst++ = duk_base64_enctab[(t >> 12) & 0x3f]; + *dst++ = duk_base64_enctab[(t >> 6) & 0x3f]; + *dst++ = duk_base64_enctab[t & 0x3f]; + +#if 0 /* Tested: not faster on x64 */ + /* aaaaaabb bbbbcccc ccdddddd */ + dst[0] = duk_base64_enctab[(src[0] >> 2) & 0x3f]; + dst[1] = duk_base64_enctab[((src[0] << 4) & 0x30) | ((src[1] >> 4) & 0x0f)]; + dst[2] = duk_base64_enctab[((src[1] << 2) & 0x3f) | ((src[2] >> 6) & 0x03)]; + dst[3] = duk_base64_enctab[src[2] & 0x3f]; + src += 3; dst += 4; +#endif + } + + switch (n_final) { + /* case 0: nop */ + case 1: { + /* XX== */ + t = (duk_uint_t) (*src++); + *dst++ = duk_base64_enctab[t >> 2]; /* XXXXXX-- */ + *dst++ = duk_base64_enctab[(t << 4) & 0x3f]; /* ------XX */ + *dst++ = DUK_ASC_EQUALS; + *dst++ = DUK_ASC_EQUALS; + break; + } + case 2: { + /* XXX= */ + t = (duk_uint_t) (*src++); + t = (t << 8) + (duk_uint_t) (*src++); + *dst++ = duk_base64_enctab[t >> 10]; /* XXXXXX-- -------- */ + *dst++ = duk_base64_enctab[(t >> 4) & 0x3f]; /* ------XX XXXX---- */ + *dst++ = duk_base64_enctab[(t << 2) & 0x3f]; /* -------- ----XXXX */ + *dst++ = DUK_ASC_EQUALS; + break; + } + } +} +#else /* DUK_USE_BASE64_FASTPATH */ +DUK_LOCAL void duk__base64_encode_helper(const duk_uint8_t *src, duk_size_t srclen, duk_uint8_t *dst) { + duk_small_uint_t i, snip; + duk_uint_t t; + duk_uint_fast8_t x, y; + const duk_uint8_t *src_end; + + src_end = src + srclen; while (src < src_end) { /* read 3 bytes into 't', padded by zero */ @@ -12919,7 +16401,7 @@ DUK_LOCAL void duk__base64_encode_helper(const duk_uint8_t *src, const duk_uint8 if (src >= src_end) { snip--; } else { - t += (duk_uint_fast32_t) (*src++); + t += (duk_uint_t) (*src++); } } @@ -12953,22 +16435,159 @@ DUK_LOCAL void duk__base64_encode_helper(const duk_uint8_t *src, const duk_uint8 y = '/'; } - DUK_ASSERT(dst < dst_end); *dst++ = (duk_uint8_t) y; } } } +#endif /* DUK_USE_BASE64_FASTPATH */ -DUK_LOCAL duk_bool_t duk__base64_decode_helper(const duk_uint8_t *src, const duk_uint8_t *src_end, - duk_uint8_t *dst, duk_uint8_t *dst_end, duk_uint8_t **out_dst_final) { - duk_uint_fast32_t t; +#if defined(DUK_USE_BASE64_FASTPATH) +DUK_LOCAL duk_bool_t duk__base64_decode_helper(const duk_uint8_t *src, duk_size_t srclen, duk_uint8_t *dst, duk_uint8_t **out_dst_final) { + duk_int_t x; + duk_int_t t; + duk_small_uint_t n_equal; + duk_small_uint_t n_chars; + const duk_uint8_t *src_end; + const duk_uint8_t *src_end_safe; + + src_end = src + srclen; + src_end_safe = src_end - 4; /* if 'src < src_end_safe', safe to read 4 bytes */ + + /* Innermost fast path processes 4 valid base-64 characters at a time + * but bails out on whitespace, padding chars ('=') and invalid chars. + * Once the slow path segment has been processed, we return to the + * inner fast path again. This handles e.g. base64 with newlines + * reasonably well because the majority of a line is in the fast path. + */ + for (;;) { + /* Fast path, handle units with just actual encoding characters. */ + + while (src <= src_end_safe) { + /* The lookup byte is intentionally sign extended to (at least) + * 32 bits and then ORed. This ensures that is at least 1 byte + * is negative, the highest bit of 't' will be set at the end + * and we don't need to check every byte. + */ + DUK_DDD(DUK_DDDPRINT("fast loop: src=%p, src_end_safe=%p, src_end=%p", + (const void *) src, (const void *) src_end_safe, (const void *) src_end)); + + t = (duk_int_t) duk_base64_dectab[*src++]; + t = (t << 6) | (duk_int_t) duk_base64_dectab[*src++]; + t = (t << 6) | (duk_int_t) duk_base64_dectab[*src++]; + t = (t << 6) | (duk_int_t) duk_base64_dectab[*src++]; + + if (DUK_UNLIKELY(t < 0)) { + DUK_DDD(DUK_DDDPRINT("fast loop unit was not clean, process one slow path unit")); + src -= 4; + break; + } + + DUK_ASSERT(t <= 0xffffffL); + DUK_ASSERT((t >> 24) == 0); + *dst++ = (duk_uint8_t) (t >> 16); + *dst++ = (duk_uint8_t) ((t >> 8) & 0xff); + *dst++ = (duk_uint8_t) (t & 0xff); + } + + /* Handle one slow path unit (or finish if we're done). */ + + n_equal = 0; + n_chars = 0; + t = 0; + for (;;) { + DUK_DDD(DUK_DDDPRINT("slow loop: src=%p, src_end=%p, n_chars=%ld, n_equal=%ld, t=%ld", + (const void *) src, (const void *) src_end, (long) n_chars, (long) n_equal, (long) t)); + + if (DUK_UNLIKELY(src >= src_end)) { + goto done; /* two level break */ + } + + x = duk_base64_dectab[*src++]; + if (DUK_UNLIKELY(x < 0)) { + if (x == -2) { + continue; /* allowed ascii whitespace */ + } else if (x == -3) { + n_equal++; + t <<= 6; + } else { + DUK_ASSERT(x == -1); + goto error; + } + } else { + DUK_ASSERT(x >= 0 && x <= 63); + if (n_equal > 0) { + /* Don't allow actual chars after equal sign. */ + goto error; + } + t = (t << 6) + x; + } + + if (DUK_UNLIKELY(n_chars == 3)) { + /* Emit 3 bytes and backtrack if there was padding. There's + * always space for the whole 3 bytes so no check needed. + */ + DUK_ASSERT(t <= 0xffffffL); + DUK_ASSERT((t >> 24) == 0); + *dst++ = (duk_uint8_t) (t >> 16); + *dst++ = (duk_uint8_t) ((t >> 8) & 0xff); + *dst++ = (duk_uint8_t) (t & 0xff); + + if (DUK_UNLIKELY(n_equal > 0)) { + DUK_ASSERT(n_equal <= 4); + + /* There may be whitespace between the equal signs. */ + if (n_equal == 1) { + /* XXX= */ + dst -= 1; + } else if (n_equal == 2) { + /* XX== */ + dst -= 2; + } else { + goto error; /* invalid padding */ + } + + /* Continue parsing after padding, allows concatenated, + * padded base64. + */ + } + break; /* back to fast loop */ + } else { + n_chars++; + } + } + } + done: + DUK_DDD(DUK_DDDPRINT("done; src=%p, src_end=%p, n_chars=%ld", + (const void *) src, (const void *) src_end, (long) n_chars)); + + DUK_ASSERT(src == src_end); + + if (n_chars != 0) { + /* Here we'd have the option of decoding unpadded base64 + * (e.g. "xxxxyy" instead of "xxxxyy==". Currently not + * accepted. + */ + goto error; + } + + *out_dst_final = dst; + return 1; + + error: + return 0; +} +#else /* DUK_USE_BASE64_FASTPATH */ +DUK_LOCAL duk_bool_t duk__base64_decode_helper(const duk_uint8_t *src, duk_size_t srclen, duk_uint8_t *dst, duk_uint8_t **out_dst_final) { + duk_uint_t t; duk_uint_fast8_t x, y; duk_small_uint_t group_idx; + duk_small_uint_t n_equal; + const duk_uint8_t *src_end; - DUK_UNREF(dst_end); - + src_end = src + srclen; t = 0; group_idx = 0; + n_equal = 0; while (src < src_end) { x = *src++; @@ -12984,42 +16603,14 @@ DUK_LOCAL duk_bool_t duk__base64_decode_helper(const duk_uint8_t *src, const duk } else if (x == '/') { y = 63; } else if (x == '=') { - /* We don't check the zero padding bytes here right now. - * This seems to be common behavior for base-64 decoders. + /* We don't check the zero padding bytes here right now + * (that they're actually zero). This seems to be common + * behavior for base-64 decoders. */ - if (group_idx == 2) { - /* xx== -> 1 byte, t contains 12 bits, 4 on right are zero */ - t = t >> 4; - DUK_ASSERT(dst < dst_end); - *dst++ = (duk_uint8_t) t; - - if (src >= src_end) { - goto error; - } - x = *src++; - if (x != '=') { - goto error; - } - } else if (group_idx == 3) { - /* xxx= -> 2 bytes, t contains 18 bits, 2 on right are zero */ - t = t >> 2; - DUK_ASSERT(dst < dst_end); - *dst++ = (duk_uint8_t) ((t >> 8) & 0xff); - DUK_ASSERT(dst < dst_end); - *dst++ = (duk_uint8_t) (t & 0xff); - } else { - goto error; - } - - /* Here we can choose either to end parsing and ignore - * whatever follows, or to continue parsing in case - * multiple (possibly padded) base64 strings have been - * concatenated. Currently, keep on parsing. - */ - t = 0; - group_idx = 0; - continue; + n_equal++; + t <<= 6; /* shift in zeroes */ + goto skip_add; } else if (x == 0x09 || x == 0x0a || x == 0x0d || x == 0x20) { /* allow basic ASCII whitespace */ continue; @@ -13027,16 +16618,38 @@ DUK_LOCAL duk_bool_t duk__base64_decode_helper(const duk_uint8_t *src, const duk goto error; } + if (n_equal > 0) { + /* Don't allow mixed padding and actual chars. */ + goto error; + } t = (t << 6) + y; + skip_add: if (group_idx == 3) { /* output 3 bytes from 't' */ - DUK_ASSERT(dst < dst_end); *dst++ = (duk_uint8_t) ((t >> 16) & 0xff); - DUK_ASSERT(dst < dst_end); *dst++ = (duk_uint8_t) ((t >> 8) & 0xff); - DUK_ASSERT(dst < dst_end); *dst++ = (duk_uint8_t) (t & 0xff); + + if (DUK_UNLIKELY(n_equal > 0)) { + /* Backtrack. */ + DUK_ASSERT(n_equal <= 4); + if (n_equal == 1) { + dst -= 1; + } else if (n_equal == 2) { + dst -= 2; + } else { + goto error; /* invalid padding */ + } + + /* Here we can choose either to end parsing and ignore + * whatever follows, or to continue parsing in case + * multiple (possibly padded) base64 strings have been + * concatenated. Currently, keep on parsing. + */ + n_equal = 0; + } + t = 0; group_idx = 0; } else { @@ -13058,34 +16671,24 @@ DUK_LOCAL duk_bool_t duk__base64_decode_helper(const duk_uint8_t *src, const duk error: return 0; } - -/* Shared handling for encode/decode argument. Fast path handling for - * buffer and string values because they're the most common. In particular, - * avoid creating a temporary string or buffer when possible. - */ -DUK_LOCAL const duk_uint8_t *duk__prep_codec_arg(duk_context *ctx, duk_idx_t index, duk_size_t *out_len) { - DUK_ASSERT(duk_is_valid_index(ctx, index)); /* checked by caller */ - if (duk_is_buffer(ctx, index)) { - return (const duk_uint8_t *) duk_get_buffer(ctx, index, out_len); - } else { - return (const duk_uint8_t *) duk_to_lstring(ctx, index, out_len); - } -} +#endif /* DUK_USE_BASE64_FASTPATH */ DUK_EXTERNAL const char *duk_base64_encode(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; - duk_uint8_t *src; + const duk_uint8_t *src; duk_size_t srclen; duk_size_t dstlen; duk_uint8_t *dst; const char *ret; + DUK_ASSERT_CTX_VALID(ctx); + /* XXX: optimize for string inputs: no need to coerce to a buffer * which makes a copy of the input. */ index = duk_require_normalize_index(ctx, index); - src = (duk_uint8_t *) duk_to_buffer(ctx, index, &srclen); + src = duk__prep_codec_arg(ctx, index, &srclen); /* Note: for srclen=0, src may be NULL */ /* Computation must not wrap; this limit works for 32-bit size_t: @@ -13099,15 +16702,14 @@ DUK_EXTERNAL const char *duk_base64_encode(duk_context *ctx, duk_idx_t index) { dstlen = (srclen + 2) / 3 * 4; dst = (duk_uint8_t *) duk_push_fixed_buffer(ctx, dstlen); - duk__base64_encode_helper((const duk_uint8_t *) src, (const duk_uint8_t *) (src + srclen), - dst, (dst + dstlen)); + duk__base64_encode_helper((const duk_uint8_t *) src, srclen, dst); ret = duk_to_string(ctx, -1); duk_replace(ctx, index); return ret; type_error: - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_BASE64_ENCODE_FAILED); + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_ENCODE_FAILED); return NULL; /* never here */ } @@ -13120,12 +16722,14 @@ DUK_EXTERNAL void duk_base64_decode(duk_context *ctx, duk_idx_t index) { duk_uint8_t *dst_final; duk_bool_t retval; + DUK_ASSERT_CTX_VALID(ctx); + /* XXX: optimize for buffer inputs: no need to coerce to a string * which causes an unnecessary interning. */ index = duk_require_normalize_index(ctx, index); - src = (const duk_uint8_t *) duk_to_lstring(ctx, index, &srclen); + src = duk__prep_codec_arg(ctx, index, &srclen); /* Computation must not wrap, only srclen + 3 is at risk of * wrapping because after that the number gets smaller. @@ -13135,12 +16739,11 @@ DUK_EXTERNAL void duk_base64_decode(duk_context *ctx, duk_idx_t index) { if (srclen > 4294967292UL) { goto type_error; } - dstlen = (srclen + 3) / 4 * 3; /* upper limit */ + dstlen = (srclen + 3) / 4 * 3; /* upper limit, assuming no whitespace etc */ dst = (duk_uint8_t *) duk_push_dynamic_buffer(ctx, dstlen); /* Note: for dstlen=0, dst may be NULL */ - retval = duk__base64_decode_helper((const duk_uint8_t *) src, (const duk_uint8_t *) (src + srclen), - dst, dst + dstlen, &dst_final); + retval = duk__base64_decode_helper((const duk_uint8_t *) src, srclen, dst, &dst_final); if (!retval) { goto type_error; } @@ -13151,16 +16754,21 @@ DUK_EXTERNAL void duk_base64_decode(duk_context *ctx, duk_idx_t index) { return; type_error: - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_BASE64_DECODE_FAILED); + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_DECODE_FAILED); } DUK_EXTERNAL const char *duk_hex_encode(duk_context *ctx, duk_idx_t index) { const duk_uint8_t *inp; duk_size_t len; duk_size_t i; - duk_small_uint_t t; duk_uint8_t *buf; const char *ret; +#if defined(DUK_USE_HEX_FASTPATH) + duk_size_t len_safe; + duk_uint16_t *p16; +#endif + + DUK_ASSERT_CTX_VALID(ctx); index = duk_require_normalize_index(ctx, index); inp = duk__prep_codec_arg(ctx, index, &len); @@ -13170,18 +16778,34 @@ DUK_EXTERNAL const char *duk_hex_encode(duk_context *ctx, duk_idx_t index) { buf = (duk_uint8_t *) duk_push_buffer_raw(ctx, len * 2, DUK_BUF_FLAG_NOZERO /*flags*/); DUK_ASSERT(buf != NULL); +#if defined(DUK_USE_HEX_FASTPATH) + DUK_ASSERT((((duk_uintptr_t) buf) & 0x01U) == 0); /* pointer is aligned, guaranteed for fixed buffer */ + p16 = (duk_uint16_t *) (void *) buf; + len_safe = len & ~0x03U; + for (i = 0; i < len_safe; i += 4) { + p16[0] = duk_hex_enctab[inp[i]]; + p16[1] = duk_hex_enctab[inp[i + 1]]; + p16[2] = duk_hex_enctab[inp[i + 2]]; + p16[3] = duk_hex_enctab[inp[i + 3]]; + p16 += 4; + } + for (; i < len; i++) { + *p16++ = duk_hex_enctab[inp[i]]; + } +#else /* DUK_USE_HEX_FASTPATH */ for (i = 0; i < len; i++) { - /* XXX: by using two 256-entry tables could avoid shifting and masking. */ + duk_small_uint_t t; t = (duk_small_uint_t) inp[i]; buf[i*2 + 0] = duk_lc_digits[t >> 4]; buf[i*2 + 1] = duk_lc_digits[t & 0x0f]; } +#endif /* DUK_USE_HEX_FASTPATH */ /* XXX: Using a string return value forces a string intern which is * not always necessary. As a rough performance measure, hex encode - * time for perf-testcases/test-hex-encode.js dropped from ~35s to - * ~15s without string coercion. Change to returning a buffer and - * let the caller coerce to string if necessary? + * time for tests/perf/test-hex-encode.js dropped from ~35s to ~15s + * without string coercion. Change to returning a buffer and let the + * caller coerce to string if necessary? */ ret = duk_to_string(ctx, -1); @@ -13194,8 +16818,15 @@ DUK_EXTERNAL void duk_hex_decode(duk_context *ctx, duk_idx_t index) { const duk_uint8_t *inp; duk_size_t len; duk_size_t i; - duk_small_int_t t; + duk_int_t t; duk_uint8_t *buf; +#if defined(DUK_USE_HEX_FASTPATH) + duk_int_t chk; + duk_uint8_t *p; + duk_size_t len_safe; +#endif + + DUK_ASSERT_CTX_VALID(ctx); index = duk_require_normalize_index(ctx, index); inp = duk__prep_codec_arg(ctx, index, &len); @@ -13209,32 +16840,74 @@ DUK_EXTERNAL void duk_hex_decode(duk_context *ctx, duk_idx_t index) { buf = (duk_uint8_t *) duk_push_buffer_raw(ctx, len / 2, DUK_BUF_FLAG_NOZERO /*flags*/); DUK_ASSERT(buf != NULL); +#if defined(DUK_USE_HEX_FASTPATH) + p = buf; + len_safe = len & ~0x07U; + for (i = 0; i < len_safe; i += 8) { + t = ((duk_int_t) duk_hex_dectab_shift4[inp[i]]) | + ((duk_int_t) duk_hex_dectab[inp[i + 1]]); + chk = t; + p[0] = (duk_uint8_t) t; + t = ((duk_int_t) duk_hex_dectab_shift4[inp[i + 2]]) | + ((duk_int_t) duk_hex_dectab[inp[i + 3]]); + chk |= t; + p[1] = (duk_uint8_t) t; + t = ((duk_int_t) duk_hex_dectab_shift4[inp[i + 4]]) | + ((duk_int_t) duk_hex_dectab[inp[i + 5]]); + chk |= t; + p[2] = (duk_uint8_t) t; + t = ((duk_int_t) duk_hex_dectab_shift4[inp[i + 6]]) | + ((duk_int_t) duk_hex_dectab[inp[i + 7]]); + chk |= t; + p[3] = (duk_uint8_t) t; + p += 4; + + /* Check if any lookup above had a negative result. */ + if (DUK_UNLIKELY(chk < 0)) { + goto type_error; + } + } + for (; i < len; i += 2) { + t = (((duk_int_t) duk_hex_dectab[inp[i]]) << 4) | + ((duk_int_t) duk_hex_dectab[inp[i + 1]]); + if (DUK_UNLIKELY(t < 0)) { + goto type_error; + } + *p++ = (duk_uint8_t) t; + } +#else /* DUK_USE_HEX_FASTPATH */ for (i = 0; i < len; i += 2) { /* For invalid characters the value -1 gets extended to * at least 16 bits. If either nybble is invalid, the * resulting 't' will be < 0. */ - t = (((duk_small_int_t) duk_hex_dectab[inp[i]]) << 4) | - ((duk_small_int_t) duk_hex_dectab[inp[i + 1]]); + t = (((duk_int_t) duk_hex_dectab[inp[i]]) << 4) | + ((duk_int_t) duk_hex_dectab[inp[i + 1]]); if (DUK_UNLIKELY(t < 0)) { goto type_error; } buf[i >> 1] = (duk_uint8_t) t; } +#endif /* DUK_USE_HEX_FASTPATH */ duk_replace(ctx, index); return; type_error: - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_HEX_DECODE_FAILED); + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_DECODE_FAILED); } DUK_EXTERNAL const char *duk_json_encode(duk_context *ctx, duk_idx_t index) { #ifdef DUK_USE_ASSERTIONS - duk_idx_t top_at_entry = duk_get_top(ctx); + duk_idx_t top_at_entry; #endif const char *ret; + DUK_ASSERT_CTX_VALID(ctx); +#ifdef DUK_USE_ASSERTIONS + top_at_entry = duk_get_top(ctx); +#endif + index = duk_require_normalize_index(ctx, index); duk_bi_json_stringify_helper(ctx, index /*idx_value*/, @@ -13252,7 +16925,12 @@ DUK_EXTERNAL const char *duk_json_encode(duk_context *ctx, duk_idx_t index) { DUK_EXTERNAL void duk_json_decode(duk_context *ctx, duk_idx_t index) { #ifdef DUK_USE_ASSERTIONS - duk_idx_t top_at_entry = duk_get_top(ctx); + duk_idx_t top_at_entry; +#endif + + DUK_ASSERT_CTX_VALID(ctx); +#ifdef DUK_USE_ASSERTIONS + top_at_entry = duk_get_top(ctx); #endif index = duk_require_normalize_index(ctx, index); @@ -13283,11 +16961,13 @@ DUK_EXTERNAL duk_int_t duk_eval_raw(duk_context *ctx, const char *src_buffer, du duk_uint_t comp_flags; duk_int_t rc; + DUK_ASSERT_CTX_VALID(ctx); + /* Note: strictness is *not* inherited from the current Duktape/C. * This would be confusing because the current strictness state * depends on whether we're running inside a Duktape/C activation * (= strict mode) or outside of any activation (= non-strict mode). - * See api-testcases/test-eval-strictness.c for more discussion. + * See tests/api/test-eval-strictness.c for more discussion. */ /* [ ... source? filename ] (depends on flags) */ @@ -13303,10 +16983,12 @@ DUK_EXTERNAL duk_int_t duk_eval_raw(duk_context *ctx, const char *src_buffer, du goto got_rc; } + duk_push_global_object(ctx); /* explicit 'this' binding, see GH-164 */ + if (flags & DUK_COMPILE_SAFE) { - rc = duk_pcall(ctx, 0); + rc = duk_pcall_method(ctx, 0); } else { - duk_call(ctx, 0); + duk_call_method(ctx, 0); rc = DUK_EXEC_SUCCESS; } @@ -13328,10 +17010,12 @@ DUK_LOCAL duk_ret_t duk__do_compile(duk_context *ctx) { duk_small_uint_t comp_flags; duk_hcompiledfunction *h_templ; + DUK_ASSERT_CTX_VALID(ctx); + /* Note: strictness is not inherited from the current Duktape/C * context. Otherwise it would not be possible to compile * non-strict code inside a Duktape/C activation (which is - * always strict now). See api-testcases/test-eval-strictness.c + * always strict now). See tests/api/test-eval-strictness.c * for discussion. */ @@ -13348,12 +17032,12 @@ DUK_LOCAL duk_ret_t duk__do_compile(duk_context *ctx) { h_sourcecode = duk_get_hstring(ctx, -2); if ((flags & DUK_COMPILE_NOSOURCE) || /* args incorrect */ - (h_sourcecode == NULL)) { /* e.g. duk_push_file_string_raw() pushed undefined */ + (h_sourcecode == NULL)) { /* e.g. duk_push_string_file_raw() pushed undefined */ /* XXX: when this error is caused by a nonexistent * file given to duk_peval_file() or similar, the * error message is not the best possible. */ - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_NO_SOURCECODE); + DUK_ERROR_API(thr, DUK_STR_NO_SOURCECODE); } DUK_ASSERT(h_sourcecode != NULL); comp_args->src_buffer = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_sourcecode); @@ -13405,6 +17089,8 @@ DUK_EXTERNAL duk_int_t duk_compile_raw(duk_context *ctx, const char *src_buffer, duk__compile_raw_args comp_args_alloc; duk__compile_raw_args *comp_args = &comp_args_alloc; + DUK_ASSERT_CTX_VALID(ctx); + if ((flags & DUK_COMPILE_STRLEN) && (src_buffer != NULL)) { /* String length is computed here to avoid multiple evaluation * of a macro argument in the calling side. @@ -13448,6 +17134,8 @@ DUK_EXTERNAL void duk_push_context_dump(duk_context *ctx) { duk_idx_t idx; duk_idx_t top; + DUK_ASSERT_CTX_VALID(ctx); + /* We don't duk_require_stack() here now, but rely on the caller having * enough space. */ @@ -13491,7 +17179,11 @@ DUK_EXTERNAL void duk_debugger_attach(duk_context *ctx, const char *str; duk_size_t len; - DUK_ASSERT(ctx != NULL); + /* XXX: should there be an error or an automatic detach if + * already attached? + */ + + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(read_cb != NULL); DUK_ASSERT(write_cb != NULL); /* Other callbacks are optional. */ @@ -13504,11 +17196,13 @@ DUK_EXTERNAL void duk_debugger_attach(duk_context *ctx, heap->dbg_write_flush_cb = write_flush_cb; heap->dbg_detached_cb = detached_cb; heap->dbg_udata = udata; + heap->dbg_have_next_byte = 0; /* Start in paused state. */ heap->dbg_processing = 0; heap->dbg_paused = 1; heap->dbg_state_dirty = 1; + heap->dbg_force_restart = 0; heap->dbg_step_type = 0; heap->dbg_step_thread = NULL; heap->dbg_step_csindex = 0; @@ -13535,12 +17229,12 @@ DUK_EXTERNAL void duk_debugger_attach(duk_context *ctx, DUK_EXTERNAL void duk_debugger_detach(duk_context *ctx) { duk_hthread *thr; + DUK_ASSERT_CTX_VALID(ctx); thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); DUK_ASSERT(thr != NULL); DUK_ASSERT(thr->heap != NULL); - /* Can be called muliple times with no harm. */ + /* Can be called multiple times with no harm. */ duk_debug_do_detach(thr->heap); } @@ -13548,8 +17242,8 @@ DUK_EXTERNAL void duk_debugger_cooperate(duk_context *ctx) { duk_hthread *thr; duk_bool_t processed_messages; + DUK_ASSERT_CTX_VALID(ctx); thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); DUK_ASSERT(thr != NULL); DUK_ASSERT(thr->heap != NULL); @@ -13580,6 +17274,7 @@ DUK_EXTERNAL void duk_debugger_attach(duk_context *ctx, duk_debug_write_flush_function write_flush_cb, duk_debug_detached_function detached_cb, void *udata) { + DUK_ASSERT_CTX_VALID(ctx); DUK_UNREF(read_cb); DUK_UNREF(write_cb); DUK_UNREF(peek_cb); @@ -13587,15 +17282,17 @@ DUK_EXTERNAL void duk_debugger_attach(duk_context *ctx, DUK_UNREF(write_flush_cb); DUK_UNREF(detached_cb); DUK_UNREF(udata); - duk_error(ctx, DUK_ERR_API_ERROR, "no debugger support"); + DUK_ERROR_API((duk_hthread *) ctx, "no debugger support"); } DUK_EXTERNAL void duk_debugger_detach(duk_context *ctx) { - duk_error(ctx, DUK_ERR_API_ERROR, "no debugger support"); + DUK_ASSERT_CTX_VALID(ctx); + DUK_ERROR_API((duk_hthread *) ctx, "no debugger support"); } DUK_EXTERNAL void duk_debugger_cooperate(duk_context *ctx) { /* nop */ + DUK_ASSERT_CTX_VALID(ctx); DUK_UNREF(ctx); } @@ -13685,6 +17382,7 @@ DUK_EXTERNAL void duk_set_global_object(duk_context *ctx) { */ h_prev_glob = thr->builtins[DUK_BIDX_GLOBAL]; + DUK_UNREF(h_prev_glob); thr->builtins[DUK_BIDX_GLOBAL] = h_glob; DUK_HOBJECT_INCREF(thr, h_glob); DUK_HOBJECT_DECREF_ALLOWNULL(thr, h_prev_glob); /* side effects, in theory (referenced by global env) */ @@ -13747,6 +17445,8 @@ DUK_EXTERNAL void duk_log_va(duk_context *ctx, duk_int_t level, const char *fmt, DUK_STRIDX_LC_WARN, DUK_STRIDX_LC_ERROR, DUK_STRIDX_LC_FATAL }; + DUK_ASSERT_CTX_VALID(ctx); + if (level < 0) { level = 0; } else if (level > (int) (sizeof(stridx_logfunc) / sizeof(duk_uint16_t)) - 1) { @@ -13774,6 +17474,8 @@ DUK_EXTERNAL void duk_log_va(duk_context *ctx, duk_int_t level, const char *fmt, DUK_EXTERNAL void duk_log(duk_context *ctx, duk_int_t level, const char *fmt, ...) { va_list ap; + DUK_ASSERT_CTX_VALID(ctx); + va_start(ap, fmt); duk_log_va(ctx, level, fmt, ap); va_end(ap); @@ -13788,7 +17490,7 @@ DUK_EXTERNAL void duk_log(duk_context *ctx, duk_int_t level, const char *fmt, .. DUK_EXTERNAL void *duk_alloc_raw(duk_context *ctx, duk_size_t size) { duk_hthread *thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); return DUK_ALLOC_RAW(thr->heap, size); } @@ -13796,7 +17498,7 @@ DUK_EXTERNAL void *duk_alloc_raw(duk_context *ctx, duk_size_t size) { DUK_EXTERNAL void duk_free_raw(duk_context *ctx, void *ptr) { duk_hthread *thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_FREE_RAW(thr->heap, ptr); } @@ -13804,7 +17506,7 @@ DUK_EXTERNAL void duk_free_raw(duk_context *ctx, void *ptr) { DUK_EXTERNAL void *duk_realloc_raw(duk_context *ctx, void *ptr, duk_size_t size) { duk_hthread *thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); return DUK_REALLOC_RAW(thr->heap, ptr, size); } @@ -13812,7 +17514,7 @@ DUK_EXTERNAL void *duk_realloc_raw(duk_context *ctx, void *ptr, duk_size_t size) DUK_EXTERNAL void *duk_alloc(duk_context *ctx, duk_size_t size) { duk_hthread *thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); return DUK_ALLOC(thr->heap, size); } @@ -13820,7 +17522,7 @@ DUK_EXTERNAL void *duk_alloc(duk_context *ctx, duk_size_t size) { DUK_EXTERNAL void duk_free(duk_context *ctx, void *ptr) { duk_hthread *thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_FREE(thr->heap, ptr); } @@ -13828,7 +17530,7 @@ DUK_EXTERNAL void duk_free(duk_context *ctx, void *ptr) { DUK_EXTERNAL void *duk_realloc(duk_context *ctx, void *ptr, duk_size_t size) { duk_hthread *thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); /* * Note: since this is an exposed API call, there should be @@ -13847,7 +17549,7 @@ DUK_EXTERNAL void duk_get_memory_functions(duk_context *ctx, duk_memory_function duk_hthread *thr = (duk_hthread *) ctx; duk_heap *heap; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(out_funcs != NULL); DUK_ASSERT(thr != NULL); DUK_ASSERT(thr->heap != NULL); @@ -13866,9 +17568,11 @@ DUK_EXTERNAL void duk_gc(duk_context *ctx, duk_uint_t flags) { DUK_UNREF(flags); + /* NULL accepted */ if (!ctx) { return; } + DUK_ASSERT_CTX_VALID(ctx); heap = thr->heap; DUK_ASSERT(heap != NULL); @@ -13901,7 +17605,7 @@ DUK_EXTERNAL duk_bool_t duk_get_prop(duk_context *ctx, duk_idx_t obj_index) { duk_tval *tv_key; duk_bool_t rc; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); /* Note: copying tv_obj and tv_key to locals to shield against a valstack * resize is not necessary for a property get right now. @@ -13919,7 +17623,7 @@ DUK_EXTERNAL duk_bool_t duk_get_prop(duk_context *ctx, duk_idx_t obj_index) { } DUK_EXTERNAL duk_bool_t duk_get_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(key != NULL); obj_index = duk_require_normalize_index(ctx, obj_index); @@ -13928,7 +17632,7 @@ DUK_EXTERNAL duk_bool_t duk_get_prop_string(duk_context *ctx, duk_idx_t obj_inde } DUK_EXTERNAL duk_bool_t duk_get_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); obj_index = duk_require_normalize_index(ctx, obj_index); duk_push_uarridx(ctx, arr_index); @@ -13938,7 +17642,7 @@ DUK_EXTERNAL duk_bool_t duk_get_prop_index(duk_context *ctx, duk_idx_t obj_index DUK_INTERNAL duk_bool_t duk_get_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx) { duk_hthread *thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT_DISABLE(stridx >= 0); DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); @@ -13950,7 +17654,7 @@ DUK_INTERNAL duk_bool_t duk_get_prop_stridx(duk_context *ctx, duk_idx_t obj_inde DUK_INTERNAL duk_bool_t duk_get_prop_stridx_boolean(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_bool_t *out_has_prop) { duk_bool_t rc; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT_DISABLE(stridx >= 0); DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); @@ -13972,7 +17676,7 @@ DUK_EXTERNAL duk_bool_t duk_put_prop(duk_context *ctx, duk_idx_t obj_index) { duk_small_int_t throw_flag; duk_bool_t rc; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); /* Note: copying tv_obj and tv_key to locals to shield against a valstack * resize is not necessary for a property put right now (putprop protects @@ -13992,7 +17696,7 @@ DUK_EXTERNAL duk_bool_t duk_put_prop(duk_context *ctx, duk_idx_t obj_index) { } DUK_EXTERNAL duk_bool_t duk_put_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(key != NULL); obj_index = duk_require_normalize_index(ctx, obj_index); @@ -14002,7 +17706,7 @@ DUK_EXTERNAL duk_bool_t duk_put_prop_string(duk_context *ctx, duk_idx_t obj_inde } DUK_EXTERNAL duk_bool_t duk_put_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); obj_index = duk_require_normalize_index(ctx, obj_index); duk_push_uarridx(ctx, arr_index); @@ -14013,7 +17717,7 @@ DUK_EXTERNAL duk_bool_t duk_put_prop_index(duk_context *ctx, duk_idx_t obj_index DUK_INTERNAL duk_bool_t duk_put_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx) { duk_hthread *thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT_DISABLE(stridx >= 0); DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); @@ -14030,7 +17734,7 @@ DUK_EXTERNAL duk_bool_t duk_del_prop(duk_context *ctx, duk_idx_t obj_index) { duk_small_int_t throw_flag; duk_bool_t rc; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); /* Note: copying tv_obj and tv_key to locals to shield against a valstack * resize is not necessary for a property delete right now. @@ -14048,7 +17752,7 @@ DUK_EXTERNAL duk_bool_t duk_del_prop(duk_context *ctx, duk_idx_t obj_index) { } DUK_EXTERNAL duk_bool_t duk_del_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(key != NULL); obj_index = duk_require_normalize_index(ctx, obj_index); @@ -14057,7 +17761,7 @@ DUK_EXTERNAL duk_bool_t duk_del_prop_string(duk_context *ctx, duk_idx_t obj_inde } DUK_EXTERNAL duk_bool_t duk_del_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); obj_index = duk_require_normalize_index(ctx, obj_index); duk_push_uarridx(ctx, arr_index); @@ -14067,7 +17771,7 @@ DUK_EXTERNAL duk_bool_t duk_del_prop_index(duk_context *ctx, duk_idx_t obj_index DUK_INTERNAL duk_bool_t duk_del_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx) { duk_hthread *thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT_DISABLE(stridx >= 0); DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); @@ -14082,7 +17786,7 @@ DUK_EXTERNAL duk_bool_t duk_has_prop(duk_context *ctx, duk_idx_t obj_index) { duk_tval *tv_key; duk_bool_t rc; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); /* Note: copying tv_obj and tv_key to locals to shield against a valstack * resize is not necessary for a property existence check right now. @@ -14099,7 +17803,7 @@ DUK_EXTERNAL duk_bool_t duk_has_prop(duk_context *ctx, duk_idx_t obj_index) { } DUK_EXTERNAL duk_bool_t duk_has_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(key != NULL); obj_index = duk_require_normalize_index(ctx, obj_index); @@ -14108,7 +17812,7 @@ DUK_EXTERNAL duk_bool_t duk_has_prop_string(duk_context *ctx, duk_idx_t obj_inde } DUK_EXTERNAL duk_bool_t duk_has_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); obj_index = duk_require_normalize_index(ctx, obj_index); duk_push_uarridx(ctx, arr_index); @@ -14118,7 +17822,7 @@ DUK_EXTERNAL duk_bool_t duk_has_prop_index(duk_context *ctx, duk_idx_t obj_index DUK_INTERNAL duk_bool_t duk_has_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx) { duk_hthread *thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT_DISABLE(stridx >= 0); DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); @@ -14137,7 +17841,7 @@ DUK_INTERNAL void duk_xdef_prop(duk_context *ctx, duk_idx_t obj_index, duk_small duk_hobject *obj; duk_hstring *key; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); obj = duk_require_hobject(ctx, obj_index); DUK_ASSERT(obj != NULL); @@ -14154,7 +17858,7 @@ DUK_INTERNAL void duk_xdef_prop_index(duk_context *ctx, duk_idx_t obj_index, duk duk_hthread *thr = (duk_hthread *) ctx; duk_hobject *obj; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); obj = duk_require_hobject(ctx, obj_index); DUK_ASSERT(obj != NULL); @@ -14168,7 +17872,7 @@ DUK_INTERNAL void duk_xdef_prop_stridx(duk_context *ctx, duk_idx_t obj_index, du duk_hobject *obj; duk_hstring *key; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT_DISABLE(stridx >= 0); DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); @@ -14187,7 +17891,7 @@ DUK_INTERNAL void duk_xdef_prop_stridx_builtin(duk_context *ctx, duk_idx_t obj_i duk_hobject *obj; duk_hstring *key; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT_DISABLE(stridx >= 0); DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); DUK_ASSERT_DISABLE(builtin_idx >= 0); @@ -14227,6 +17931,8 @@ DUK_EXTERNAL void duk_def_prop(duk_context *ctx, duk_idx_t obj_index, duk_uint_t duk_uint_t is_data_desc; duk_uint_t is_acc_desc; + DUK_ASSERT_CTX_VALID(ctx); + obj = duk_require_hobject(ctx, obj_index); is_data_desc = flags & (DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_HAVE_WRITABLE); @@ -14310,7 +18016,7 @@ DUK_EXTERNAL void duk_compact(duk_context *ctx, duk_idx_t obj_index) { duk_hthread *thr = (duk_hthread *) ctx; duk_hobject *obj; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); obj = duk_get_hobject(ctx, obj_index); if (obj) { @@ -14322,7 +18028,7 @@ DUK_EXTERNAL void duk_compact(duk_context *ctx, duk_idx_t obj_index) { /* XXX: the duk_hobject_enum.c stack APIs should be reworked */ DUK_EXTERNAL void duk_enum(duk_context *ctx, duk_idx_t obj_index, duk_uint_t enum_flags) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); duk_dup(ctx, obj_index); duk_require_hobject_or_lfunc_coerce(ctx, -1); @@ -14330,7 +18036,7 @@ DUK_EXTERNAL void duk_enum(duk_context *ctx, duk_idx_t obj_index, duk_uint_t enu } DUK_EXTERNAL duk_bool_t duk_next(duk_context *ctx, duk_idx_t enum_index, duk_bool_t get_value) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); duk_require_hobject(ctx, enum_index); duk_dup(ctx, enum_index); @@ -14344,7 +18050,7 @@ DUK_EXTERNAL duk_bool_t duk_next(duk_context *ctx, duk_idx_t enum_index, duk_boo DUK_EXTERNAL void duk_put_function_list(duk_context *ctx, duk_idx_t obj_index, const duk_function_list_entry *funcs) { const duk_function_list_entry *ent = funcs; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); obj_index = duk_require_normalize_index(ctx, obj_index); if (ent != NULL) { @@ -14359,7 +18065,7 @@ DUK_EXTERNAL void duk_put_function_list(duk_context *ctx, duk_idx_t obj_index, c DUK_EXTERNAL void duk_put_number_list(duk_context *ctx, duk_idx_t obj_index, const duk_number_list_entry *numbers) { const duk_number_list_entry *ent = numbers; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); obj_index = duk_require_normalize_index(ctx, obj_index); if (ent != NULL) { @@ -14379,7 +18085,7 @@ DUK_EXTERNAL duk_bool_t duk_get_global_string(duk_context *ctx, const char *key) duk_hthread *thr = (duk_hthread *) ctx; duk_bool_t ret; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL] != NULL); /* XXX: direct implementation */ @@ -14394,7 +18100,7 @@ DUK_EXTERNAL duk_bool_t duk_put_global_string(duk_context *ctx, const char *key) duk_hthread *thr = (duk_hthread *) ctx; duk_bool_t ret; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL] != NULL); /* XXX: direct implementation */ @@ -14415,7 +18121,7 @@ DUK_EXTERNAL void duk_get_prototype(duk_context *ctx, duk_idx_t index) { duk_hobject *obj; duk_hobject *proto; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_UNREF(thr); obj = duk_require_hobject(ctx, index); @@ -14435,7 +18141,7 @@ DUK_EXTERNAL void duk_set_prototype(duk_context *ctx, duk_idx_t index) { duk_hobject *obj; duk_hobject *proto; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); obj = duk_require_hobject(ctx, index); DUK_ASSERT(obj != NULL); @@ -14459,10 +18165,14 @@ DUK_EXTERNAL void duk_set_prototype(duk_context *ctx, duk_idx_t index) { * now (just set it to undefined). */ DUK_EXTERNAL void duk_get_finalizer(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + duk_get_prop_stridx(ctx, index, DUK_STRIDX_INT_FINALIZER); } DUK_EXTERNAL void duk_set_finalizer(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + duk_put_prop_stridx(ctx, index, DUK_STRIDX_INT_FINALIZER); } #line 1 "duk_api_stack.c" @@ -14496,22 +18206,25 @@ DUK_EXTERNAL duk_int_t duk_api_global_line = 0; #endif /* - * Helpers + * Misc helpers */ +/* Check that there's room to push one value. */ #if defined(DUK_USE_VALSTACK_UNSAFE) /* Faster but value stack overruns are memory unsafe. */ -#define DUK__CHECK_SPACE() do { \ +#define DUK__CHECK_SPACE() do { \ DUK_ASSERT(!(thr->valstack_top >= thr->valstack_end)); \ } while (0) #else -#define DUK__CHECK_SPACE() do { \ - if (thr->valstack_top >= thr->valstack_end) { \ - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); \ +#define DUK__CHECK_SPACE() do { \ + if (DUK_UNLIKELY(thr->valstack_top >= thr->valstack_end)) { \ + DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK); \ } \ } while (0) #endif +DUK_LOCAL_DECL duk_heaphdr *duk__get_tagged_heaphdr_raw(duk_context *ctx, duk_idx_t index, duk_uint_t tag); + DUK_LOCAL duk_int_t duk__api_coerce_d2i(duk_context *ctx, duk_idx_t index, duk_bool_t require) { duk_hthread *thr; duk_tval *tv; @@ -14573,10 +18286,10 @@ DUK_LOCAL duk_int_t duk__api_coerce_d2i(duk_context *ctx, duk_idx_t index, duk_b error_notnumber: if (require) { - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_NUMBER); - } else { - return 0; + DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "number", DUK_STR_NOT_NUMBER); + /* not reachable */ } + return 0; } DUK_LOCAL duk_uint_t duk__api_coerce_d2ui(duk_context *ctx, duk_idx_t index, duk_bool_t require) { @@ -14630,10 +18343,10 @@ DUK_LOCAL duk_uint_t duk__api_coerce_d2ui(duk_context *ctx, duk_idx_t index, duk error_notnumber: if (require) { - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_NUMBER); - } else { - return 0; + DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "number", DUK_STR_NOT_NUMBER); + /* not reachable */ } + return 0; } /* @@ -14647,9 +18360,10 @@ DUK_LOCAL duk_uint_t duk__api_coerce_d2ui(duk_context *ctx, duk_idx_t index, duk DUK_EXTERNAL duk_idx_t duk_normalize_index(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; - duk_idx_t vs_size; + duk_uidx_t vs_size; + duk_uidx_t uindex; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(DUK_INVALID_INDEX < 0); /* Care must be taken to avoid pointer wrapping in the index @@ -14659,124 +18373,119 @@ DUK_EXTERNAL duk_idx_t duk_normalize_index(duk_context *ctx, duk_idx_t index) { */ /* Assume value stack sizes (in elements) fits into duk_idx_t. */ - vs_size = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom); - DUK_ASSERT(vs_size >= 0); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + vs_size = (duk_uidx_t) (thr->valstack_top - thr->valstack_bottom); + DUK_ASSERT_DISABLE(vs_size >= 0); /* unsigned */ if (index < 0) { - index = vs_size + index; - if (DUK_UNLIKELY(index < 0)) { - /* Also catches index == DUK_INVALID_INDEX: vs_size >= 0 - * so that vs_size + DUK_INVALID_INDEX cannot underflow - * and will always be negative. - */ - return DUK_INVALID_INDEX; - } + uindex = vs_size + (duk_uidx_t) index; } else { /* since index non-negative */ DUK_ASSERT(index != DUK_INVALID_INDEX); - - if (DUK_UNLIKELY(index >= vs_size)) { - return DUK_INVALID_INDEX; - } + uindex = (duk_uidx_t) index; } - DUK_ASSERT(index >= 0); - DUK_ASSERT(index < vs_size); - return index; + /* DUK_INVALID_INDEX won't be accepted as a valid index. */ + DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_size); + + if (DUK_LIKELY(uindex < vs_size)) { + return (duk_idx_t) uindex; + } + return DUK_INVALID_INDEX; } DUK_EXTERNAL duk_idx_t duk_require_normalize_index(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; - duk_idx_t vs_size; + duk_uidx_t vs_size; + duk_uidx_t uindex; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(DUK_INVALID_INDEX < 0); - vs_size = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom); - DUK_ASSERT(vs_size >= 0); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + vs_size = (duk_uidx_t) (thr->valstack_top - thr->valstack_bottom); + DUK_ASSERT_DISABLE(vs_size >= 0); /* unsigned */ if (index < 0) { - index = vs_size + index; - if (DUK_UNLIKELY(index < 0)) { - goto invalid_index; - } + uindex = vs_size + (duk_uidx_t) index; } else { DUK_ASSERT(index != DUK_INVALID_INDEX); - if (DUK_UNLIKELY(index >= vs_size)) { - goto invalid_index; - } + uindex = (duk_uidx_t) index; } - DUK_ASSERT(index >= 0); - DUK_ASSERT(index < vs_size); - return index; + /* DUK_INVALID_INDEX won't be accepted as a valid index. */ + DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_size); - invalid_index: - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX); + if (DUK_LIKELY(uindex < vs_size)) { + return (duk_idx_t) uindex; + } + DUK_ERROR_API_INDEX(thr, index); return 0; /* unreachable */ } DUK_INTERNAL duk_tval *duk_get_tval(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; - duk_idx_t vs_size; + duk_uidx_t vs_size; + duk_uidx_t uindex; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(DUK_INVALID_INDEX < 0); - vs_size = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom); - DUK_ASSERT(vs_size >= 0); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + vs_size = (duk_uidx_t) (thr->valstack_top - thr->valstack_bottom); + DUK_ASSERT_DISABLE(vs_size >= 0); /* unsigned */ if (index < 0) { - index = vs_size + index; - if (DUK_UNLIKELY(index < 0)) { - return NULL; - } + uindex = vs_size + (duk_uidx_t) index; } else { DUK_ASSERT(index != DUK_INVALID_INDEX); - if (DUK_UNLIKELY(index >= vs_size)) { - return NULL; - } + uindex = (duk_uidx_t) index; } - DUK_ASSERT(index >= 0); - DUK_ASSERT(index < vs_size); - return thr->valstack_bottom + index; + /* DUK_INVALID_INDEX won't be accepted as a valid index. */ + DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_size); + + if (DUK_LIKELY(uindex < vs_size)) { + return thr->valstack_bottom + uindex; + } + return NULL; } DUK_INTERNAL duk_tval *duk_require_tval(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; - duk_idx_t vs_size; + duk_uidx_t vs_size; + duk_uidx_t uindex; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(DUK_INVALID_INDEX < 0); - vs_size = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom); - DUK_ASSERT(vs_size >= 0); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + vs_size = (duk_uidx_t) (thr->valstack_top - thr->valstack_bottom); + DUK_ASSERT_DISABLE(vs_size >= 0); /* unsigned */ + /* Use unsigned arithmetic to optimize comparison. */ if (index < 0) { - index = vs_size + index; - if (DUK_UNLIKELY(index < 0)) { - goto invalid_index; - } + uindex = vs_size + (duk_uidx_t) index; } else { DUK_ASSERT(index != DUK_INVALID_INDEX); - if (DUK_UNLIKELY(index >= vs_size)) { - goto invalid_index; - } + uindex = (duk_uidx_t) index; } - DUK_ASSERT(index >= 0); - DUK_ASSERT(index < vs_size); - return thr->valstack_bottom + index; + /* DUK_INVALID_INDEX won't be accepted as a valid index. */ + DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_size); - invalid_index: - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX); + if (DUK_LIKELY(uindex < vs_size)) { + return thr->valstack_bottom + uindex; + } + DUK_ERROR_API_INDEX(thr, index); return NULL; } /* Non-critical. */ DUK_EXTERNAL duk_bool_t duk_is_valid_index(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(DUK_INVALID_INDEX < 0); + return (duk_normalize_index(ctx, index) >= 0); } @@ -14784,11 +18493,12 @@ DUK_EXTERNAL duk_bool_t duk_is_valid_index(duk_context *ctx, duk_idx_t index) { DUK_EXTERNAL void duk_require_valid_index(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(DUK_INVALID_INDEX < 0); if (duk_normalize_index(ctx, index) < 0) { - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX); + DUK_ERROR_API_INDEX(thr, index); + return; /* unreachable */ } } @@ -14799,103 +18509,111 @@ DUK_EXTERNAL void duk_require_valid_index(duk_context *ctx, duk_idx_t index) { DUK_EXTERNAL duk_idx_t duk_get_top(duk_context *ctx) { duk_hthread *thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); return (duk_idx_t) (thr->valstack_top - thr->valstack_bottom); } -/* set stack top within currently allocated range, but don't reallocate */ +/* Set stack top within currently allocated range, but don't reallocate. + * This is performance critical especially for call handling, so whenever + * changing, profile and look at generated code. + */ DUK_EXTERNAL void duk_set_top(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; - duk_idx_t vs_size; - duk_idx_t vs_limit; - duk_idx_t count; - duk_tval tv_tmp; + duk_uidx_t vs_size; + duk_uidx_t vs_limit; + duk_uidx_t uindex; duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(DUK_INVALID_INDEX < 0); - vs_size = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom); - vs_limit = (duk_idx_t) (thr->valstack_end - thr->valstack_bottom); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + DUK_ASSERT(thr->valstack_end >= thr->valstack_bottom); + vs_size = (duk_uidx_t) (thr->valstack_top - thr->valstack_bottom); + vs_limit = (duk_uidx_t) (thr->valstack_end - thr->valstack_bottom); if (index < 0) { /* Negative indices are always within allocated stack but * must not go below zero index. */ - index = vs_size + index; - if (index < 0) { - /* Also catches index == DUK_INVALID_INDEX. */ - goto invalid_index; - } + uindex = vs_size + (duk_uidx_t) index; } else { /* Positive index can be higher than valstack top but must * not go above allocated stack (equality is OK). */ - if (index > vs_limit) { - goto invalid_index; - } + uindex = (duk_uidx_t) index; } - DUK_ASSERT(index >= 0); - DUK_ASSERT(index <= vs_limit); - if (index >= vs_size) { - /* Stack size increases or stays the same. Fill the new - * entries (if any) with undefined. No pointer stability - * issues here so we can use a running pointer. - */ + /* DUK_INVALID_INDEX won't be accepted as a valid index. */ + DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_size); + DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_limit); - tv = thr->valstack_top; - count = index - vs_size; - DUK_ASSERT(count >= 0); - while (count > 0) { - /* no need to decref previous or new value */ +#if defined(DUK_USE_VALSTACK_UNSAFE) + DUK_ASSERT(uindex <= vs_limit); + DUK_UNREF(vs_limit); +#else + if (DUK_UNLIKELY(uindex > vs_limit)) { + DUK_ERROR_API_INDEX(thr, index); + return; /* unreachable */ + } +#endif + DUK_ASSERT(uindex <= vs_limit); + + /* Handle change in value stack top. Respect value stack + * initialization policy: 'undefined' above top. Note that + * DECREF may cause a side effect that reallocates valstack, + * so must relookup after DECREF. + */ + + if (uindex >= vs_size) { + /* Stack size increases or stays the same. */ +#if defined(DUK_USE_ASSERTIONS) + duk_uidx_t count; + + count = uindex - vs_size; + while (count != 0) { count--; - DUK_ASSERT(DUK_TVAL_IS_UNDEFINED_UNUSED(tv)); - DUK_TVAL_SET_UNDEFINED_ACTUAL(tv); - tv++; + tv = thr->valstack_top + count; + DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(tv)); } - thr->valstack_top = tv; +#endif + thr->valstack_top = thr->valstack_bottom + uindex; } else { - /* Stack size decreases, DECREF entries which are above the - * new top. Each DECREF potentially invalidates valstack - * pointers, so don't hold on to pointers. The valstack top - * must also be updated on every loop in case a GC is triggered. - */ + /* Stack size decreases. */ +#if defined(DUK_USE_REFERENCE_COUNTING) + duk_uidx_t count; - /* XXX: Here it would be useful to have a DECREF macro which - * doesn't need a NULL check, and does refzero queueing without - * running the refzero algorithm. There would be no pointer - * instability in this case, and code could be inlined. After - * the loop, one call to refzero would be needed. - */ - - count = vs_size - index; + count = vs_size - uindex; DUK_ASSERT(count > 0); - while (count > 0) { count--; - tv = --thr->valstack_top; /* tv -> value just before prev top value */ + tv = --thr->valstack_top; /* tv -> value just before prev top value; must relookup */ DUK_ASSERT(tv >= thr->valstack_bottom); - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_UNDEFINED_UNUSED(tv); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ - - /* XXX: fast primitive to set a bunch of values to UNDEFINED_UNUSED */ - + DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv); /* side effects */ } - } - return; +#else /* DUK_USE_REFERENCE_COUNTING */ + duk_uidx_t count; + duk_tval *tv_end; - invalid_index: - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX); + count = vs_size - uindex; + tv = thr->valstack_top; + tv_end = tv - count; + DUK_ASSERT(tv > tv_end); + do { + tv--; + DUK_TVAL_SET_UNDEFINED(tv); + } while (tv != tv_end); + thr->valstack_top = tv_end; +#endif /* DUK_USE_REFERENCE_COUNTING */ + } } DUK_EXTERNAL duk_idx_t duk_get_top_index(duk_context *ctx) { duk_hthread *thr = (duk_hthread *) ctx; duk_idx_t ret; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); ret = ((duk_idx_t) (thr->valstack_top - thr->valstack_bottom)) - 1; if (DUK_UNLIKELY(ret < 0)) { @@ -14912,11 +18630,12 @@ DUK_EXTERNAL duk_idx_t duk_require_top_index(duk_context *ctx) { duk_hthread *thr = (duk_hthread *) ctx; duk_idx_t ret; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); ret = ((duk_idx_t) (thr->valstack_top - thr->valstack_bottom)) - 1; if (DUK_UNLIKELY(ret < 0)) { - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX); + DUK_ERROR_API_INDEX(thr, -1); + return 0; /* unreachable */ } return ret; } @@ -14954,10 +18673,10 @@ DUK_LOCAL duk_bool_t duk__resize_valstack(duk_context *ctx, duk_size_t new_size) duk_tval *old_valstack_post; #endif duk_tval *new_valstack; - duk_tval *p; duk_size_t new_alloc_size; + duk_tval *p; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr != NULL); DUK_ASSERT(thr->valstack_bottom >= thr->valstack); DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); @@ -14978,7 +18697,7 @@ DUK_LOCAL duk_bool_t duk__resize_valstack(duk_context *ctx, duk_size_t new_size) * * Note: cannot use a plain DUK_REALLOC() because a mark-and-sweep may * invalidate the original thr->valstack base pointer inside the realloc - * process. See doc/memory-management.txt. + * process. See doc/memory-management.rst. */ new_alloc_size = sizeof(duk_tval) * new_size; @@ -15006,7 +18725,7 @@ DUK_LOCAL duk_bool_t duk__resize_valstack(duk_context *ctx, duk_size_t new_size) * because mark-and-sweep must adhere to a strict stack policy. * In other words, logical bottom and top MUST NOT have changed. * - All values above the top are unreachable but are initialized - * to UNDEFINED_UNUSED, up to the post-realloc valstack_end. + * to UNDEFINED, up to the post-realloc valstack_end. * - 'old_end_offset' must be computed after realloc to be correct. */ @@ -15020,8 +18739,11 @@ DUK_LOCAL duk_bool_t duk__resize_valstack(duk_context *ctx, duk_size_t new_size) #endif thr->valstack = new_valstack; thr->valstack_end = new_valstack + new_size; - thr->valstack_bottom = (duk_tval *) ((duk_uint8_t *) new_valstack + old_bottom_offset); - thr->valstack_top = (duk_tval *) ((duk_uint8_t *) new_valstack + old_top_offset); +#if !defined(DUK_USE_PREFER_SIZE) + thr->valstack_size = new_size; +#endif + thr->valstack_bottom = (duk_tval *) (void *) ((duk_uint8_t *) new_valstack + old_bottom_offset); + thr->valstack_top = (duk_tval *) (void *) ((duk_uint8_t *) new_valstack + old_top_offset); DUK_ASSERT(thr->valstack_bottom >= thr->valstack); DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); @@ -15050,23 +18772,23 @@ DUK_LOCAL duk_bool_t duk__resize_valstack(duk_context *ctx, duk_size_t new_size) (void *) thr->valstack, (void *) thr->valstack_end, (void *) thr->valstack_bottom, (void *) thr->valstack_top)); - /* init newly allocated slots (only) */ - p = (duk_tval *) ((duk_uint8_t *) thr->valstack + old_end_offset_post); + /* Init newly allocated slots (only). */ + p = (duk_tval *) (void *) ((duk_uint8_t *) thr->valstack + old_end_offset_post); while (p < thr->valstack_end) { - /* never executed if new size is smaller */ - DUK_TVAL_SET_UNDEFINED_UNUSED(p); + /* Never executed if new size is smaller. */ + DUK_TVAL_SET_UNDEFINED(p); p++; } - /* assertion check: we maintain elements above top in known state */ -#ifdef DUK_USE_ASSERTIONS + /* Assert for value stack initialization policy. */ +#if defined(DUK_USE_ASSERTIONS) p = thr->valstack_top; while (p < thr->valstack_end) { - /* everything above old valstack top should be preinitialized now */ - DUK_ASSERT(DUK_TVAL_IS_UNDEFINED_UNUSED(p)); + DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(p)); p++; } #endif + return 1; } @@ -15090,13 +18812,18 @@ duk_bool_t duk_valstack_resize_raw(duk_context *ctx, (long) (thr->valstack_bottom - thr->valstack), (int) shrink_flag, (int) compact_flag, (int) throw_flag)); - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr != NULL); DUK_ASSERT(thr->valstack_bottom >= thr->valstack); DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); DUK_ASSERT(thr->valstack_end >= thr->valstack_top); +#if defined(DUK_USE_PREFER_SIZE) old_size = (duk_size_t) (thr->valstack_end - thr->valstack); +#else + DUK_ASSERT((duk_size_t) (thr->valstack_end - thr->valstack) == thr->valstack_size); + old_size = thr->valstack_size; +#endif if (min_new_size <= old_size) { is_shrink = 1; @@ -15169,7 +18896,7 @@ DUK_EXTERNAL duk_bool_t duk_check_stack(duk_context *ctx, duk_idx_t extra) { duk_hthread *thr = (duk_hthread *) ctx; duk_size_t min_new_size; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr != NULL); if (DUK_UNLIKELY(extra < 0)) { @@ -15191,7 +18918,7 @@ DUK_EXTERNAL void duk_require_stack(duk_context *ctx, duk_idx_t extra) { duk_hthread *thr = (duk_hthread *) ctx; duk_size_t min_new_size; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr != NULL); if (DUK_UNLIKELY(extra < 0)) { @@ -15212,7 +18939,7 @@ DUK_EXTERNAL void duk_require_stack(duk_context *ctx, duk_idx_t extra) { DUK_EXTERNAL duk_bool_t duk_check_stack_top(duk_context *ctx, duk_idx_t top) { duk_size_t min_new_size; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); if (DUK_UNLIKELY(top < 0)) { /* Clamping to zero makes the API more robust to calling code @@ -15232,7 +18959,7 @@ DUK_EXTERNAL duk_bool_t duk_check_stack_top(duk_context *ctx, duk_idx_t top) { DUK_EXTERNAL void duk_require_stack_top(duk_context *ctx, duk_idx_t top) { duk_size_t min_new_size; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); if (DUK_UNLIKELY(top < 0)) { /* Clamping to zero makes the API more robust to calling code @@ -15258,7 +18985,7 @@ DUK_EXTERNAL void duk_swap(duk_context *ctx, duk_idx_t index1, duk_idx_t index2) duk_tval *tv2; duk_tval tv_tmp; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv1 = duk_require_tval(ctx, index1); DUK_ASSERT(tv1 != NULL); @@ -15272,7 +18999,7 @@ DUK_EXTERNAL void duk_swap(duk_context *ctx, duk_idx_t index1, duk_idx_t index2) } DUK_EXTERNAL void duk_swap_top(duk_context *ctx, duk_idx_t index) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); duk_swap(ctx, index, -1); } @@ -15282,7 +19009,7 @@ DUK_EXTERNAL void duk_dup(duk_context *ctx, duk_idx_t from_index) { duk_tval *tv_from; duk_tval *tv_to; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); thr = (duk_hthread *) ctx; DUK__CHECK_SPACE(); @@ -15299,12 +19026,13 @@ DUK_EXTERNAL void duk_dup_top(duk_context *ctx) { duk_tval *tv_from; duk_tval *tv_to; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); thr = (duk_hthread *) ctx; DUK__CHECK_SPACE(); if (thr->valstack_top - thr->valstack_bottom <= 0) { - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX); + DUK_ERROR_API_INDEX(thr, -1); + return; /* unreachable */ } tv_from = thr->valstack_top - 1; tv_to = thr->valstack_top++; @@ -15320,7 +19048,7 @@ DUK_EXTERNAL void duk_insert(duk_context *ctx, duk_idx_t to_index) { duk_tval tv_tmp; duk_size_t nbytes; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); p = duk_require_tval(ctx, to_index); DUK_ASSERT(p != NULL); @@ -15345,7 +19073,7 @@ DUK_EXTERNAL void duk_insert(duk_context *ctx, duk_idx_t to_index) { if (nbytes > 0) { DUK_TVAL_SET_TVAL(&tv_tmp, q); DUK_ASSERT(nbytes > 0); - DUK_MEMMOVE((void *) (p + 1), (void *) p, nbytes); + DUK_MEMMOVE((void *) (p + 1), (const void *) p, (size_t) nbytes); DUK_TVAL_SET_TVAL(p, &tv_tmp); } else { /* nop: insert top to top */ @@ -15360,7 +19088,7 @@ DUK_EXTERNAL void duk_replace(duk_context *ctx, duk_idx_t to_index) { duk_tval *tv2; duk_tval tv_tmp; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv1 = duk_require_tval(ctx, -1); DUK_ASSERT(tv1 != NULL); @@ -15370,10 +19098,9 @@ DUK_EXTERNAL void duk_replace(duk_context *ctx, duk_idx_t to_index) { /* For tv1 == tv2, both pointing to stack top, the end result * is same as duk_pop(ctx). */ - DUK_TVAL_SET_TVAL(&tv_tmp, tv2); DUK_TVAL_SET_TVAL(tv2, tv1); - DUK_TVAL_SET_UNDEFINED_UNUSED(tv1); + DUK_TVAL_SET_UNDEFINED(tv1); thr->valstack_top--; DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ } @@ -15382,23 +19109,17 @@ DUK_EXTERNAL void duk_copy(duk_context *ctx, duk_idx_t from_index, duk_idx_t to_ duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv1; duk_tval *tv2; - duk_tval tv_tmp; + DUK_ASSERT_CTX_VALID(ctx); DUK_UNREF(thr); /* w/o refcounting */ - DUK_ASSERT(ctx != NULL); - tv1 = duk_require_tval(ctx, from_index); DUK_ASSERT(tv1 != NULL); tv2 = duk_require_tval(ctx, to_index); DUK_ASSERT(tv2 != NULL); /* For tv1 == tv2, this is a no-op (no explicit check needed). */ - - DUK_TVAL_SET_TVAL(&tv_tmp, tv2); - DUK_TVAL_SET_TVAL(tv2, tv1); - DUK_TVAL_INCREF(thr, tv2); /* no side effects */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_TVAL_UPDREF(thr, tv2, tv1); /* side effects */ } DUK_EXTERNAL void duk_remove(duk_context *ctx, duk_idx_t index) { @@ -15410,7 +19131,7 @@ DUK_EXTERNAL void duk_remove(duk_context *ctx, duk_idx_t index) { #endif duk_size_t nbytes; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); p = duk_require_tval(ctx, index); DUK_ASSERT(p != NULL); @@ -15431,9 +19152,9 @@ DUK_EXTERNAL void duk_remove(duk_context *ctx, duk_idx_t index) { #endif nbytes = (duk_size_t) (((duk_uint8_t *) q) - ((duk_uint8_t *) p)); /* Note: 'q' is top-1 */ - DUK_MEMMOVE(p, p + 1, nbytes); /* zero size not an issue: pointers are valid */ + DUK_MEMMOVE((void *) p, (const void *) (p + 1), (size_t) nbytes); /* zero size not an issue: pointers are valid */ - DUK_TVAL_SET_UNDEFINED_UNUSED(q); + DUK_TVAL_SET_UNDEFINED(q); thr->valstack_top--; #ifdef DUK_USE_REFERENCE_COUNTING @@ -15455,17 +19176,19 @@ DUK_EXTERNAL void duk_xcopymove_raw(duk_context *to_ctx, duk_context *from_ctx, /* XXX: several pointer comparison issues here */ + DUK_ASSERT_CTX_VALID(to_ctx); + DUK_ASSERT_CTX_VALID(from_ctx); DUK_ASSERT(to_ctx != NULL); DUK_ASSERT(from_ctx != NULL); if (to_ctx == from_ctx) { - DUK_ERROR(to_thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CONTEXT); + DUK_ERROR_API(to_thr, DUK_STR_INVALID_CONTEXT); return; } if ((count < 0) || (count > (duk_idx_t) to_thr->valstack_max)) { /* Maximum value check ensures 'nbytes' won't wrap below. */ - DUK_ERROR(to_thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_COUNT); + DUK_ERROR_API(to_thr, DUK_STR_INVALID_COUNT); return; } @@ -15475,41 +19198,39 @@ DUK_EXTERNAL void duk_xcopymove_raw(duk_context *to_ctx, duk_context *from_ctx, } DUK_ASSERT(to_thr->valstack_top <= to_thr->valstack_end); if ((duk_size_t) ((duk_uint8_t *) to_thr->valstack_end - (duk_uint8_t *) to_thr->valstack_top) < nbytes) { - DUK_ERROR(to_thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); + DUK_ERROR_API(to_thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK); } src = (void *) ((duk_uint8_t *) from_thr->valstack_top - nbytes); if (src < (void *) from_thr->valstack_bottom) { - DUK_ERROR(to_thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_COUNT); + DUK_ERROR_API(to_thr, DUK_STR_INVALID_COUNT); } /* copy values (no overlap even if to_ctx == from_ctx; that's not * allowed now anyway) */ DUK_ASSERT(nbytes > 0); - DUK_MEMCPY((void *) to_thr->valstack_top, src, nbytes); + DUK_MEMCPY((void *) to_thr->valstack_top, (const void *) src, (size_t) nbytes); p = to_thr->valstack_top; - to_thr->valstack_top = (duk_tval *) (((duk_uint8_t *) p) + nbytes); + to_thr->valstack_top = (duk_tval *) (void *) (((duk_uint8_t *) p) + nbytes); if (is_copy) { - /* incref copies, keep originals */ + /* Incref copies, keep originals. */ q = to_thr->valstack_top; while (p < q) { DUK_TVAL_INCREF(to_thr, p); /* no side effects */ p++; } } else { - /* no net refcount change */ + /* No net refcount change. */ p = from_thr->valstack_top; - q = (duk_tval *) (((duk_uint8_t *) p) - nbytes); + q = (duk_tval *) (void *) (((duk_uint8_t *) p) - nbytes); from_thr->valstack_top = q; - /* elements above stack top are kept UNUSED */ while (p > q) { p--; - DUK_TVAL_SET_UNDEFINED_UNUSED(p); - - /* XXX: fast primitive to set a bunch of values to UNDEFINED_UNUSED */ + DUK_TVAL_SET_UNDEFINED(p); + /* XXX: fast primitive to set a bunch of values to UNDEFINED */ } } } @@ -15522,27 +19243,27 @@ DUK_EXTERNAL void duk_require_undefined(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_get_tval(ctx, index); if (tv && DUK_TVAL_IS_UNDEFINED(tv)) { - /* Note: accept both 'actual' and 'unused' undefined */ return; } - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_UNDEFINED); + DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "undefined", DUK_STR_NOT_UNDEFINED); + return; /* not reachable */ } DUK_EXTERNAL void duk_require_null(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_get_tval(ctx, index); if (tv && DUK_TVAL_IS_NULL(tv)) { return; } - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_NULL); + DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "null", DUK_STR_NOT_NULL); return; /* not reachable */ } @@ -15550,7 +19271,7 @@ DUK_EXTERNAL duk_bool_t duk_get_boolean(duk_context *ctx, duk_idx_t index) { duk_bool_t ret = 0; /* default: false */ duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_get_tval(ctx, index); if (tv && DUK_TVAL_IS_BOOLEAN(tv)) { @@ -15565,7 +19286,7 @@ DUK_EXTERNAL duk_bool_t duk_require_boolean(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_get_tval(ctx, index); if (tv && DUK_TVAL_IS_BOOLEAN(tv)) { @@ -15573,8 +19294,7 @@ DUK_EXTERNAL duk_bool_t duk_require_boolean(duk_context *ctx, duk_idx_t index) { DUK_ASSERT(ret == 0 || ret == 1); return ret; } - - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_BOOLEAN); + DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "boolean", DUK_STR_NOT_BOOLEAN); return 0; /* not reachable */ } @@ -15582,7 +19302,7 @@ DUK_EXTERNAL duk_double_t duk_get_number(duk_context *ctx, duk_idx_t index) { duk_double_union ret; duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); ret.d = DUK_DOUBLE_NAN; /* default: NaN */ tv = duk_get_tval(ctx, index); @@ -15603,7 +19323,7 @@ DUK_EXTERNAL duk_double_t duk_require_number(duk_context *ctx, duk_idx_t index) duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_get_tval(ctx, index); if (tv && DUK_TVAL_IS_NUMBER(tv)) { @@ -15618,28 +19338,31 @@ DUK_EXTERNAL duk_double_t duk_require_number(duk_context *ctx, duk_idx_t index) DUK_DBLUNION_NORMALIZE_NAN_CHECK(&ret); return ret.d; } - - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_NUMBER); + DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "number", DUK_STR_NOT_NUMBER); return DUK_DOUBLE_NAN; /* not reachable */ } DUK_EXTERNAL duk_int_t duk_get_int(duk_context *ctx, duk_idx_t index) { /* Custom coercion for API */ + DUK_ASSERT_CTX_VALID(ctx); return (duk_int_t) duk__api_coerce_d2i(ctx, index, 0 /*require*/); } DUK_EXTERNAL duk_uint_t duk_get_uint(duk_context *ctx, duk_idx_t index) { /* Custom coercion for API */ + DUK_ASSERT_CTX_VALID(ctx); return (duk_uint_t) duk__api_coerce_d2ui(ctx, index, 0 /*require*/); } DUK_EXTERNAL duk_int_t duk_require_int(duk_context *ctx, duk_idx_t index) { /* Custom coercion for API */ + DUK_ASSERT_CTX_VALID(ctx); return (duk_int_t) duk__api_coerce_d2i(ctx, index, 1 /*require*/); } DUK_EXTERNAL duk_uint_t duk_require_uint(duk_context *ctx, duk_idx_t index) { /* Custom coercion for API */ + DUK_ASSERT_CTX_VALID(ctx); return (duk_uint_t) duk__api_coerce_d2ui(ctx, index, 1 /*require*/); } @@ -15647,7 +19370,7 @@ DUK_EXTERNAL const char *duk_get_lstring(duk_context *ctx, duk_idx_t index, duk_ const char *ret; duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); /* default: NULL, length 0 */ ret = NULL; @@ -15675,7 +19398,7 @@ DUK_EXTERNAL const char *duk_require_lstring(duk_context *ctx, duk_idx_t index, duk_hthread *thr = (duk_hthread *) ctx; const char *ret; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); /* Note: this check relies on the fact that even a zero-size string * has a non-NULL pointer. @@ -15684,19 +19407,18 @@ DUK_EXTERNAL const char *duk_require_lstring(duk_context *ctx, duk_idx_t index, if (ret) { return ret; } - - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_STRING); + DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "string", DUK_STR_NOT_STRING); return NULL; /* not reachable */ } DUK_EXTERNAL const char *duk_get_string(duk_context *ctx, duk_idx_t index) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); return duk_get_lstring(ctx, index, NULL); } DUK_EXTERNAL const char *duk_require_string(duk_context *ctx, duk_idx_t index) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); return duk_require_lstring(ctx, index, NULL); } @@ -15704,7 +19426,7 @@ DUK_EXTERNAL const char *duk_require_string(duk_context *ctx, duk_idx_t index) { DUK_EXTERNAL void *duk_get_pointer(duk_context *ctx, duk_idx_t index) { duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_get_tval(ctx, index); if (tv && DUK_TVAL_IS_POINTER(tv)) { @@ -15719,7 +19441,7 @@ DUK_EXTERNAL void *duk_require_pointer(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); /* Note: here we must be wary of the fact that a pointer may be * valid and be a NULL. @@ -15729,8 +19451,7 @@ DUK_EXTERNAL void *duk_require_pointer(duk_context *ctx, duk_idx_t index) { void *p = DUK_TVAL_GET_POINTER(tv); /* may be NULL */ return (void *) p; } - - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_POINTER); + DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "pointer", DUK_STR_NOT_POINTER); return NULL; /* not reachable */ } @@ -15738,7 +19459,7 @@ DUK_EXTERNAL void *duk_require_pointer(duk_context *ctx, duk_idx_t index) { DUK_INTERNAL void *duk_get_voidptr(duk_context *ctx, duk_idx_t index) { duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_get_tval(ctx, index); if (tv && DUK_TVAL_IS_HEAP_ALLOCATED(tv)) { @@ -15751,11 +19472,11 @@ DUK_INTERNAL void *duk_get_voidptr(duk_context *ctx, duk_idx_t index) { } #endif -DUK_EXTERNAL void *duk_get_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) { +DUK_LOCAL void *duk__get_buffer_helper(duk_context *ctx, duk_idx_t index, duk_size_t *out_size, duk_bool_t throw_flag) { duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_UNREF(thr); if (out_size != NULL) { @@ -15772,109 +19493,144 @@ DUK_EXTERNAL void *duk_get_buffer(duk_context *ctx, duk_idx_t index, duk_size_t return (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h); /* may be NULL (but only if size is 0) */ } + if (throw_flag) { + DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "buffer", DUK_STR_NOT_BUFFER); + } return NULL; } +DUK_EXTERNAL void *duk_get_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) { + return duk__get_buffer_helper(ctx, index, out_size, 0 /*throw_flag*/); +} + DUK_EXTERNAL void *duk_require_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) { + return duk__get_buffer_helper(ctx, index, out_size, 1 /*throw_flag*/); +} + +DUK_LOCAL void *duk__get_buffer_data_helper(duk_context *ctx, duk_idx_t index, duk_size_t *out_size, duk_bool_t throw_flag) { duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); + DUK_UNREF(thr); if (out_size != NULL) { *out_size = 0; } - /* Note: here we must be wary of the fact that a data pointer may - * be a NULL for a zero-size buffer. - */ - tv = duk_get_tval(ctx, index); - if (tv && DUK_TVAL_IS_BUFFER(tv)) { + if (tv == NULL) { + goto fail; + } + + if (DUK_TVAL_IS_BUFFER(tv)) { duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv); DUK_ASSERT(h != NULL); if (out_size) { *out_size = DUK_HBUFFER_GET_SIZE(h); } return (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h); /* may be NULL (but only if size is 0) */ + } else if (DUK_TVAL_IS_OBJECT(tv)) { + duk_hobject *h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) { + /* XXX: this is probably a useful shared helper: for a + * duk_hbufferobject, get a validated buffer pointer/length. + */ + duk_hbufferobject *h_bufobj = (duk_hbufferobject *) h; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + if (h_bufobj->buf != NULL && + DUK_HBUFFEROBJECT_VALID_SLICE(h_bufobj)) { + duk_uint8_t *p; + + p = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf); + if (out_size != NULL) { + *out_size = (duk_size_t) h_bufobj->length; + } + return (void *) (p + h_bufobj->offset); + } + /* if slice not fully valid, treat as error */ + } } - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_BUFFER); - return NULL; /* not reachable */ + fail: + if (throw_flag) { + DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "buffer", DUK_STR_NOT_BUFFER); + } + return NULL; } -/* Raw helper for getting a value from the stack, checking its tag, and possible its object class. - * The tag cannot be a number because numbers don't have an internal tag in the packed representation. - */ -DUK_INTERNAL duk_heaphdr *duk_get_tagged_heaphdr_raw(duk_context *ctx, duk_idx_t index, duk_uint_t flags_and_tag) { - duk_hthread *thr = (duk_hthread *) ctx; - duk_tval *tv; - duk_small_uint_t tag = flags_and_tag & 0xffffU; /* tags can be up to 16 bits */ +DUK_EXTERNAL void *duk_get_buffer_data(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) { + return duk__get_buffer_data_helper(ctx, index, out_size, 0 /*throw_flag*/); +} - DUK_ASSERT(ctx != NULL); +DUK_EXTERNAL void *duk_require_buffer_data(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) { + return duk__get_buffer_data_helper(ctx, index, out_size, 1 /*throw_flag*/); +} + +/* Raw helper for getting a value from the stack, checking its tag. + * The tag cannot be a number because numbers don't have an internal + * tag in the packed representation. + */ + +DUK_LOCAL duk_heaphdr *duk__get_tagged_heaphdr_raw(duk_context *ctx, duk_idx_t index, duk_uint_t tag) { + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); tv = duk_get_tval(ctx, index); if (tv && (DUK_TVAL_GET_TAG(tv) == tag)) { duk_heaphdr *ret; - - /* Note: tag comparison in general doesn't work for numbers, - * but it does work for everything else (heap objects here). - */ ret = DUK_TVAL_GET_HEAPHDR(tv); DUK_ASSERT(ret != NULL); /* tagged null pointers should never occur */ - - /* If class check has been requested, tag must also be DUK_TAG_OBJECT. - * This allows us to just check the class check flag without checking - * the tag also. - */ - DUK_ASSERT((flags_and_tag & DUK_GETTAGGED_FLAG_CHECK_CLASS) == 0 || - tag == DUK_TAG_OBJECT); - - if ((flags_and_tag & DUK_GETTAGGED_FLAG_CHECK_CLASS) == 0 || /* no class check */ - (duk_int_t) DUK_HOBJECT_GET_CLASS_NUMBER((duk_hobject *) ret) == /* or class check matches */ - (duk_int_t) ((flags_and_tag >> DUK_GETTAGGED_CLASS_SHIFT) & 0xff)) { - return ret; - } + return ret; } - if (flags_and_tag & DUK_GETTAGGED_FLAG_ALLOW_NULL) { - return (duk_heaphdr *) NULL; - } - - /* Formatting the tag number here is not very useful: the tag value - * is Duktape internal (not the same as DUK_TYPE_xxx) and even depends - * on the duk_tval layout. If anything, add a human readable type here. - */ - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_UNEXPECTED_TYPE); - return NULL; /* not reachable */ + return (duk_heaphdr *) NULL; } DUK_INTERNAL duk_hstring *duk_get_hstring(duk_context *ctx, duk_idx_t index) { - return (duk_hstring *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_STRING | DUK_GETTAGGED_FLAG_ALLOW_NULL); + return (duk_hstring *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_STRING); } DUK_INTERNAL duk_hstring *duk_require_hstring(duk_context *ctx, duk_idx_t index) { - return (duk_hstring *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_STRING); + duk_heaphdr *h; + h = duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_STRING); + if (h == NULL) { + DUK_ERROR_REQUIRE_TYPE_INDEX(ctx, index, "string", DUK_STR_NOT_STRING); + } + return (duk_hstring *) h; } DUK_INTERNAL duk_hobject *duk_get_hobject(duk_context *ctx, duk_idx_t index) { - return (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT | DUK_GETTAGGED_FLAG_ALLOW_NULL); + return (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT); } DUK_INTERNAL duk_hobject *duk_require_hobject(duk_context *ctx, duk_idx_t index) { - return (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT); + duk_heaphdr *h; + h = duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT); + if (h == NULL) { + DUK_ERROR_REQUIRE_TYPE_INDEX(ctx, index, "object", DUK_STR_NOT_OBJECT); + } + return (duk_hobject *) h; } DUK_INTERNAL duk_hbuffer *duk_get_hbuffer(duk_context *ctx, duk_idx_t index) { - return (duk_hbuffer *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_BUFFER | DUK_GETTAGGED_FLAG_ALLOW_NULL); + return (duk_hbuffer *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_BUFFER); } DUK_INTERNAL duk_hbuffer *duk_require_hbuffer(duk_context *ctx, duk_idx_t index) { - return (duk_hbuffer *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_BUFFER); + duk_heaphdr *h; + h = duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_BUFFER); + if (h == NULL) { + DUK_ERROR_REQUIRE_TYPE_INDEX(ctx, index, "buffer", DUK_STR_NOT_BUFFER); + } + return (duk_hbuffer *) h; } DUK_INTERNAL duk_hthread *duk_get_hthread(duk_context *ctx, duk_idx_t index) { - duk_hobject *h = (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT | DUK_GETTAGGED_FLAG_ALLOW_NULL); + duk_hobject *h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT); if (h != NULL && !DUK_HOBJECT_IS_THREAD(h)) { h = NULL; } @@ -15883,36 +19639,32 @@ DUK_INTERNAL duk_hthread *duk_get_hthread(duk_context *ctx, duk_idx_t index) { DUK_INTERNAL duk_hthread *duk_require_hthread(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; - duk_hobject *h = (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT); - DUK_ASSERT(h != NULL); - if (!DUK_HOBJECT_IS_THREAD(h)) { - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_THREAD); + duk_hobject *h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT); + if (!(h != NULL && DUK_HOBJECT_IS_THREAD(h))) { + DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "thread", DUK_STR_NOT_THREAD); } return (duk_hthread *) h; } DUK_INTERNAL duk_hcompiledfunction *duk_get_hcompiledfunction(duk_context *ctx, duk_idx_t index) { - duk_hobject *h = (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT | DUK_GETTAGGED_FLAG_ALLOW_NULL); + duk_hobject *h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT); if (h != NULL && !DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) { h = NULL; } return (duk_hcompiledfunction *) h; } -#if 0 /*unused*/ DUK_INTERNAL duk_hcompiledfunction *duk_require_hcompiledfunction(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; - duk_hobject *h = (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT); - DUK_ASSERT(h != NULL); - if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) { - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_COMPILEDFUNCTION); + duk_hobject *h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT); + if (!(h != NULL && DUK_HOBJECT_IS_COMPILEDFUNCTION(h))) { + DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "compiledfunction", DUK_STR_NOT_COMPILEDFUNCTION); } return (duk_hcompiledfunction *) h; } -#endif DUK_INTERNAL duk_hnativefunction *duk_get_hnativefunction(duk_context *ctx, duk_idx_t index) { - duk_hobject *h = (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT | DUK_GETTAGGED_FLAG_ALLOW_NULL); + duk_hobject *h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT); if (h != NULL && !DUK_HOBJECT_IS_NATIVEFUNCTION(h)) { h = NULL; } @@ -15921,10 +19673,9 @@ DUK_INTERNAL duk_hnativefunction *duk_get_hnativefunction(duk_context *ctx, duk_ DUK_INTERNAL duk_hnativefunction *duk_require_hnativefunction(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; - duk_hobject *h = (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT); - DUK_ASSERT(h != NULL); - if (!DUK_HOBJECT_IS_NATIVEFUNCTION(h)) { - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_NATIVEFUNCTION); + duk_hobject *h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT); + if (!(h != NULL && DUK_HOBJECT_IS_NATIVEFUNCTION(h))) { + DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "nativefunction", DUK_STR_NOT_NATIVEFUNCTION); } return (duk_hnativefunction *) h; } @@ -15934,7 +19685,7 @@ DUK_EXTERNAL duk_c_function duk_get_c_function(duk_context *ctx, duk_idx_t index duk_hobject *h; duk_hnativefunction *f; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_get_tval(ctx, index); if (!tv) { @@ -15959,20 +19710,30 @@ DUK_EXTERNAL duk_c_function duk_require_c_function(duk_context *ctx, duk_idx_t i duk_hthread *thr = (duk_hthread *) ctx; duk_c_function ret; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); ret = duk_get_c_function(ctx, index); if (!ret) { - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_C_FUNCTION); + DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "nativefunction", DUK_STR_NOT_NATIVEFUNCTION); } return ret; } +DUK_EXTERNAL void duk_require_function(duk_context *ctx, duk_idx_t index) { + if (!duk_is_function(ctx, index)) { + DUK_ERROR_REQUIRE_TYPE_INDEX((duk_hthread *) ctx, index, "function", DUK_STR_NOT_FUNCTION); + } +} + DUK_EXTERNAL duk_context *duk_get_context(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + return (duk_context *) duk_get_hthread(ctx, index); } DUK_EXTERNAL duk_context *duk_require_context(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + return (duk_context *) duk_require_hthread(ctx, index); } @@ -15980,7 +19741,7 @@ DUK_EXTERNAL void *duk_get_heapptr(duk_context *ctx, duk_idx_t index) { duk_tval *tv; void *ret; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_get_tval(ctx, index); if (tv && DUK_TVAL_IS_HEAP_ALLOCATED(tv)) { @@ -15997,7 +19758,7 @@ DUK_EXTERNAL void *duk_require_heapptr(duk_context *ctx, duk_idx_t index) { duk_tval *tv; void *ret; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_require_tval(ctx, index); DUK_ASSERT(tv != NULL); @@ -16007,7 +19768,7 @@ DUK_EXTERNAL void *duk_require_heapptr(duk_context *ctx, duk_idx_t index) { return ret; } - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_UNEXPECTED_TYPE); + DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "heapobject", DUK_STR_UNEXPECTED_TYPE); return (void *) NULL; /* not reachable */ } @@ -16024,10 +19785,10 @@ duk_hobject *duk_get_hobject_or_lfunc(duk_context *ctx, duk_idx_t index) { * to an object). Return value is NULL if value is neither an object nor a * lightfunc. */ -duk_hobject *duk_get_hobject_or_lfunc_coerce(duk_context *ctx, duk_idx_t index) { +DUK_INTERNAL duk_hobject *duk_get_hobject_or_lfunc_coerce(duk_context *ctx, duk_idx_t index) { duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_require_tval(ctx, index); DUK_ASSERT(tv != NULL); @@ -16048,7 +19809,7 @@ DUK_INTERNAL duk_hobject *duk_require_hobject_or_lfunc(duk_context *ctx, duk_idx duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_require_tval(ctx, index); DUK_ASSERT(tv != NULL); @@ -16057,8 +19818,7 @@ DUK_INTERNAL duk_hobject *duk_require_hobject_or_lfunc(duk_context *ctx, duk_idx } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) { return NULL; } - - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_UNEXPECTED_TYPE); + DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "object", DUK_STR_NOT_OBJECT); return NULL; /* not reachable */ } @@ -16070,7 +19830,7 @@ DUK_INTERNAL duk_hobject *duk_require_hobject_or_lfunc_coerce(duk_context *ctx, duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_require_tval(ctx, index); if (DUK_TVAL_IS_OBJECT(tv)) { @@ -16079,15 +19839,48 @@ DUK_INTERNAL duk_hobject *duk_require_hobject_or_lfunc_coerce(duk_context *ctx, duk_to_object(ctx, index); return duk_require_hobject(ctx, index); } - - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_UNEXPECTED_TYPE); + DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "object", DUK_STR_NOT_OBJECT); return NULL; /* not reachable */ } +DUK_INTERNAL duk_hobject *duk_get_hobject_with_class(duk_context *ctx, duk_idx_t index, duk_small_uint_t classnum) { + duk_hobject *h; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT_DISABLE(classnum >= 0); /* unsigned */ + DUK_ASSERT(classnum <= DUK_HOBJECT_CLASS_MAX); + + h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT); + if (h != NULL && DUK_HOBJECT_GET_CLASS_NUMBER(h) != classnum) { + h = NULL; + } + return h; +} + +DUK_INTERNAL duk_hobject *duk_require_hobject_with_class(duk_context *ctx, duk_idx_t index, duk_small_uint_t classnum) { + duk_hthread *thr; + duk_hobject *h; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT_DISABLE(classnum >= 0); /* unsigned */ + DUK_ASSERT(classnum <= DUK_HOBJECT_CLASS_MAX); + thr = (duk_hthread *) ctx; + + h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT); + if (!(h != NULL && DUK_HOBJECT_GET_CLASS_NUMBER(h) == classnum)) { + duk_hstring *h_class; + h_class = DUK_HTHREAD_GET_STRING(thr, DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX(classnum)); + DUK_UNREF(h_class); + + DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, (const char *) DUK_HSTRING_GET_DATA(h_class), DUK_STR_UNEXPECTED_TYPE); + } + return h; +} + DUK_EXTERNAL duk_size_t duk_get_length(duk_context *ctx, duk_idx_t index) { duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_get_tval(ctx, index); if (!tv) { @@ -16125,6 +19918,7 @@ DUK_EXTERNAL duk_size_t duk_get_length(duk_context *ctx, duk_idx_t index) { #endif default: /* number */ + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv)); DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); return 0; } @@ -16136,7 +19930,7 @@ DUK_INTERNAL void duk_set_length(duk_context *ctx, duk_idx_t index, duk_size_t l duk_hthread *thr = (duk_hthread *) ctx; duk_hobject *h; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); h = duk_get_hobject(ctx, index); if (!h) { @@ -16179,7 +19973,7 @@ DUK_EXTERNAL void duk_to_defaultvalue(duk_context *ctx, duk_idx_t index, duk_int /* inline initializer for coercers[] is not allowed by old compilers like BCC */ duk_small_int_t coercers[2]; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr != NULL); coercers[0] = DUK_STRIDX_VALUE_OF; @@ -16215,36 +20009,30 @@ DUK_EXTERNAL void duk_to_defaultvalue(duk_context *ctx, duk_idx_t index, duk_int DUK_EXTERNAL void duk_to_undefined(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv; - duk_tval tv_tmp; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_UNREF(thr); tv = duk_require_tval(ctx, index); DUK_ASSERT(tv != NULL); - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_UNDEFINED_ACTUAL(tv); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv); /* side effects */ } DUK_EXTERNAL void duk_to_null(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv; - duk_tval tv_tmp; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_UNREF(thr); tv = duk_require_tval(ctx, index); DUK_ASSERT(tv != NULL); - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_NULL(tv); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_NULL_UPDREF(thr, tv); /* side effects */ } /* E5 Section 9.1 */ DUK_EXTERNAL void duk_to_primitive(duk_context *ctx, duk_idx_t index, duk_int_t hint) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(hint == DUK_HINT_NONE || hint == DUK_HINT_NUMBER || hint == DUK_HINT_STRING); index = duk_require_normalize_index(ctx, index); @@ -16261,10 +20049,9 @@ DUK_EXTERNAL void duk_to_primitive(duk_context *ctx, duk_idx_t index, duk_int_t DUK_EXTERNAL duk_bool_t duk_to_boolean(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv; - duk_tval tv_tmp; duk_bool_t val; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_UNREF(thr); index = duk_require_normalize_index(ctx, index); @@ -16277,19 +20064,16 @@ DUK_EXTERNAL duk_bool_t duk_to_boolean(duk_context *ctx, duk_idx_t index) { /* Note: no need to re-lookup tv, conversion is side effect free */ DUK_ASSERT(tv != NULL); - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_BOOLEAN(tv, val); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_BOOLEAN_UPDREF(thr, tv, val); /* side effects */ return val; } DUK_EXTERNAL duk_double_t duk_to_number(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv; - duk_tval tv_tmp; duk_double_t d; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_require_tval(ctx, index); DUK_ASSERT(tv != NULL); @@ -16298,9 +20082,7 @@ DUK_EXTERNAL duk_double_t duk_to_number(duk_context *ctx, duk_idx_t index) { /* Note: need to re-lookup because ToNumber() may have side effects */ tv = duk_require_tval(ctx, index); - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_NUMBER(tv, d); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_NUMBER_UPDREF(thr, tv, d); /* side effects */ return d; } @@ -16313,10 +20095,9 @@ typedef duk_double_t (*duk__toint_coercer)(duk_hthread *thr, duk_tval *tv); DUK_LOCAL duk_double_t duk__to_int_uint_helper(duk_context *ctx, duk_idx_t index, duk__toint_coercer coerce_func) { duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv; - duk_tval tv_tmp; duk_double_t d; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_require_tval(ctx, index); DUK_ASSERT(tv != NULL); @@ -16326,9 +20107,7 @@ DUK_LOCAL duk_double_t duk__to_int_uint_helper(duk_context *ctx, duk_idx_t index /* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */ tv = duk_require_tval(ctx, index); - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_NUMBER(tv, d); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_NUMBER_UPDREF(thr, tv, d); /* side effects */ return d; } @@ -16336,6 +20115,7 @@ DUK_EXTERNAL duk_int_t duk_to_int(duk_context *ctx, duk_idx_t index) { /* Value coercion (in stack): ToInteger(), E5 Section 9.4 * API return value coercion: custom */ + DUK_ASSERT_CTX_VALID(ctx); (void) duk__to_int_uint_helper(ctx, index, duk_js_tointeger); return (duk_int_t) duk__api_coerce_d2i(ctx, index, 0 /*require*/); } @@ -16344,6 +20124,7 @@ DUK_EXTERNAL duk_uint_t duk_to_uint(duk_context *ctx, duk_idx_t index) { /* Value coercion (in stack): ToInteger(), E5 Section 9.4 * API return value coercion: custom */ + DUK_ASSERT_CTX_VALID(ctx); (void) duk__to_int_uint_helper(ctx, index, duk_js_tointeger); return (duk_uint_t) duk__api_coerce_d2ui(ctx, index, 0 /*require*/); } @@ -16351,10 +20132,9 @@ DUK_EXTERNAL duk_uint_t duk_to_uint(duk_context *ctx, duk_idx_t index) { DUK_EXTERNAL duk_int32_t duk_to_int32(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv; - duk_tval tv_tmp; duk_int32_t ret; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_require_tval(ctx, index); DUK_ASSERT(tv != NULL); @@ -16363,14 +20143,10 @@ DUK_EXTERNAL duk_int32_t duk_to_int32(duk_context *ctx, duk_idx_t index) { /* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */ tv = duk_require_tval(ctx, index); #if defined(DUK_USE_FASTINT) - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_FASTINT_I32(tv, ret); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_FASTINT_I32_UPDREF(thr, tv, ret); /* side effects */ return ret; #else - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_NUMBER(tv, (duk_double_t) ret); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_NUMBER_UPDREF(thr, tv, (duk_double_t) ret); /* side effects */ return ret; #endif } @@ -16378,10 +20154,9 @@ DUK_EXTERNAL duk_int32_t duk_to_int32(duk_context *ctx, duk_idx_t index) { DUK_EXTERNAL duk_uint32_t duk_to_uint32(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv; - duk_tval tv_tmp; duk_uint32_t ret; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_require_tval(ctx, index); DUK_ASSERT(tv != NULL); @@ -16390,14 +20165,10 @@ DUK_EXTERNAL duk_uint32_t duk_to_uint32(duk_context *ctx, duk_idx_t index) { /* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */ tv = duk_require_tval(ctx, index); #if defined(DUK_USE_FASTINT) - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_FASTINT_U32(tv, ret); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_FASTINT_U32_UPDREF(thr, tv, ret); /* side effects */ return ret; #else - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_NUMBER(tv, (duk_double_t) ret); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_NUMBER_UPDREF(thr, tv, (duk_double_t) ret); /* side effects */ #endif return ret; } @@ -16405,10 +20176,9 @@ DUK_EXTERNAL duk_uint32_t duk_to_uint32(duk_context *ctx, duk_idx_t index) { DUK_EXTERNAL duk_uint16_t duk_to_uint16(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv; - duk_tval tv_tmp; duk_uint16_t ret; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_require_tval(ctx, index); DUK_ASSERT(tv != NULL); @@ -16417,29 +20187,68 @@ DUK_EXTERNAL duk_uint16_t duk_to_uint16(duk_context *ctx, duk_idx_t index) { /* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */ tv = duk_require_tval(ctx, index); #if defined(DUK_USE_FASTINT) - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_FASTINT_U32(tv, ret); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_FASTINT_U32_UPDREF(thr, tv, ret); /* side effects */ return ret; #else - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_NUMBER(tv, (duk_double_t) ret); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_NUMBER_UPDREF(thr, tv, (duk_double_t) ret); /* side effects */ #endif return ret; } +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Special coercion for Uint8ClampedArray. */ +DUK_INTERNAL duk_uint8_t duk_to_uint8clamped(duk_context *ctx, duk_idx_t index) { + duk_double_t d; + duk_double_t t; + duk_uint8_t ret; + + /* XXX: Simplify this algorithm, should be possible to come up with + * a shorter and faster algorithm by inspecting IEEE representation + * directly. + */ + + d = duk_to_number(ctx, index); + if (d <= 0.0) { + return 0; + } else if (d >= 255) { + return 255; + } else if (DUK_ISNAN(d)) { + /* Avoid NaN-to-integer coercion as it is compiler specific. */ + return 0; + } + + t = d - DUK_FLOOR(d); + if (t == 0.5) { + /* Exact halfway, round to even. */ + ret = (duk_uint8_t) d; + ret = (ret + 1) & 0xfe; /* Example: d=3.5, t=0.5 -> ret = (3 + 1) & 0xfe = 4 & 0xfe = 4 + * Example: d=4.5, t=0.5 -> ret = (4 + 1) & 0xfe = 5 & 0xfe = 4 + */ + } else { + /* Not halfway, round to nearest. */ + ret = (duk_uint8_t) (d + 0.5); + } + return ret; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + DUK_EXTERNAL const char *duk_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len) { + DUK_ASSERT_CTX_VALID(ctx); + (void) duk_to_string(ctx, index); return duk_require_lstring(ctx, index, out_len); } DUK_LOCAL duk_ret_t duk__safe_to_string_raw(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); + duk_to_string(ctx, -1); return 1; } DUK_EXTERNAL const char *duk_safe_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len) { + DUK_ASSERT_CTX_VALID(ctx); + index = duk_require_normalize_index(ctx, index); /* We intentionally ignore the duk_safe_call() return value and only @@ -16463,11 +20272,65 @@ DUK_EXTERNAL const char *duk_safe_to_lstring(duk_context *ctx, duk_idx_t index, ; } DUK_ASSERT(duk_is_string(ctx, -1)); + DUK_ASSERT(duk_get_string(ctx, -1) != NULL); duk_replace(ctx, index); - return duk_require_lstring(ctx, index, out_len); + return duk_get_lstring(ctx, index, out_len); } +#if defined(DUK_USE_DEBUGGER_SUPPORT) /* only needed by debugger for now */ +DUK_EXTERNAL duk_hstring *duk_safe_to_hstring(duk_context *ctx, duk_idx_t index) { + (void) duk_safe_to_string(ctx, index); + DUK_ASSERT(duk_is_string(ctx, index)); + DUK_ASSERT(duk_get_hstring(ctx, index) != NULL); + return duk_get_hstring(ctx, index); +} +#endif + +/* Coerce top into Object.prototype.toString() output. */ +DUK_INTERNAL void duk_to_object_class_string_top(duk_context *ctx) { + duk_hthread *thr; + duk_uint_t typemask; + duk_hstring *h_strclass; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + + typemask = duk_get_type_mask(ctx, -1); + if (typemask & DUK_TYPE_MASK_UNDEFINED) { + h_strclass = DUK_HTHREAD_STRING_UC_UNDEFINED(thr); + } else if (typemask & DUK_TYPE_MASK_NULL) { + h_strclass = DUK_HTHREAD_STRING_UC_NULL(thr); + } else { + duk_hobject *h_obj; + + duk_to_object(ctx, -1); + h_obj = duk_get_hobject(ctx, -1); + DUK_ASSERT(h_obj != NULL); + + h_strclass = DUK_HOBJECT_GET_CLASS_STRING(thr->heap, h_obj); + } + DUK_ASSERT(h_strclass != NULL); + + duk_pop(ctx); + duk_push_sprintf(ctx, "[object %s]", (const char *) DUK_HSTRING_GET_DATA(h_strclass)); +} + +#if !defined(DUK_USE_PARANOID_ERRORS) +DUK_INTERNAL void duk_push_hobject_class_string(duk_context *ctx, duk_hobject *h) { + duk_hthread *thr; + duk_hstring *h_strclass; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(h != NULL); + thr = (duk_hthread *) ctx; + + h_strclass = DUK_HOBJECT_GET_CLASS_STRING(thr->heap, h); + DUK_ASSERT(h_strclass != NULL); + duk_push_sprintf(ctx, "[object %s]", (const char *) DUK_HSTRING_GET_DATA(h_strclass)); +} +#endif /* !DUK_USE_PARANOID_ERRORS */ + /* XXX: other variants like uint, u32 etc */ DUK_INTERNAL duk_int_t duk_to_int_clamped_raw(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval, duk_bool_t *out_clamped) { duk_hthread *thr = (duk_hthread *) ctx; @@ -16477,7 +20340,7 @@ DUK_INTERNAL duk_int_t duk_to_int_clamped_raw(duk_context *ctx, duk_idx_t index, duk_int_t res; duk_bool_t clamped = 0; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_require_tval(ctx, index); DUK_ASSERT(tv != NULL); @@ -16543,7 +20406,7 @@ DUK_EXTERNAL const char *duk_to_string(duk_context *ctx, duk_idx_t index) { duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_UNREF(thr); index = duk_require_normalize_index(ctx, index); @@ -16610,6 +20473,7 @@ DUK_EXTERNAL const char *duk_to_string(duk_context *ctx, duk_idx_t index) { #endif default: { /* number */ + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv)); DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); duk_push_tval(ctx, tv); duk_numconv_stringify(ctx, @@ -16628,7 +20492,7 @@ DUK_EXTERNAL const char *duk_to_string(duk_context *ctx, duk_idx_t index) { DUK_INTERNAL duk_hstring *duk_to_hstring(duk_context *ctx, duk_idx_t index) { duk_hstring *ret; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); duk_to_string(ctx, index); ret = duk_get_hstring(ctx, index); DUK_ASSERT(ret != NULL); @@ -16642,6 +20506,7 @@ DUK_EXTERNAL void *duk_to_buffer_raw(duk_context *ctx, duk_idx_t index, duk_size duk_size_t src_size; duk_uint8_t *dst_data; + DUK_ASSERT_CTX_VALID(ctx); DUK_UNREF(thr); index = duk_require_normalize_index(ctx, index); @@ -16649,19 +20514,24 @@ DUK_EXTERNAL void *duk_to_buffer_raw(duk_context *ctx, duk_idx_t index, duk_size h_buf = duk_get_hbuffer(ctx, index); if (h_buf != NULL) { /* Buffer is kept as is, with the fixed/dynamic nature of the - * buffer only changed if requested. + * buffer only changed if requested. An external buffer + * is converted into a non-external dynamic buffer in a + * duk_to_dynamic_buffer() call. */ duk_uint_t tmp; + duk_uint8_t *tmp_ptr; - src_data = (const duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_buf); + tmp_ptr = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_buf); + src_data = (const duk_uint8_t *) tmp_ptr; src_size = DUK_HBUFFER_GET_SIZE(h_buf); tmp = (DUK_HBUFFER_HAS_DYNAMIC(h_buf) ? DUK_BUF_MODE_DYNAMIC : DUK_BUF_MODE_FIXED); - if (tmp == mode || mode == DUK_BUF_MODE_DONTCARE) { + if ((tmp == mode && !DUK_HBUFFER_HAS_EXTERNAL(h_buf)) || + mode == DUK_BUF_MODE_DONTCARE) { /* Note: src_data may be NULL if input is a zero-size * dynamic buffer. */ - dst_data = (duk_uint8_t *) src_data; + dst_data = tmp_ptr; goto skip_copy; } } else { @@ -16680,7 +20550,7 @@ DUK_EXTERNAL void *duk_to_buffer_raw(duk_context *ctx, duk_idx_t index, duk_size * target buffer is dynamic). Avoid zero-size memcpy() * with an invalid pointer. */ - DUK_MEMCPY(dst_data, src_data, src_size); + DUK_MEMCPY((void *) dst_data, (const void *) src_data, (size_t) src_size); } duk_replace(ctx, index); skip_copy: @@ -16695,7 +20565,7 @@ DUK_EXTERNAL void *duk_to_pointer(duk_context *ctx, duk_idx_t index) { duk_tval *tv; void *res; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); index = duk_require_normalize_index(ctx, index); @@ -16731,6 +20601,8 @@ DUK_EXTERNAL void *duk_to_pointer(duk_context *ctx, duk_idx_t index) { #endif default: /* number */ + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv)); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); res = NULL; break; } @@ -16746,7 +20618,7 @@ DUK_EXTERNAL void duk_to_object(duk_context *ctx, duk_idx_t index) { duk_uint_t flags = 0; /* shared flags for a subset of types */ duk_small_int_t proto = 0; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); index = duk_require_normalize_index(ctx, index); @@ -16777,11 +20649,35 @@ DUK_EXTERNAL void duk_to_object(duk_context *ctx, duk_idx_t index) { break; } case DUK_TAG_BUFFER: { - flags = DUK_HOBJECT_FLAG_EXTENSIBLE | - DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ | - DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BUFFER); - proto = DUK_BIDX_BUFFER_PROTOTYPE; - goto create_object; + /* A plain buffer coerces to a Duktape.Buffer because it's the + * object counterpart of the plain buffer value. But it might + * still make more sense to produce an ArrayBuffer here? + */ + + duk_hbufferobject *h_bufobj; + duk_hbuffer *h_val; + + h_val = DUK_TVAL_GET_BUFFER(tv); + DUK_ASSERT(h_val != NULL); + + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BUFFER), + DUK_BIDX_BUFFER_PROTOTYPE); + DUK_ASSERT(h_bufobj != NULL); + DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE((duk_hobject *) h_bufobj)); + DUK_ASSERT(DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) h_bufobj)); + + h_bufobj->buf = h_val; + DUK_HBUFFER_INCREF(thr, h_val); + DUK_ASSERT(h_bufobj->offset == 0); + h_bufobj->length = (duk_uint_t) DUK_HBUFFER_GET_SIZE(h_val); + DUK_ASSERT(h_bufobj->shift == 0); + DUK_ASSERT(h_bufobj->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8); + + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + goto replace_value; } case DUK_TAG_POINTER: { flags = DUK_HOBJECT_FLAG_EXTENSIBLE | @@ -16800,16 +20696,16 @@ DUK_EXTERNAL void duk_to_object(duk_context *ctx, duk_idx_t index) { * true */ duk_small_uint_t lf_flags; - duk_small_uint_t nargs; + duk_idx_t nargs; duk_small_uint_t lf_len; duk_c_function func; duk_hnativefunction *nf; DUK_TVAL_GET_LIGHTFUNC(tv, func, lf_flags); - nargs = DUK_LFUNC_FLAGS_GET_NARGS(lf_flags); + nargs = (duk_idx_t) DUK_LFUNC_FLAGS_GET_NARGS(lf_flags); if (nargs == DUK_LFUNC_NARGS_VARARGS) { - nargs = DUK_VARARGS; + nargs = (duk_idx_t) DUK_VARARGS; } flags = DUK_HOBJECT_FLAG_EXTENSIBLE | DUK_HOBJECT_FLAG_CONSTRUCTABLE | @@ -16819,10 +20715,10 @@ DUK_EXTERNAL void duk_to_object(duk_context *ctx, duk_idx_t index) { DUK_HOBJECT_FLAG_NOTAIL | /* DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC: omitted here intentionally */ DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION); - (void) duk__push_c_function_raw(ctx, func, (duk_idx_t) nargs, flags); + (void) duk__push_c_function_raw(ctx, func, nargs, flags); lf_len = DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags); - if (lf_len != nargs) { + if ((duk_idx_t) lf_len != nargs) { /* Explicit length is only needed if it differs from 'nargs'. */ duk_push_int(ctx, (duk_int_t) lf_len); duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE); @@ -16842,6 +20738,8 @@ DUK_EXTERNAL void duk_to_object(duk_context *ctx, duk_idx_t index) { case DUK_TAG_FASTINT: #endif default: { + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv)); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); flags = DUK_HOBJECT_FLAG_EXTENSIBLE | DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_NUMBER); proto = DUK_BIDX_NUMBER_PROTOTYPE; @@ -16884,7 +20782,7 @@ DUK_LOCAL duk_bool_t duk__tag_check(duk_context *ctx, duk_idx_t index, duk_small DUK_LOCAL duk_bool_t duk__obj_flag_any_default_false(duk_context *ctx, duk_idx_t index, duk_uint_t flag_mask) { duk_hobject *obj; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); obj = duk_get_hobject(ctx, index); if (obj) { @@ -16896,6 +20794,8 @@ DUK_LOCAL duk_bool_t duk__obj_flag_any_default_false(duk_context *ctx, duk_idx_t DUK_EXTERNAL duk_int_t duk_get_type(duk_context *ctx, duk_idx_t index) { duk_tval *tv; + DUK_ASSERT_CTX_VALID(ctx); + tv = duk_get_tval(ctx, index); if (!tv) { return DUK_TYPE_NONE; @@ -16922,19 +20822,49 @@ DUK_EXTERNAL duk_int_t duk_get_type(duk_context *ctx, duk_idx_t index) { #endif default: /* Note: number has no explicit tag (in 8-byte representation) */ + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv)); DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); return DUK_TYPE_NUMBER; } DUK_UNREACHABLE(); } +#if defined(DUK_USE_VERBOSE_ERRORS) && defined(DUK_USE_PARANOID_ERRORS) +DUK_LOCAL const char *duk__type_names[] = { + "none", + "undefined", + "null", + "boolean", + "number", + "string", + "object", + "buffer", + "pointer", + "lightfunc" +}; + +DUK_INTERNAL const char *duk_get_type_name(duk_context *ctx, duk_idx_t index) { + duk_int_t type_tag; + + type_tag = duk_get_type(ctx, index); + DUK_ASSERT(type_tag >= DUK_TYPE_MIN && type_tag <= DUK_TYPE_MAX); + DUK_ASSERT(DUK_TYPE_MIN == 0 && sizeof(duk__type_names) / sizeof(const char *) == DUK_TYPE_MAX + 1); + + return duk__type_names[type_tag]; +} +#endif + DUK_EXTERNAL duk_bool_t duk_check_type(duk_context *ctx, duk_idx_t index, duk_int_t type) { + DUK_ASSERT_CTX_VALID(ctx); + return (duk_get_type(ctx, index) == type) ? 1 : 0; } DUK_EXTERNAL duk_uint_t duk_get_type_mask(duk_context *ctx, duk_idx_t index) { duk_tval *tv; + DUK_ASSERT_CTX_VALID(ctx); + tv = duk_get_tval(ctx, index); if (!tv) { return DUK_TYPE_MASK_NONE; @@ -16961,6 +20891,7 @@ DUK_EXTERNAL duk_uint_t duk_get_type_mask(duk_context *ctx, duk_idx_t index) { #endif default: /* Note: number has no explicit tag (in 8-byte representation) */ + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv)); DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); return DUK_TYPE_MASK_NUMBER; } @@ -16969,7 +20900,9 @@ DUK_EXTERNAL duk_uint_t duk_get_type_mask(duk_context *ctx, duk_idx_t index) { DUK_EXTERNAL duk_bool_t duk_check_type_mask(duk_context *ctx, duk_idx_t index, duk_uint_t mask) { duk_hthread *thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); + + DUK_ASSERT_CTX_VALID(ctx); + if (duk_get_type_mask(ctx, index) & mask) { return 1; } @@ -16981,12 +20914,12 @@ DUK_EXTERNAL duk_bool_t duk_check_type_mask(duk_context *ctx, duk_idx_t index, d } DUK_EXTERNAL duk_bool_t duk_is_undefined(duk_context *ctx, duk_idx_t index) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); return duk__tag_check(ctx, index, DUK_TAG_UNDEFINED); } DUK_EXTERNAL duk_bool_t duk_is_null(duk_context *ctx, duk_idx_t index) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); return duk__tag_check(ctx, index, DUK_TAG_NULL); } @@ -16994,6 +20927,8 @@ DUK_EXTERNAL duk_bool_t duk_is_null_or_undefined(duk_context *ctx, duk_idx_t ind duk_tval *tv; duk_small_uint_t tag; + DUK_ASSERT_CTX_VALID(ctx); + tv = duk_get_tval(ctx, index); if (!tv) { return 0; @@ -17003,14 +20938,14 @@ DUK_EXTERNAL duk_bool_t duk_is_null_or_undefined(duk_context *ctx, duk_idx_t ind } DUK_EXTERNAL duk_bool_t duk_is_boolean(duk_context *ctx, duk_idx_t index) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); return duk__tag_check(ctx, index, DUK_TAG_BOOLEAN); } DUK_EXTERNAL duk_bool_t duk_is_number(duk_context *ctx, duk_idx_t index) { duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); /* * Number is special because it doesn't have a specific @@ -17035,6 +20970,8 @@ DUK_EXTERNAL duk_bool_t duk_is_nan(duk_context *ctx, duk_idx_t index) { duk_tval *tv; + DUK_ASSERT_CTX_VALID(ctx); + tv = duk_get_tval(ctx, index); if (!tv || !DUK_TVAL_IS_NUMBER(tv)) { return 0; @@ -17043,34 +20980,34 @@ DUK_EXTERNAL duk_bool_t duk_is_nan(duk_context *ctx, duk_idx_t index) { } DUK_EXTERNAL duk_bool_t duk_is_string(duk_context *ctx, duk_idx_t index) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); return duk__tag_check(ctx, index, DUK_TAG_STRING); } DUK_EXTERNAL duk_bool_t duk_is_object(duk_context *ctx, duk_idx_t index) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); return duk__tag_check(ctx, index, DUK_TAG_OBJECT); } DUK_EXTERNAL duk_bool_t duk_is_buffer(duk_context *ctx, duk_idx_t index) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); return duk__tag_check(ctx, index, DUK_TAG_BUFFER); } DUK_EXTERNAL duk_bool_t duk_is_pointer(duk_context *ctx, duk_idx_t index) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); return duk__tag_check(ctx, index, DUK_TAG_POINTER); } DUK_EXTERNAL duk_bool_t duk_is_lightfunc(duk_context *ctx, duk_idx_t index) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); return duk__tag_check(ctx, index, DUK_TAG_LIGHTFUNC); } DUK_EXTERNAL duk_bool_t duk_is_array(duk_context *ctx, duk_idx_t index) { duk_hobject *obj; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); obj = duk_get_hobject(ctx, index); if (obj) { @@ -17080,7 +21017,11 @@ DUK_EXTERNAL duk_bool_t duk_is_array(duk_context *ctx, duk_idx_t index) { } DUK_EXTERNAL duk_bool_t duk_is_function(duk_context *ctx, duk_idx_t index) { - duk_tval *tv = duk_get_tval(ctx, index); + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); if (tv && DUK_TVAL_IS_LIGHTFUNC(tv)) { return 1; } @@ -17092,52 +21033,37 @@ DUK_EXTERNAL duk_bool_t duk_is_function(duk_context *ctx, duk_idx_t index) { } DUK_EXTERNAL duk_bool_t duk_is_c_function(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); return duk__obj_flag_any_default_false(ctx, index, DUK_HOBJECT_FLAG_NATIVEFUNCTION); } DUK_EXTERNAL duk_bool_t duk_is_ecmascript_function(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); return duk__obj_flag_any_default_false(ctx, index, DUK_HOBJECT_FLAG_COMPILEDFUNCTION); } DUK_EXTERNAL duk_bool_t duk_is_bound_function(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); return duk__obj_flag_any_default_false(ctx, index, DUK_HOBJECT_FLAG_BOUND); } DUK_EXTERNAL duk_bool_t duk_is_thread(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); return duk__obj_flag_any_default_false(ctx, index, DUK_HOBJECT_FLAG_THREAD); } -DUK_EXTERNAL duk_bool_t duk_is_callable(duk_context *ctx, duk_idx_t index) { - /* XXX: currently same as duk_is_function() */ - return duk_is_function(ctx, index); -} - -DUK_EXTERNAL duk_bool_t duk_is_dynamic_buffer(duk_context *ctx, duk_idx_t index) { - duk_tval *tv; - - DUK_ASSERT(ctx != NULL); - - tv = duk_get_tval(ctx, index); - if (tv && DUK_TVAL_IS_BUFFER(tv)) { - duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv); - DUK_ASSERT(h != NULL); - return (DUK_HBUFFER_HAS_DYNAMIC(h) ? 1 : 0); - } - return 0; -} - DUK_EXTERNAL duk_bool_t duk_is_fixed_buffer(duk_context *ctx, duk_idx_t index) { duk_tval *tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); tv = duk_get_tval(ctx, index); if (tv && DUK_TVAL_IS_BUFFER(tv)) { @@ -17148,10 +21074,32 @@ DUK_EXTERNAL duk_bool_t duk_is_fixed_buffer(duk_context *ctx, duk_idx_t index) { return 0; } -/* XXX: make macro in API */ -DUK_EXTERNAL duk_bool_t duk_is_primitive(duk_context *ctx, duk_idx_t index) { - DUK_ASSERT(ctx != NULL); - return !duk_is_object(ctx, index); +DUK_EXTERNAL duk_bool_t duk_is_dynamic_buffer(duk_context *ctx, duk_idx_t index) { + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (tv && DUK_TVAL_IS_BUFFER(tv)) { + duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv); + DUK_ASSERT(h != NULL); + return (DUK_HBUFFER_HAS_DYNAMIC(h) && !DUK_HBUFFER_HAS_EXTERNAL(h) ? 1 : 0); + } + return 0; +} + +DUK_EXTERNAL duk_bool_t duk_is_external_buffer(duk_context *ctx, duk_idx_t index) { + duk_tval *tv; + + DUK_ASSERT_CTX_VALID(ctx); + + tv = duk_get_tval(ctx, index); + if (tv && DUK_TVAL_IS_BUFFER(tv)) { + duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv); + DUK_ASSERT(h != NULL); + return (DUK_HBUFFER_HAS_DYNAMIC(h) && DUK_HBUFFER_HAS_EXTERNAL(h) ? 1 : 0); + } + return 0; } DUK_EXTERNAL duk_errcode_t duk_get_error_code(duk_context *ctx, duk_idx_t index) { @@ -17159,7 +21107,8 @@ DUK_EXTERNAL duk_errcode_t duk_get_error_code(duk_context *ctx, duk_idx_t index) duk_hobject *h; duk_uint_t sanity; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); + h = duk_get_hobject(ctx, index); sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY; @@ -17203,7 +21152,7 @@ DUK_INTERNAL void duk_push_tval(duk_context *ctx, duk_tval *tv) { duk_hthread *thr; duk_tval *tv_slot; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(tv != NULL); thr = (duk_hthread *) ctx; DUK__CHECK_SPACE(); @@ -17212,36 +21161,25 @@ DUK_INTERNAL void duk_push_tval(duk_context *ctx, duk_tval *tv) { DUK_TVAL_INCREF(thr, tv); /* no side effects */ } -#if defined(DUK_USE_DEBUGGER_SUPPORT) -/* Right now only needed by the debugger. */ -DUK_INTERNAL void duk_push_unused(duk_context *ctx) { - duk_hthread *thr; - duk_tval *tv_slot; - - DUK_ASSERT(ctx != NULL); - thr = (duk_hthread *) ctx; - DUK__CHECK_SPACE(); - tv_slot = thr->valstack_top++; - DUK_TVAL_SET_UNDEFINED_UNUSED(tv_slot); -} -#endif - DUK_EXTERNAL void duk_push_undefined(duk_context *ctx) { duk_hthread *thr; - duk_tval *tv_slot; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); thr = (duk_hthread *) ctx; DUK__CHECK_SPACE(); - tv_slot = thr->valstack_top++; - DUK_TVAL_SET_UNDEFINED_ACTUAL(tv_slot); + + /* Because value stack init policy is 'undefined above top', + * we don't need to write, just assert. + */ + thr->valstack_top++; + DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(thr->valstack_top - 1)); } DUK_EXTERNAL void duk_push_null(duk_context *ctx) { duk_hthread *thr; duk_tval *tv_slot; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); thr = (duk_hthread *) ctx; DUK__CHECK_SPACE(); tv_slot = thr->valstack_top++; @@ -17253,7 +21191,7 @@ DUK_EXTERNAL void duk_push_boolean(duk_context *ctx, duk_bool_t val) { duk_tval *tv_slot; duk_small_int_t b; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); thr = (duk_hthread *) ctx; DUK__CHECK_SPACE(); b = (val ? 1 : 0); /* ensure value is 1 or 0 (not other non-zero) */ @@ -17265,7 +21203,7 @@ DUK_EXTERNAL void duk_push_true(duk_context *ctx) { duk_hthread *thr; duk_tval *tv_slot; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); thr = (duk_hthread *) ctx; DUK__CHECK_SPACE(); tv_slot = thr->valstack_top++; @@ -17276,7 +21214,7 @@ DUK_EXTERNAL void duk_push_false(duk_context *ctx) { duk_hthread *thr; duk_tval *tv_slot; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); thr = (duk_hthread *) ctx; DUK__CHECK_SPACE(); tv_slot = thr->valstack_top++; @@ -17289,7 +21227,7 @@ DUK_EXTERNAL void duk_push_number(duk_context *ctx, duk_double_t val) { duk_tval *tv_slot; duk_double_union du; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); thr = (duk_hthread *) ctx; DUK__CHECK_SPACE(); du.d = val; @@ -17303,7 +21241,7 @@ DUK_EXTERNAL void duk_push_int(duk_context *ctx, duk_int_t val) { duk_hthread *thr; duk_tval *tv_slot; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); thr = (duk_hthread *) ctx; DUK__CHECK_SPACE(); tv_slot = thr->valstack_top++; @@ -17322,7 +21260,7 @@ DUK_EXTERNAL void duk_push_int(duk_context *ctx, duk_int_t val) { duk_tval *tv_slot; duk_double_t d; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); thr = (duk_hthread *) ctx; DUK__CHECK_SPACE(); d = (duk_double_t) val; @@ -17336,7 +21274,7 @@ DUK_EXTERNAL void duk_push_uint(duk_context *ctx, duk_uint_t val) { duk_hthread *thr; duk_tval *tv_slot; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); thr = (duk_hthread *) ctx; DUK__CHECK_SPACE(); tv_slot = thr->valstack_top++; @@ -17356,7 +21294,7 @@ DUK_EXTERNAL void duk_push_uint(duk_context *ctx, duk_uint_t val) { duk_tval *tv_slot; duk_double_t d; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); thr = (duk_hthread *) ctx; DUK__CHECK_SPACE(); d = (duk_double_t) val; @@ -17370,7 +21308,7 @@ DUK_EXTERNAL void duk_push_nan(duk_context *ctx) { duk_tval *tv_slot; duk_double_union du; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); thr = (duk_hthread *) ctx; DUK__CHECK_SPACE(); DUK_DBLUNION_SET_NAN(&du); @@ -17384,11 +21322,11 @@ DUK_EXTERNAL const char *duk_push_lstring(duk_context *ctx, const char *str, duk duk_hstring *h; duk_tval *tv_slot; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); /* check stack before interning (avoid hanging temp) */ if (thr->valstack_top >= thr->valstack_end) { - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); + DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK); } /* NULL with zero length represents an empty string; NULL with higher @@ -17405,7 +21343,7 @@ DUK_EXTERNAL const char *duk_push_lstring(duk_context *ctx, const char *str, duk DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_STRING_TOO_LONG); } - h = duk_heap_string_intern_checked(thr, (duk_uint8_t *) str, (duk_uint32_t) len); + h = duk_heap_string_intern_checked(thr, (const duk_uint8_t *) str, (duk_uint32_t) len); DUK_ASSERT(h != NULL); tv_slot = thr->valstack_top++; @@ -17416,7 +21354,7 @@ DUK_EXTERNAL const char *duk_push_lstring(duk_context *ctx, const char *str, duk } DUK_EXTERNAL const char *duk_push_string(duk_context *ctx, const char *str) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); if (str) { return duk_push_lstring(ctx, str, DUK_STRLEN(str)); @@ -17437,7 +21375,8 @@ DUK_EXTERNAL const char *duk_push_string_file_raw(duk_context *ctx, const char * char *buf; long sz; /* ANSI C typing */ - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); + if (!path) { goto fail; } @@ -17481,7 +21420,7 @@ DUK_EXTERNAL const char *duk_push_string_file_raw(duk_context *ctx, const char * #else DUK_EXTERNAL const char *duk_push_string_file_raw(duk_context *ctx, const char *path, duk_uint_t flags) { duk_hthread *thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_UNREF(path); if (flags != 0) { @@ -17499,53 +21438,46 @@ DUK_EXTERNAL void duk_push_pointer(duk_context *ctx, void *val) { duk_hthread *thr; duk_tval *tv_slot; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); thr = (duk_hthread *) ctx; DUK__CHECK_SPACE(); tv_slot = thr->valstack_top++; DUK_TVAL_SET_POINTER(tv_slot, val); } -#define DUK__PUSH_THIS_FLAG_CHECK_COERC (1 << 0) -#define DUK__PUSH_THIS_FLAG_TO_OBJECT (1 << 1) -#define DUK__PUSH_THIS_FLAG_TO_STRING (1 << 2) +DUK_LOCAL void duk__push_this_helper(duk_context *ctx, duk_small_uint_t check_object_coercible) { + duk_hthread *thr; + duk_tval *tv_slot; -DUK_LOCAL void duk__push_this_helper(duk_context *ctx, duk_small_uint_t flags) { - duk_hthread *thr = (duk_hthread *) ctx; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT_DISABLE(thr->callstack_top >= 0); /* avoid warning (unsigned) */ + thr = (duk_hthread *) ctx; DUK_ASSERT(thr->callstack_top <= thr->callstack_size); + DUK__CHECK_SPACE(); - if (thr->callstack_top == 0) { - if (flags & DUK__PUSH_THIS_FLAG_CHECK_COERC) { + DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(thr->valstack_top)); /* because of valstack init policy */ + tv_slot = thr->valstack_top++; + + if (DUK_UNLIKELY(thr->callstack_top == 0)) { + if (check_object_coercible) { goto type_error; } - duk_push_undefined(ctx); + /* 'undefined' already on stack top */ } else { - duk_tval tv_tmp; duk_tval *tv; /* 'this' binding is just before current activation's bottom */ DUK_ASSERT(thr->valstack_bottom > thr->valstack); tv = thr->valstack_bottom - 1; - if (flags & DUK__PUSH_THIS_FLAG_CHECK_COERC) { - if (DUK_TVAL_IS_UNDEFINED(tv) || DUK_TVAL_IS_NULL(tv)) { - goto type_error; - } + if (check_object_coercible && + (DUK_TVAL_IS_UNDEFINED(tv) || DUK_TVAL_IS_NULL(tv))) { + /* XXX: better macro for DUK_TVAL_IS_UNDEFINED_OR_NULL(tv) */ + goto type_error; } - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - duk_push_tval(ctx, &tv_tmp); + DUK_TVAL_SET_TVAL(tv_slot, tv); + DUK_TVAL_INCREF(thr, tv); } - - if (flags & DUK__PUSH_THIS_FLAG_TO_OBJECT) { - duk_to_object(ctx, -1); - } else if (flags & DUK__PUSH_THIS_FLAG_TO_STRING) { - duk_to_string(ctx, -1); - } - return; type_error: @@ -17553,17 +21485,24 @@ DUK_LOCAL void duk__push_this_helper(duk_context *ctx, duk_small_uint_t flags) { } DUK_EXTERNAL void duk_push_this(duk_context *ctx) { - duk__push_this_helper(ctx, 0 /*flags*/); + DUK_ASSERT_CTX_VALID(ctx); + + duk__push_this_helper(ctx, 0 /*check_object_coercible*/); } DUK_INTERNAL void duk_push_this_check_object_coercible(duk_context *ctx) { - duk__push_this_helper(ctx, DUK__PUSH_THIS_FLAG_CHECK_COERC /*flags*/); + DUK_ASSERT_CTX_VALID(ctx); + + duk__push_this_helper(ctx, 1 /*check_object_coercible*/); } DUK_INTERNAL duk_hobject *duk_push_this_coercible_to_object(duk_context *ctx) { duk_hobject *h; - duk__push_this_helper(ctx, DUK__PUSH_THIS_FLAG_CHECK_COERC | - DUK__PUSH_THIS_FLAG_TO_OBJECT /*flags*/); + + DUK_ASSERT_CTX_VALID(ctx); + + duk__push_this_helper(ctx, 1 /*check_object_coercible*/); + duk_to_object(ctx, -1); h = duk_get_hobject(ctx, -1); DUK_ASSERT(h != NULL); return h; @@ -17571,19 +21510,35 @@ DUK_INTERNAL duk_hobject *duk_push_this_coercible_to_object(duk_context *ctx) { DUK_INTERNAL duk_hstring *duk_push_this_coercible_to_string(duk_context *ctx) { duk_hstring *h; - duk__push_this_helper(ctx, DUK__PUSH_THIS_FLAG_CHECK_COERC | - DUK__PUSH_THIS_FLAG_TO_STRING /*flags*/); + + DUK_ASSERT_CTX_VALID(ctx); + + duk__push_this_helper(ctx, 1 /*check_object_coercible*/); + duk_to_string(ctx, -1); h = duk_get_hstring(ctx, -1); DUK_ASSERT(h != NULL); return h; } +DUK_INTERNAL duk_tval *duk_get_borrowed_this_tval(duk_context *ctx) { + duk_hthread *thr; + + DUK_ASSERT(ctx != NULL); + thr = (duk_hthread *) ctx; + + DUK_ASSERT(thr->callstack_top > 0); /* caller required to know */ + DUK_ASSERT(thr->valstack_bottom > thr->valstack); /* consequence of above */ + DUK_ASSERT(thr->valstack_bottom - 1 >= thr->valstack); /* 'this' binding exists */ + + return thr->valstack_bottom - 1; +} + DUK_EXTERNAL void duk_push_current_function(duk_context *ctx) { duk_hthread *thr = (duk_hthread *) ctx; duk_activation *act; + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr != NULL); - DUK_ASSERT(ctx != NULL); DUK_ASSERT_DISABLE(thr->callstack_top >= 0); DUK_ASSERT(thr->callstack_top <= thr->callstack_size); @@ -17598,8 +21553,8 @@ DUK_EXTERNAL void duk_push_current_function(duk_context *ctx) { DUK_EXTERNAL void duk_push_current_thread(duk_context *ctx) { duk_hthread *thr = (duk_hthread *) ctx; + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr != NULL); - DUK_ASSERT(ctx != NULL); if (thr->heap->curr_thread) { duk_push_hobject(ctx, (duk_hobject *) thr->heap->curr_thread); @@ -17609,14 +21564,14 @@ DUK_EXTERNAL void duk_push_current_thread(duk_context *ctx) { } DUK_EXTERNAL void duk_push_global_object(duk_context *ctx) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); duk_push_hobject_bidx(ctx, DUK_BIDX_GLOBAL); } /* XXX: size optimize */ DUK_LOCAL void duk__push_stash(duk_context *ctx) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE)) { DUK_DDD(DUK_DDDPRINT("creating heap/global/thread stash on first use")); duk_pop(ctx); @@ -17630,7 +21585,7 @@ DUK_LOCAL void duk__push_stash(duk_context *ctx) { DUK_EXTERNAL void duk_push_heap_stash(duk_context *ctx) { duk_hthread *thr = (duk_hthread *) ctx; duk_heap *heap; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); heap = thr->heap; DUK_ASSERT(heap->heap_object != NULL); duk_push_hobject(ctx, heap->heap_object); @@ -17638,16 +21593,16 @@ DUK_EXTERNAL void duk_push_heap_stash(duk_context *ctx) { } DUK_EXTERNAL void duk_push_global_stash(duk_context *ctx) { - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); duk_push_global_object(ctx); duk__push_stash(ctx); } DUK_EXTERNAL void duk_push_thread_stash(duk_context *ctx, duk_context *target_ctx) { duk_hthread *thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); if (!target_ctx) { - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); + DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS); return; /* not reached */ } duk_push_hobject(ctx, (duk_hobject *) target_ctx); @@ -17658,6 +21613,7 @@ DUK_EXTERNAL void duk_push_thread_stash(duk_context *ctx, duk_context *target_ct DUK_LOCAL duk_int_t duk__try_push_vsprintf(duk_context *ctx, void *buf, duk_size_t sz, const char *fmt, va_list ap) { duk_int_t len; + DUK_ASSERT_CTX_VALID(ctx); DUK_UNREF(ctx); /* NUL terminator handling doesn't matter here */ @@ -17680,7 +21636,7 @@ DUK_EXTERNAL const char *duk_push_vsprintf(duk_context *ctx, const char *fmt, va duk_int_t len; /* XXX: duk_ssize_t */ const char *res; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); /* special handling of fmt==NULL */ if (!fmt) { @@ -17723,7 +21679,7 @@ DUK_EXTERNAL const char *duk_push_vsprintf(duk_context *ctx, const char *fmt, va /* failed, resize and try again */ sz = sz * 2; if (sz >= DUK_PUSH_SPRINTF_SANITY_LIMIT) { - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_SPRINTF_TOO_LONG); + DUK_ERROR_API(thr, DUK_STR_SPRINTF_TOO_LONG); } } @@ -17741,6 +21697,8 @@ DUK_EXTERNAL const char *duk_push_sprintf(duk_context *ctx, const char *fmt, ... va_list ap; const char *ret; + DUK_ASSERT_CTX_VALID(ctx); + /* allow fmt==NULL */ va_start(ap, fmt); ret = duk_push_vsprintf(ctx, fmt, ap); @@ -17755,18 +21713,18 @@ DUK_INTERNAL duk_idx_t duk_push_object_helper(duk_context *ctx, duk_uint_t hobje duk_hobject *h; duk_idx_t ret; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(prototype_bidx == -1 || (prototype_bidx >= 0 && prototype_bidx < DUK_NUM_BUILTINS)); /* check stack first */ if (thr->valstack_top >= thr->valstack_end) { - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); + DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK); } h = duk_hobject_alloc(thr->heap, hobject_flags_and_class); if (!h) { - DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_OBJECT_ALLOC_FAILED); + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_ALLOC_FAILED); } DUK_DDD(DUK_DDDPRINT("created object with flags: 0x%08lx", (unsigned long) h->hdr.h_flags)); @@ -17794,6 +21752,8 @@ DUK_INTERNAL duk_idx_t duk_push_object_helper_proto(duk_context *ctx, duk_uint_t duk_idx_t ret; duk_hobject *h; + DUK_ASSERT_CTX_VALID(ctx); + ret = duk_push_object_helper(ctx, hobject_flags_and_class, -1); h = duk_get_hobject(ctx, -1); DUK_ASSERT(h != NULL); @@ -17803,6 +21763,8 @@ DUK_INTERNAL duk_idx_t duk_push_object_helper_proto(duk_context *ctx, duk_uint_t } DUK_EXTERNAL duk_idx_t duk_push_object(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); + return duk_push_object_helper(ctx, DUK_HOBJECT_FLAG_EXTENSIBLE | DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT), @@ -17814,6 +21776,8 @@ DUK_EXTERNAL duk_idx_t duk_push_array(duk_context *ctx) { duk_hobject *obj; duk_idx_t ret; + DUK_ASSERT_CTX_VALID(ctx); + ret = duk_push_object_helper(ctx, DUK_HOBJECT_FLAG_EXTENSIBLE | DUK_HOBJECT_FLAG_ARRAY_PART | @@ -17851,11 +21815,11 @@ DUK_EXTERNAL duk_idx_t duk_push_thread_raw(duk_context *ctx, duk_uint_t flags) { duk_idx_t ret; duk_tval *tv_slot; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); /* check stack first */ if (thr->valstack_top >= thr->valstack_end) { - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); + DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK); } obj = duk_hthread_alloc(thr->heap, @@ -17863,7 +21827,7 @@ DUK_EXTERNAL duk_idx_t duk_push_thread_raw(duk_context *ctx, duk_uint_t flags) { DUK_HOBJECT_FLAG_THREAD | DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_THREAD)); if (!obj) { - DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_THREAD_ALLOC_FAILED); + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_ALLOC_FAILED); } obj->state = DUK_HTHREAD_STATE_INACTIVE; #if defined(DUK_USE_HEAPPTR16) @@ -17882,7 +21846,7 @@ DUK_EXTERNAL duk_idx_t duk_push_thread_raw(duk_context *ctx, duk_uint_t flags) { /* important to do this *after* pushing, to make the thread reachable for gc */ if (!duk_hthread_init_stacks(thr->heap, obj)) { - DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_THREAD_ALLOC_FAILED); + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_ALLOC_FAILED); } /* initialize built-ins - either by copying or creating new ones */ @@ -17910,11 +21874,11 @@ DUK_INTERNAL duk_idx_t duk_push_compiledfunction(duk_context *ctx) { duk_idx_t ret; duk_tval *tv_slot; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); /* check stack first */ if (thr->valstack_top >= thr->valstack_end) { - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); + DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK); } /* Template functions are not strictly constructable (they don't @@ -17927,7 +21891,7 @@ DUK_INTERNAL duk_idx_t duk_push_compiledfunction(duk_context *ctx) { DUK_HOBJECT_FLAG_COMPILEDFUNCTION | DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION)); if (!obj) { - DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_FUNC_ALLOC_FAILED); + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_ALLOC_FAILED); } DUK_DDD(DUK_DDDPRINT("created compiled function object with flags: 0x%08lx", (unsigned long) obj->obj.hdr.h_flags)); @@ -17949,19 +21913,19 @@ DUK_LOCAL duk_idx_t duk__push_c_function_raw(duk_context *ctx, duk_c_function fu duk_hnativefunction *obj; duk_idx_t ret; duk_tval *tv_slot; - duk_uint16_t func_nargs; + duk_int16_t func_nargs; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); /* check stack first */ if (thr->valstack_top >= thr->valstack_end) { - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); + DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK); } if (func == NULL) { goto api_error; } if (nargs >= 0 && nargs < DUK_HNATIVEFUNCTION_NARGS_MAX) { - func_nargs = (duk_uint16_t) nargs; + func_nargs = (duk_int16_t) nargs; } else if (nargs == DUK_VARARGS) { func_nargs = DUK_HNATIVEFUNCTION_NARGS_VARARGS; } else { @@ -17970,7 +21934,7 @@ DUK_LOCAL duk_idx_t duk__push_c_function_raw(duk_context *ctx, duk_c_function fu obj = duk_hnativefunction_alloc(thr->heap, flags); if (!obj) { - DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_FUNC_ALLOC_FAILED); + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_ALLOC_FAILED); } obj->func = func; @@ -17991,13 +21955,15 @@ DUK_LOCAL duk_idx_t duk__push_c_function_raw(duk_context *ctx, duk_c_function fu return ret; api_error: - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); + DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS); return 0; /* not reached */ } DUK_EXTERNAL duk_idx_t duk_push_c_function(duk_context *ctx, duk_c_function func, duk_int_t nargs) { duk_uint_t flags; + DUK_ASSERT_CTX_VALID(ctx); + flags = DUK_HOBJECT_FLAG_EXTENSIBLE | DUK_HOBJECT_FLAG_CONSTRUCTABLE | DUK_HOBJECT_FLAG_NATIVEFUNCTION | @@ -18013,6 +21979,8 @@ DUK_EXTERNAL duk_idx_t duk_push_c_function(duk_context *ctx, duk_c_function func DUK_INTERNAL void duk_push_c_function_noexotic(duk_context *ctx, duk_c_function func, duk_int_t nargs) { duk_uint_t flags; + DUK_ASSERT_CTX_VALID(ctx); + flags = DUK_HOBJECT_FLAG_EXTENSIBLE | DUK_HOBJECT_FLAG_CONSTRUCTABLE | DUK_HOBJECT_FLAG_NATIVEFUNCTION | @@ -18027,6 +21995,8 @@ DUK_INTERNAL void duk_push_c_function_noexotic(duk_context *ctx, duk_c_function DUK_INTERNAL void duk_push_c_function_noconstruct_noexotic(duk_context *ctx, duk_c_function func, duk_int_t nargs) { duk_uint_t flags; + DUK_ASSERT_CTX_VALID(ctx); + flags = DUK_HOBJECT_FLAG_EXTENSIBLE | DUK_HOBJECT_FLAG_NATIVEFUNCTION | DUK_HOBJECT_FLAG_NEWENV | @@ -18042,11 +22012,11 @@ DUK_EXTERNAL duk_idx_t duk_push_c_lightfunc(duk_context *ctx, duk_c_function fun duk_tval tv_tmp; duk_small_uint_t lf_flags; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); /* check stack first */ if (thr->valstack_top >= thr->valstack_end) { - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); + DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK); } if (nargs >= DUK_LFUNC_NARGS_MIN && nargs <= DUK_LFUNC_NARGS_MAX) { @@ -18070,10 +22040,167 @@ DUK_EXTERNAL duk_idx_t duk_push_c_lightfunc(duk_context *ctx, duk_c_function fun return ((duk_idx_t) (thr->valstack_top - thr->valstack_bottom)) - 1; api_error: - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); + DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS); return 0; /* not reached */ } +DUK_INTERNAL duk_hbufferobject *duk_push_bufferobject_raw(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_hbufferobject *obj; + duk_tval *tv_slot; + + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(prototype_bidx >= 0); + + /* check stack first */ + if (thr->valstack_top >= thr->valstack_end) { + DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK); + } + + obj = duk_hbufferobject_alloc(thr->heap, hobject_flags_and_class); + if (!obj) { + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_ALLOC_FAILED); + } + + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) obj, thr->builtins[prototype_bidx]); + DUK_ASSERT_HBUFFEROBJECT_VALID(obj); + + tv_slot = thr->valstack_top; + DUK_TVAL_SET_OBJECT(tv_slot, (duk_hobject *) obj); + DUK_HOBJECT_INCREF(thr, obj); + thr->valstack_top++; + + return obj; +} + +/* XXX: There's quite a bit of overlap with buffer creation handling in + * duk_bi_buffer.c. Look for overlap and refactor. + */ +#define DUK__PACK_ARGS(classnum,protobidx,elemtype,elemshift,isview) \ + (((classnum) << 24) | ((protobidx) << 16) | ((elemtype) << 8) | ((elemshift) << 4) | (isview)) + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +static const duk_uint32_t duk__bufobj_flags_lookup[] = { + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_BUFFER, DUK_BIDX_BUFFER_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT8, 0, 0), /* DUK_BUFOBJ_DUKTAPE_BUFFER */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_BUFFER, DUK_BIDX_NODEJS_BUFFER_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT8, 0, 0), /* DUK_BUFOBJ_NODEJS_BUFFER */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_ARRAYBUFFER, DUK_BIDX_ARRAYBUFFER_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT8, 0, 0), /* DUK_BUFOBJ_ARRAYBUFFER */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_DATAVIEW, DUK_BIDX_DATAVIEW_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT8, 0, 1), /* DUK_BUFOBJ_DATAVIEW */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_INT8ARRAY, DUK_BIDX_INT8ARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_INT8, 0, 1), /* DUK_BUFOBJ_INT8ARRAY */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT8ARRAY, DUK_BIDX_UINT8ARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT8, 0, 1), /* DUK_BUFOBJ_UINT8ARRAY */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY, DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED, 0, 1), /* DUK_BUFOBJ_UINT8CLAMPEDARRAY */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_INT16ARRAY, DUK_BIDX_INT16ARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_INT16, 1, 1), /* DUK_BUFOBJ_INT16ARRAY */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT16ARRAY, DUK_BIDX_UINT16ARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT16, 1, 1), /* DUK_BUFOBJ_UINT16ARRAY */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_INT32ARRAY, DUK_BIDX_INT32ARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_INT32, 2, 1), /* DUK_BUFOBJ_INT32ARRAY */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT32ARRAY, DUK_BIDX_UINT32ARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT32, 2, 1), /* DUK_BUFOBJ_UINT32ARRAY */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_FLOAT32ARRAY, DUK_BIDX_FLOAT32ARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_FLOAT32, 2, 1), /* DUK_BUFOBJ_FLOAT32ARRAY */ + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_FLOAT64ARRAY, DUK_BIDX_FLOAT64ARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_FLOAT64, 3, 1) /* DUK_BUFOBJ_FLOAT64ARRAY */ +}; +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +/* Only allow Duktape.Buffer when support disabled. */ +static const duk_uint32_t duk__bufobj_flags_lookup[] = { + DUK__PACK_ARGS(DUK_HOBJECT_CLASS_BUFFER, DUK_BIDX_BUFFER_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT8, 0, 0) /* DUK_BUFOBJ_DUKTAPE_BUFFER */ +}; +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ +#undef DUK__PACK_ARGS + +DUK_EXTERNAL void duk_push_buffer_object(duk_context *ctx, duk_idx_t idx_buffer, duk_size_t byte_offset, duk_size_t byte_length, duk_uint_t flags) { + duk_hthread *thr; + duk_hbufferobject *h_bufobj; + duk_hbuffer *h_val; + duk_uint32_t tmp; + duk_uint_t classnum; + duk_uint_t protobidx; + duk_uint_t lookupidx; + duk_uint_t uint_offset, uint_length, uint_added; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + /* The underlying types for offset/length in duk_hbufferobject is + * duk_uint_t; make sure argument values fit and that offset + length + * does not wrap. + */ + uint_offset = (duk_uint_t) byte_offset; + uint_length = (duk_uint_t) byte_length; + if (sizeof(duk_size_t) != sizeof(duk_uint_t)) { + if ((duk_size_t) uint_offset != byte_offset || (duk_size_t) uint_length != byte_length) { + goto range_error; + } + } + uint_added = uint_offset + uint_length; + if (uint_added < uint_offset) { + goto range_error; + } + DUK_ASSERT(uint_added >= uint_offset && uint_added >= uint_length); + + DUK_ASSERT_DISABLE(flags >= 0); /* flags is unsigned */ + lookupidx = flags & 0x0f; /* 4 low bits */ + if (lookupidx >= sizeof(duk__bufobj_flags_lookup) / sizeof(duk_uint32_t)) { + goto arg_error; + } + tmp = duk__bufobj_flags_lookup[lookupidx]; + classnum = tmp >> 24; + protobidx = (tmp >> 16) & 0xff; + + h_val = duk_require_hbuffer(ctx, idx_buffer); + DUK_ASSERT(h_val != NULL); + + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(classnum), + protobidx); + DUK_ASSERT(h_bufobj != NULL); + + h_bufobj->buf = h_val; + DUK_HBUFFER_INCREF(thr, h_val); + h_bufobj->offset = uint_offset; + h_bufobj->length = uint_length; + h_bufobj->shift = (tmp >> 4) & 0x0f; + h_bufobj->elem_type = (tmp >> 8) & 0xff; + h_bufobj->is_view = tmp & 0x0f; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) + /* TypedArray views need an automatic ArrayBuffer which must be + * provided as .buffer property of the view. Just create a new + * ArrayBuffer sharing the same underlying buffer. + */ + if (flags & DUK_BUFOBJ_CREATE_ARRBUF) { + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ARRAYBUFFER), + DUK_BIDX_ARRAYBUFFER_PROTOTYPE); + + DUK_ASSERT(h_bufobj != NULL); + + h_bufobj->buf = h_val; + DUK_HBUFFER_INCREF(thr, h_val); + h_bufobj->offset = uint_offset; + h_bufobj->length = uint_length; + DUK_ASSERT(h_bufobj->shift == 0); + h_bufobj->elem_type = DUK_HBUFFEROBJECT_ELEM_UINT8; + DUK_ASSERT(h_bufobj->is_view == 0); + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LC_BUFFER, DUK_PROPDESC_FLAGS_NONE); + duk_compact(ctx, -1); + } +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + + return; + + range_error: + DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_INVALID_CALL_ARGS); + return; /* not reached */ + + arg_error: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_CALL_ARGS); + return; /* not reached */ +} + DUK_EXTERNAL duk_idx_t duk_push_error_object_va_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, va_list ap) { duk_hthread *thr = (duk_hthread *) ctx; duk_idx_t ret; @@ -18082,7 +22209,7 @@ DUK_EXTERNAL duk_idx_t duk_push_error_object_va_raw(duk_context *ctx, duk_errcod duk_bool_t noblame_fileline; #endif - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr != NULL); DUK_UNREF(filename); DUK_UNREF(line); @@ -18134,6 +22261,8 @@ DUK_EXTERNAL duk_idx_t duk_push_error_object_raw(duk_context *ctx, duk_errcode_t va_list ap; duk_idx_t ret; + DUK_ASSERT_CTX_VALID(ctx); + va_start(ap, fmt); ret = duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap); va_end(ap); @@ -18147,6 +22276,8 @@ DUK_EXTERNAL duk_idx_t duk_push_error_object_stash(duk_context *ctx, duk_errcode va_list ap; duk_idx_t ret; + DUK_ASSERT_CTX_VALID(ctx); + duk_api_global_filename = NULL; duk_api_global_line = 0; va_start(ap, fmt); @@ -18160,12 +22291,13 @@ DUK_EXTERNAL void *duk_push_buffer_raw(duk_context *ctx, duk_size_t size, duk_sm duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv_slot; duk_hbuffer *h; + void *buf_data; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); /* check stack first */ if (thr->valstack_top >= thr->valstack_end) { - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); + DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK); } /* Check for maximum buffer length. */ @@ -18173,9 +22305,9 @@ DUK_EXTERNAL void *duk_push_buffer_raw(duk_context *ctx, duk_size_t size, duk_sm DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_BUFFER_TOO_LONG); } - h = duk_hbuffer_alloc(thr->heap, size, flags); + h = duk_hbuffer_alloc(thr->heap, size, flags, &buf_data); if (!h) { - DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_BUFFER_ALLOC_FAILED); + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_ALLOC_FAILED); } tv_slot = thr->valstack_top; @@ -18183,14 +22315,14 @@ DUK_EXTERNAL void *duk_push_buffer_raw(duk_context *ctx, duk_size_t size, duk_sm DUK_HBUFFER_INCREF(thr, h); thr->valstack_top++; - return DUK_HBUFFER_GET_DATA_PTR(thr->heap, h); + return (void *) buf_data; } DUK_EXTERNAL duk_idx_t duk_push_heapptr(duk_context *ctx, void *ptr) { duk_hthread *thr = (duk_hthread *) ctx; duk_idx_t ret; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom); @@ -18198,7 +22330,7 @@ DUK_EXTERNAL duk_idx_t duk_push_heapptr(duk_context *ctx, void *ptr) { goto push_undefined; } - switch (DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) ptr)) { + switch ((int) DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) ptr)) { case DUK_HTYPE_STRING: duk_push_hstring(ctx, (duk_hstring *) ptr); break; @@ -18227,7 +22359,7 @@ DUK_INTERNAL duk_idx_t duk_push_object_internal(duk_context *ctx) { DUK_INTERNAL void duk_push_hstring(duk_context *ctx, duk_hstring *h) { duk_tval tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(h != NULL); DUK_TVAL_SET_STRING(&tv, h); duk_push_tval(ctx, &tv); @@ -18241,7 +22373,7 @@ DUK_INTERNAL void duk_push_hstring_stridx(duk_context *ctx, duk_small_int_t stri DUK_INTERNAL void duk_push_hobject(duk_context *ctx, duk_hobject *h) { duk_tval tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(h != NULL); DUK_TVAL_SET_OBJECT(&tv, h); duk_push_tval(ctx, &tv); @@ -18249,7 +22381,7 @@ DUK_INTERNAL void duk_push_hobject(duk_context *ctx, duk_hobject *h) { DUK_INTERNAL void duk_push_hbuffer(duk_context *ctx, duk_hbuffer *h) { duk_tval tv; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(h != NULL); DUK_TVAL_SET_BUFFER(&tv, h); duk_push_tval(ctx, &tv); @@ -18257,7 +22389,7 @@ DUK_INTERNAL void duk_push_hbuffer(duk_context *ctx, duk_hbuffer *h) { DUK_INTERNAL void duk_push_hobject_bidx(duk_context *ctx, duk_small_int_t builtin_idx) { duk_hthread *thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr != NULL); DUK_ASSERT(builtin_idx >= 0 && builtin_idx < DUK_NUM_BUILTINS); DUK_ASSERT(thr->builtins[builtin_idx] != NULL); @@ -18270,16 +22402,18 @@ DUK_INTERNAL void duk_push_hobject_bidx(duk_context *ctx, duk_small_int_t builti DUK_EXTERNAL void duk_pop_n(duk_context *ctx, duk_idx_t count) { duk_hthread *thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); + duk_tval *tv; - if (count < 0) { - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_COUNT); + DUK_ASSERT_CTX_VALID(ctx); + + if (DUK_UNLIKELY(count < 0)) { + DUK_ERROR_API(thr, DUK_STR_INVALID_COUNT); return; } DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); - if ((duk_size_t) (thr->valstack_top - thr->valstack_bottom) < (duk_size_t) count) { - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_POP_TOO_MANY); + if (DUK_UNLIKELY((duk_size_t) (thr->valstack_top - thr->valstack_bottom) < (duk_size_t) count)) { + DUK_ERROR_API(thr, DUK_STR_POP_TOO_MANY); } /* @@ -18292,41 +22426,66 @@ DUK_EXTERNAL void duk_pop_n(duk_context *ctx, duk_idx_t count) { * instability), inline code. */ -#ifdef DUK_USE_REFERENCE_COUNTING - while (count > 0) { - duk_tval tv_tmp; - duk_tval *tv; + /* XXX: optimize loops */ +#if defined(DUK_USE_REFERENCE_COUNTING) + while (count > 0) { + count--; tv = --thr->valstack_top; /* tv points to element just below prev top */ DUK_ASSERT(tv >= thr->valstack_bottom); - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_UNDEFINED_UNUSED(tv); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ - count--; + DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv); /* side effects */ } #else + tv = thr->valstack_top; while (count > 0) { - duk_tval *tv; - - tv = --thr->valstack_top; - DUK_ASSERT(tv >= thr->valstack_bottom); - DUK_TVAL_SET_UNDEFINED_UNUSED(tv); count--; + tv--; + DUK_ASSERT(tv >= thr->valstack_bottom); + DUK_TVAL_SET_UNDEFINED(tv); } + thr->valstack_top = tv; #endif DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); } +/* Popping one element is called so often that when footprint is not an issue, + * compile a specialized function for it. + */ +#if defined(DUK_USE_PREFER_SIZE) DUK_EXTERNAL void duk_pop(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); duk_pop_n(ctx, 1); } +#else +DUK_EXTERNAL void duk_pop(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + duk_tval *tv; + DUK_ASSERT_CTX_VALID(ctx); + + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + if (DUK_UNLIKELY(thr->valstack_top == thr->valstack_bottom)) { + DUK_ERROR_API(thr, DUK_STR_POP_TOO_MANY); + } + + tv = --thr->valstack_top; /* tv points to element just below prev top */ + DUK_ASSERT(tv >= thr->valstack_bottom); +#ifdef DUK_USE_REFERENCE_COUNTING + DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv); /* side effects */ +#else + DUK_TVAL_SET_UNDEFINED(tv); +#endif + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); +} +#endif /* !DUK_USE_PREFER_SIZE */ DUK_EXTERNAL void duk_pop_2(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); duk_pop_n(ctx, 2); } DUK_EXTERNAL void duk_pop_3(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); duk_pop_n(ctx, 3); } @@ -18342,7 +22501,7 @@ DUK_EXTERNAL void duk_throw(duk_context *ctx) { DUK_ASSERT(thr->valstack_end >= thr->valstack_top); if (thr->valstack_top == thr->valstack_bottom) { - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); + DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS); } /* Errors are augmented when they are created, not when they are @@ -18350,6 +22509,12 @@ DUK_EXTERNAL void duk_throw(duk_context *ctx) { * just before an error is thrown. */ + /* Sync so that augmentation sees up-to-date activations, NULL + * thr->ptr_curr_pc so that it's not used if side effects occur + * in augmentation or longjmp handling. + */ + duk_hthread_sync_and_null_currpc(thr); + #if defined(DUK_USE_AUGMENT_ERROR_THROW) DUK_DDD(DUK_DDDPRINT("THROW ERROR (API): %!dT (before throw augment)", (duk_tval *) duk_get_tval(ctx, -1))); duk_err_augment_error_throw(thr); @@ -18370,7 +22535,7 @@ DUK_EXTERNAL void duk_throw(duk_context *ctx) { DUK_EXTERNAL void duk_fatal(duk_context *ctx, duk_errcode_t err_code, const char *err_msg) { duk_hthread *thr = (duk_hthread *) ctx; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(thr != NULL); DUK_ASSERT(thr->heap != NULL); DUK_ASSERT(thr->heap->fatal_func != NULL); @@ -18388,12 +22553,17 @@ DUK_EXTERNAL void duk_fatal(duk_context *ctx, duk_errcode_t err_code, const char } DUK_EXTERNAL void duk_error_va_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, va_list ap) { + DUK_ASSERT_CTX_VALID(ctx); + duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap); duk_throw(ctx); } DUK_EXTERNAL void duk_error_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, ...) { va_list ap; + + DUK_ASSERT_CTX_VALID(ctx); + va_start(ap, fmt); duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap); va_end(ap); @@ -18406,6 +22576,8 @@ DUK_EXTERNAL void duk_error_stash(duk_context *ctx, duk_errcode_t err_code, cons duk_int_t line; va_list ap; + DUK_ASSERT_CTX_VALID(ctx); + filename = duk_api_global_filename; line = duk_api_global_line; duk_api_global_filename = NULL; @@ -18426,12 +22598,11 @@ DUK_EXTERNAL duk_bool_t duk_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv1, *tv2; + DUK_ASSERT_CTX_VALID(ctx); + tv1 = duk_get_tval(ctx, index1); - if (!tv1) { - return 0; - } tv2 = duk_get_tval(ctx, index2); - if (!tv2) { + if ((tv1 == NULL) || (tv2 == NULL)) { return 0; } @@ -18444,12 +22615,11 @@ DUK_EXTERNAL duk_bool_t duk_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t DUK_EXTERNAL duk_bool_t duk_strict_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2) { duk_tval *tv1, *tv2; + DUK_ASSERT_CTX_VALID(ctx); + tv1 = duk_get_tval(ctx, index1); - if (!tv1) { - return 0; - } tv2 = duk_get_tval(ctx, index2); - if (!tv2) { + if ((tv1 == NULL) || (tv2 == NULL)) { return 0; } @@ -18457,6 +22627,29 @@ DUK_EXTERNAL duk_bool_t duk_strict_equals(duk_context *ctx, duk_idx_t index1, du return duk_js_strict_equals(tv1, tv2); } +/* + * instanceof + */ + +DUK_EXTERNAL duk_bool_t duk_instanceof(duk_context *ctx, duk_idx_t index1, duk_idx_t index2) { + duk_tval *tv1, *tv2; + + DUK_ASSERT_CTX_VALID(ctx); + + /* Index validation is strict, which differs from duk_equals(). + * The strict behavior mimics how instanceof itself works, e.g. + * it is a TypeError if rval is not a -callable- object. It would + * be somewhat inconsistent if rval would be allowed to be + * non-existent without a TypeError. + */ + tv1 = duk_require_tval(ctx, index1); + DUK_ASSERT(tv1 != NULL); + tv2 = duk_require_tval(ctx, index2); + DUK_ASSERT(tv2 != NULL); + + return duk_js_instanceof((duk_hthread *) ctx, tv1, tv2); +} + /* * Lightfunc */ @@ -18528,7 +22721,129 @@ DUK_INTERNAL void duk_push_string_funcptr(duk_context *ctx, duk_uint8_t *ptr, du duk_push_lstring(ctx, (const char *) buf, sz * 2); } +#if !defined(DUK_USE_PARANOID_ERRORS) +/* + * Push readable string summarizing duk_tval. The operation is side effect + * free and will only throw from internal errors (e.g. out of memory). + * This is used by e.g. property access code to summarize a key/base safely, + * and is not intended to be fast (but small and safe). + */ + +#define DUK__READABLE_STRING_MAXCHARS 32 + +/* String sanitizer which escapes ASCII control characters and a few other + * ASCII characters, passes Unicode as is, and replaces invalid UTF-8 with + * question marks. No errors are thrown for any input string, except in out + * of memory situations. + */ +DUK_LOCAL void duk__push_hstring_readable_unicode(duk_context *ctx, duk_hstring *h_input) { + duk_hthread *thr; + const duk_uint8_t *p, *p_start, *p_end; + duk_uint8_t buf[DUK_UNICODE_MAX_XUTF8_LENGTH * DUK__READABLE_STRING_MAXCHARS + + 2 /*quotes*/ + 3 /*periods*/]; + duk_uint8_t *q; + duk_ucodepoint_t cp; + duk_small_uint_t nchars; + + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(h_input != NULL); + thr = (duk_hthread *) ctx; + + p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input); + p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input); + p = p_start; + q = buf; + + nchars = 0; + *q++ = (duk_uint8_t) DUK_ASC_SINGLEQUOTE; + for (;;) { + if (p >= p_end) { + break; + } + if (nchars == DUK__READABLE_STRING_MAXCHARS) { + *q++ = (duk_uint8_t) DUK_ASC_PERIOD; + *q++ = (duk_uint8_t) DUK_ASC_PERIOD; + *q++ = (duk_uint8_t) DUK_ASC_PERIOD; + break; + } + if (duk_unicode_decode_xutf8(thr, &p, p_start, p_end, &cp)) { + if (cp < 0x20 || cp == 0x7f || cp == DUK_ASC_SINGLEQUOTE || cp == DUK_ASC_BACKSLASH) { + DUK_ASSERT(DUK_UNICODE_MAX_XUTF8_LENGTH >= 4); /* estimate is valid */ + DUK_ASSERT((cp >> 4) <= 0x0f); + *q++ = (duk_uint8_t) DUK_ASC_BACKSLASH; + *q++ = (duk_uint8_t) DUK_ASC_LC_X; + *q++ = (duk_uint8_t) duk_lc_digits[cp >> 4]; + *q++ = (duk_uint8_t) duk_lc_digits[cp & 0x0f]; + } else { + q += duk_unicode_encode_xutf8(cp, q); + } + } else { + p++; /* advance manually */ + *q++ = (duk_uint8_t) DUK_ASC_QUESTION; + } + nchars++; + } + *q++ = (duk_uint8_t) DUK_ASC_SINGLEQUOTE; + + duk_push_lstring(ctx, (const char *) buf, (duk_size_t) (q - buf)); +} + +DUK_INTERNAL const char *duk_push_string_tval_readable(duk_context *ctx, duk_tval *tv) { + duk_hthread *thr; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + if (tv == NULL) { + duk_push_string(ctx, "none"); + } else { + switch (DUK_TVAL_GET_TAG(tv)) { + case DUK_TAG_STRING: { + duk__push_hstring_readable_unicode(ctx, DUK_TVAL_GET_STRING(tv)); + break; + } + case DUK_TAG_OBJECT: { + duk_hobject *h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + duk_push_hobject_class_string(ctx, h); + break; + } + case DUK_TAG_BUFFER: { + /* XXX: Hex encoded, length limited buffer summary here? */ + duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv); + DUK_ASSERT(h != NULL); + duk_push_sprintf(ctx, "[buffer:%ld]", (long) DUK_HBUFFER_GET_SIZE(h)); + break; + } + case DUK_TAG_POINTER: { + /* Surround with parentheses like in JX, ensures NULL pointer + * is distinguishable from null value ("(null)" vs "null"). + */ + duk_push_tval(ctx, tv); + duk_push_sprintf(ctx, "(%s)", duk_to_string(ctx, -1)); + duk_remove(ctx, -2); + break; + } + default: { + duk_push_tval(ctx, tv); + break; + } + } + } + + return duk_to_string(ctx, -1); +} + +DUK_INTERNAL const char *duk_push_string_readable(duk_context *ctx, duk_idx_t index) { + DUK_ASSERT_CTX_VALID(ctx); + return duk_push_string_tval_readable(ctx, duk_get_tval(ctx, index)); +} +#endif /* !DUK_USE_PARANOID_ERRORS */ + #undef DUK__CHECK_SPACE +#undef DUK__PACK_ARGS +#undef DUK__READABLE_STRING_MAXCHARS #line 1 "duk_api_string.c" /* * String manipulation @@ -18545,11 +22860,11 @@ DUK_LOCAL void duk__concat_and_join_helper(duk_context *ctx, duk_idx_t count_in, duk_hstring *h; duk_uint8_t *buf; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); if (DUK_UNLIKELY(count_in <= 0)) { if (count_in < 0) { - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_COUNT); + DUK_ERROR_API(thr, DUK_STR_INVALID_COUNT); return; } DUK_ASSERT(count_in == 0); @@ -18563,7 +22878,7 @@ DUK_LOCAL void duk__concat_and_join_helper(duk_context *ctx, duk_idx_t count_in, h = duk_to_hstring(ctx, -((duk_idx_t) count) - 1); DUK_ASSERT(h != NULL); - /* A bit tricky overflow test, see doc/code-issues.txt. */ + /* A bit tricky overflow test, see doc/code-issues.rst. */ t1 = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h); t2 = (duk_size_t) (count - 1); limit = (duk_size_t) DUK_HSTRING_MAX_BYTELEN; @@ -18639,10 +22954,14 @@ DUK_LOCAL void duk__concat_and_join_helper(duk_context *ctx, duk_idx_t count_in, } DUK_EXTERNAL void duk_concat(duk_context *ctx, duk_idx_t count) { + DUK_ASSERT_CTX_VALID(ctx); + duk__concat_and_join_helper(ctx, count, 0 /*is_join*/); } DUK_EXTERNAL void duk_join(duk_context *ctx, duk_idx_t count) { + DUK_ASSERT_CTX_VALID(ctx); + duk__concat_and_join_helper(ctx, count, 1 /*is_join*/); } @@ -18656,10 +22975,12 @@ DUK_EXTERNAL void duk_decode_string(duk_context *ctx, duk_idx_t index, duk_decod const duk_uint8_t *p, *p_start, *p_end; duk_codepoint_t cp; + DUK_ASSERT_CTX_VALID(ctx); + h_input = duk_require_hstring(ctx, index); DUK_ASSERT(h_input != NULL); - p_start = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input); + p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input); p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input); p = p_start; @@ -18675,35 +22996,41 @@ DUK_EXTERNAL void duk_decode_string(duk_context *ctx, duk_idx_t index, duk_decod DUK_EXTERNAL void duk_map_string(duk_context *ctx, duk_idx_t index, duk_map_char_function callback, void *udata) { duk_hthread *thr = (duk_hthread *) ctx; duk_hstring *h_input; - duk_hbuffer_dynamic *h_buf; + duk_bufwriter_ctx bw_alloc; + duk_bufwriter_ctx *bw; const duk_uint8_t *p, *p_start, *p_end; duk_codepoint_t cp; + DUK_ASSERT_CTX_VALID(ctx); + index = duk_normalize_index(ctx, index); h_input = duk_require_hstring(ctx, index); DUK_ASSERT(h_input != NULL); - /* XXX: should init with a spare of at least h_input->blen? */ - duk_push_dynamic_buffer(ctx, 0); - h_buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1); - DUK_ASSERT(h_buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(h_buf)); + bw = &bw_alloc; + DUK_BW_INIT_PUSHBUF(thr, bw, DUK_HSTRING_GET_BYTELEN(h_input)); /* reasonable output estimate */ - p_start = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input); + p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input); p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input); p = p_start; for (;;) { + /* XXX: could write output in chunks with fewer ensure calls, + * but relative benefit would be small here. + */ + if (p >= p_end) { break; } cp = (int) duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end); cp = callback(udata, cp); - duk_hbuffer_append_xutf8(thr, h_buf, cp); + + DUK_BW_WRITE_ENSURE_XUTF8(thr, bw, cp); } - duk_to_string(ctx, -1); /* invalidates h_buf pointer */ + DUK_BW_COMPACT(thr, bw); + duk_to_string(ctx, -1); duk_replace(ctx, index); } @@ -18714,7 +23041,7 @@ DUK_EXTERNAL void duk_substring(duk_context *ctx, duk_idx_t index, duk_size_t st duk_size_t start_byte_offset; duk_size_t end_byte_offset; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); index = duk_require_normalize_index(ctx, index); h = duk_require_hstring(ctx, index); @@ -18761,6 +23088,8 @@ DUK_EXTERNAL void duk_trim(duk_context *ctx, duk_idx_t index) { const duk_uint8_t *q_start, *q_end; /* start (incl) and end (excl) of trimmed part */ duk_codepoint_t cp; + DUK_ASSERT_CTX_VALID(ctx); + index = duk_require_normalize_index(ctx, index); h = duk_require_hstring(ctx, index); DUK_ASSERT(h != NULL); @@ -18816,7 +23145,8 @@ DUK_EXTERNAL void duk_trim(duk_context *ctx, duk_idx_t index) { DUK_ASSERT(q_end >= q_start); DUK_DDD(DUK_DDDPRINT("trim: p_start=%p, p_end=%p, q_start=%p, q_end=%p", - (void *) p_start, (void *) p_end, (void *) q_start, (void *) q_end)); + (const void *) p_start, (const void *) p_end, + (const void *) q_start, (const void *) q_end)); if (q_start == p_start && q_end == p_end) { DUK_DDD(DUK_DDDPRINT("nothing was trimmed: avoid interning (hashing etc)")); @@ -18832,6 +23162,8 @@ DUK_EXTERNAL duk_codepoint_t duk_char_code_at(duk_context *ctx, duk_idx_t index, duk_hstring *h; duk_ucodepoint_t cp; + DUK_ASSERT_CTX_VALID(ctx); + h = duk_require_hstring(ctx, index); DUK_ASSERT(h != NULL); @@ -18857,7 +23189,7 @@ DUK_EXTERNAL void duk_get_var(duk_context *ctx) { duk_hstring *h_varname; duk_small_int_t throw_flag = 1; /* always throw ReferenceError for unresolvable */ - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); h_varname = duk_require_hstring(ctx, -1); /* XXX: tostring? */ DUK_ASSERT(h_varname != NULL); @@ -18891,7 +23223,7 @@ DUK_EXTERNAL void duk_put_var(duk_context *ctx) { duk_tval *tv_val; duk_small_int_t throw_flag; - DUK_ASSERT(ctx != NULL); + DUK_ASSERT_CTX_VALID(ctx); h_varname = duk_require_hstring(ctx, -2); /* XXX: tostring? */ DUK_ASSERT(h_varname != NULL); @@ -18919,11 +23251,15 @@ DUK_EXTERNAL void duk_put_var(duk_context *ctx) { } DUK_EXTERNAL duk_bool_t duk_del_var(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); + DUK_ERROR((duk_hthread *) ctx, DUK_ERR_UNIMPLEMENTED_ERROR, DUK_STR_UNIMPLEMENTED); return 0; } DUK_EXTERNAL duk_bool_t duk_has_var(duk_context *ctx) { + DUK_ASSERT_CTX_VALID(ctx); + DUK_ERROR((duk_hthread *) ctx, DUK_ERR_UNIMPLEMENTED_ERROR, DUK_STR_UNIMPLEMENTED); return 0; } @@ -20157,9 +24493,7 @@ DUK_INTERNAL duk_ret_t duk_bi_array_prototype_iter_shared(duk_context *ctx) { DUK_ASSERT_TOP(ctx, 2); len = duk__push_this_obj_len_u32(ctx); - if (!duk_is_callable(ctx, 0)) { - goto type_error; - } + duk_require_callable(ctx, 0); /* if thisArg not supplied, behave as if undefined was supplied */ if (iter_type == DUK__ITER_MAP || iter_type == DUK__ITER_FILTER) { @@ -20274,9 +24608,6 @@ DUK_INTERNAL duk_ret_t duk_bi_array_prototype_iter_shared(duk_context *ctx) { } return 1; - - type_error: - return DUK_RET_TYPE_ERROR; } /* @@ -20370,6 +24701,14 @@ DUK_INTERNAL duk_ret_t duk_bi_array_prototype_reduce_shared(duk_context *ctx) { type_error: return DUK_RET_TYPE_ERROR; } + +#undef DUK__ARRAY_MID_JOIN_LIMIT + +#undef DUK__ITER_EVERY +#undef DUK__ITER_SOME +#undef DUK__ITER_FOREACH +#undef DUK__ITER_MAP +#undef DUK__ITER_FILTER #line 1 "duk_bi_boolean.c" /* * Boolean built-ins @@ -20441,21 +24780,501 @@ DUK_INTERNAL duk_ret_t duk_bi_boolean_constructor(duk_context *ctx) { } #line 1 "duk_bi_buffer.c" /* - * Buffer built-ins + * Duktape.Buffer, Node.js Buffer, and Khronos/ES6 TypedArray built-ins */ /* include removed: duk_internal.h */ /* - * Constructor + * Misc helpers + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Map DUK_HBUFFEROBJECT_ELEM_xxx to duk_hobject class number. + * Sync with duk_hbufferobject.h and duk_hobject.h. + */ +static const duk_uint8_t duk__buffer_class_from_elemtype[9] = { + DUK_HOBJECT_CLASS_UINT8ARRAY, + DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY, + DUK_HOBJECT_CLASS_INT8ARRAY, + DUK_HOBJECT_CLASS_UINT16ARRAY, + DUK_HOBJECT_CLASS_INT16ARRAY, + DUK_HOBJECT_CLASS_UINT32ARRAY, + DUK_HOBJECT_CLASS_INT32ARRAY, + DUK_HOBJECT_CLASS_FLOAT32ARRAY, + DUK_HOBJECT_CLASS_FLOAT64ARRAY +}; +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Map DUK_HBUFFEROBJECT_ELEM_xxx to prototype object built-in index. + * Sync with duk_hbufferobject.h. + */ +static const duk_uint8_t duk__buffer_proto_from_elemtype[9] = { + DUK_BIDX_UINT8ARRAY_PROTOTYPE, + DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE, + DUK_BIDX_INT8ARRAY_PROTOTYPE, + DUK_BIDX_UINT16ARRAY_PROTOTYPE, + DUK_BIDX_INT16ARRAY_PROTOTYPE, + DUK_BIDX_UINT32ARRAY_PROTOTYPE, + DUK_BIDX_INT32ARRAY_PROTOTYPE, + DUK_BIDX_FLOAT32ARRAY_PROTOTYPE, + DUK_BIDX_FLOAT64ARRAY_PROTOTYPE +}; +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Map DUK__FLX_xxx to byte size. + */ +static const duk_uint8_t duk__buffer_nbytes_from_fldtype[6] = { + 1, /* DUK__FLD_8BIT */ + 2, /* DUK__FLD_16BIT */ + 4, /* DUK__FLD_32BIT */ + 4, /* DUK__FLD_FLOAT */ + 8, /* DUK__FLD_DOUBLE */ + 0 /* DUK__FLD_VARINT; not relevant here */ +}; +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Bitfield for each DUK_HBUFFEROBJECT_ELEM_xxx indicating which element types + * are compatible with a blind byte copy for the TypedArray set() method (also + * used for TypedArray constructor). Array index is target buffer elem type, + * bitfield indicates compatible source types. The types must have same byte + * size and they must be coercion compatible. + */ +static duk_uint16_t duk__buffer_elemtype_copy_compatible[9] = { + /* xxx -> DUK_HBUFFEROBJECT_ELEM_UINT8 */ + (1U << DUK_HBUFFEROBJECT_ELEM_UINT8) | + (1U << DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED) | + (1U << DUK_HBUFFEROBJECT_ELEM_INT8), + + /* xxx -> DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED + * Note: INT8 is -not- copy compatible, e.g. -1 would coerce to 0x00. + */ + (1U << DUK_HBUFFEROBJECT_ELEM_UINT8) | + (1U << DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED), + + /* xxx -> DUK_HBUFFEROBJECT_ELEM_INT8 */ + (1U << DUK_HBUFFEROBJECT_ELEM_UINT8) | + (1U << DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED) | + (1U << DUK_HBUFFEROBJECT_ELEM_INT8), + + /* xxx -> DUK_HBUFFEROBJECT_ELEM_UINT16 */ + (1U << DUK_HBUFFEROBJECT_ELEM_UINT16) | + (1U << DUK_HBUFFEROBJECT_ELEM_INT16), + + /* xxx -> DUK_HBUFFEROBJECT_ELEM_INT16 */ + (1U << DUK_HBUFFEROBJECT_ELEM_UINT16) | + (1U << DUK_HBUFFEROBJECT_ELEM_INT16), + + /* xxx -> DUK_HBUFFEROBJECT_ELEM_UINT32 */ + (1U << DUK_HBUFFEROBJECT_ELEM_UINT32) | + (1U << DUK_HBUFFEROBJECT_ELEM_INT32), + + /* xxx -> DUK_HBUFFEROBJECT_ELEM_INT32 */ + (1U << DUK_HBUFFEROBJECT_ELEM_UINT32) | + (1U << DUK_HBUFFEROBJECT_ELEM_INT32), + + /* xxx -> DUK_HBUFFEROBJECT_ELEM_FLOAT32 */ + (1U << DUK_HBUFFEROBJECT_ELEM_FLOAT32), + + /* xxx -> DUK_HBUFFEROBJECT_ELEM_FLOAT64 */ + (1U << DUK_HBUFFEROBJECT_ELEM_FLOAT64) +}; +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Shared helper. */ +DUK_LOCAL duk_hbufferobject *duk__getrequire_bufobj_this(duk_context *ctx, duk_bool_t throw_flag) { + duk_hthread *thr; + duk_tval *tv; + duk_hbufferobject *h_this; + + DUK_ASSERT(ctx != NULL); + thr = (duk_hthread *) ctx; + + tv = duk_get_borrowed_this_tval(ctx); + DUK_ASSERT(tv != NULL); + if (DUK_TVAL_IS_OBJECT(tv)) { + h_this = (duk_hbufferobject *) DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h_this != NULL); + if (DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) h_this)) { + DUK_ASSERT_HBUFFEROBJECT_VALID(h_this); + return h_this; + } + } + + if (throw_flag) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_BUFFER); + } + return NULL; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Check that 'this' is a duk_hbufferobject and return a pointer to it. */ +DUK_LOCAL duk_hbufferobject *duk__get_bufobj_this(duk_context *ctx) { + return duk__getrequire_bufobj_this(ctx, 0); +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Check that 'this' is a duk_hbufferobject and return a pointer to it + * (NULL if not). + */ +DUK_LOCAL duk_hbufferobject *duk__require_bufobj_this(duk_context *ctx) { + return duk__getrequire_bufobj_this(ctx, 1); +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Check that value is a duk_hbufferobject and return a pointer to it. */ +DUK_LOCAL duk_hbufferobject *duk__require_bufobj_value(duk_context *ctx, duk_idx_t index) { + duk_hthread *thr; + duk_tval *tv; + duk_hbufferobject *h_obj; + + thr = (duk_hthread *) ctx; + + /* Don't accept relative indices now. */ + DUK_ASSERT(index >= 0); + + tv = duk_require_tval(ctx, index); + DUK_ASSERT(tv != NULL); + if (DUK_TVAL_IS_OBJECT(tv)) { + h_obj = (duk_hbufferobject *) DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h_obj != NULL); + if (DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) h_obj)) { + DUK_ASSERT_HBUFFEROBJECT_VALID(h_obj); + return h_obj; + } + } + + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_BUFFER); + return NULL; /* not reachable */ +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +DUK_LOCAL void duk__set_bufobj_buffer(duk_context *ctx, duk_hbufferobject *h_bufobj, duk_hbuffer *h_val) { + duk_hthread *thr; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(h_bufobj != NULL); + DUK_ASSERT(h_bufobj->buf == NULL); /* no need to decref */ + DUK_ASSERT(h_val != NULL); + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + h_bufobj->buf = h_val; + DUK_HBUFFER_INCREF(thr, h_val); + h_bufobj->length = (duk_uint_t) DUK_HBUFFER_GET_SIZE(h_val); + DUK_ASSERT(h_bufobj->shift == 0); + DUK_ASSERT(h_bufobj->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8); + + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); +} + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_LOCAL duk_hbufferobject *duk__push_arraybuffer_with_length(duk_context *ctx, duk_uint_t len) { + duk_hbuffer *h_val; + duk_hbufferobject *h_bufobj; + + (void) duk_push_fixed_buffer(ctx, (duk_size_t) len); + h_val = (duk_hbuffer *) duk_get_hbuffer(ctx, -1); + DUK_ASSERT(h_val != NULL); + + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ARRAYBUFFER), + DUK_BIDX_ARRAYBUFFER_PROTOTYPE); + DUK_ASSERT(h_bufobj != NULL); + + duk__set_bufobj_buffer(ctx, h_bufobj, h_val); + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + return h_bufobj; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Shared offset/length coercion helper. */ +DUK_LOCAL void duk__resolve_offset_opt_length(duk_context *ctx, + duk_hbufferobject *h_bufarg, + duk_idx_t idx_offset, + duk_idx_t idx_length, + duk_uint_t *out_offset, + duk_uint_t *out_length, + duk_bool_t throw_flag) { + duk_hthread *thr; + duk_int_t offset_signed; + duk_int_t length_signed; + duk_uint_t offset; + duk_uint_t length; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + offset_signed = duk_to_int(ctx, idx_offset); + if (offset_signed < 0) { + goto fail_range; + } + offset = (duk_uint_t) offset_signed; + if (offset > h_bufarg->length) { + goto fail_range; + } + DUK_ASSERT_DISABLE(offset >= 0); /* unsigned */ + DUK_ASSERT(offset <= h_bufarg->length); + + if (duk_is_undefined(ctx, idx_length)) { + DUK_ASSERT(h_bufarg->length >= offset); + length = h_bufarg->length - offset; /* >= 0 */ + } else { + length_signed = duk_to_int(ctx, idx_length); + if (length_signed < 0) { + goto fail_range; + } + length = (duk_uint_t) length_signed; + DUK_ASSERT(h_bufarg->length >= offset); + if (length > h_bufarg->length - offset) { + /* Unlike for negative arguments, some call sites + * want length to be clamped if it's positive. + */ + if (throw_flag) { + goto fail_range; + } else { + length = h_bufarg->length - offset; + } + } + } + DUK_ASSERT_DISABLE(length >= 0); /* unsigned */ + DUK_ASSERT(offset + length <= h_bufarg->length); + + *out_offset = offset; + *out_length = length; + return; + + fail_range: + duk_error(thr, DUK_ERR_RANGE_ERROR, DUK_STR_INVALID_CALL_ARGS); +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Shared lenient buffer length clamping helper. No negative indices, no + * element/byte shifting. + */ +DUK_LOCAL void duk__clamp_startend_nonegidx_noshift(duk_context *ctx, + duk_hbufferobject *h_bufobj, + duk_idx_t idx_start, + duk_idx_t idx_end, + duk_int_t *out_start_offset, + duk_int_t *out_end_offset) { + duk_int_t buffer_length; + duk_int_t start_offset; + duk_int_t end_offset; + + DUK_ASSERT(out_start_offset != NULL); + DUK_ASSERT(out_end_offset != NULL); + + buffer_length = (duk_int_t) h_bufobj->length; + + /* undefined coerces to zero which is correct */ + start_offset = duk_to_int_clamped(ctx, idx_start, 0, buffer_length); + if (duk_is_undefined(ctx, idx_end)) { + end_offset = buffer_length; + } else { + end_offset = duk_to_int_clamped(ctx, idx_end, start_offset, buffer_length); + } + + DUK_ASSERT(start_offset >= 0); + DUK_ASSERT(start_offset <= buffer_length); + DUK_ASSERT(end_offset >= 0); + DUK_ASSERT(end_offset <= buffer_length); + DUK_ASSERT(start_offset <= end_offset); + + *out_start_offset = start_offset; + *out_end_offset = end_offset; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Shared lenient buffer length clamping helper. Indices are treated as + * element indices (though output values are byte offsets) which only + * really matters for TypedArray views as other buffer object have a zero + * shift. Negative indices are counted from end of input slice; crossed + * indices are clamped to zero length; and final indices are clamped + * against input slice. Used for e.g. ArrayBuffer slice(). + */ +DUK_LOCAL void duk__clamp_startend_negidx_shifted(duk_context *ctx, + duk_hbufferobject *h_bufobj, + duk_idx_t idx_start, + duk_idx_t idx_end, + duk_int_t *out_start_offset, + duk_int_t *out_end_offset) { + duk_int_t buffer_length; + duk_int_t start_offset; + duk_int_t end_offset; + + DUK_ASSERT(out_start_offset != NULL); + DUK_ASSERT(out_end_offset != NULL); + + buffer_length = (duk_int_t) h_bufobj->length; + buffer_length >>= h_bufobj->shift; /* as elements */ + + /* Resolve start/end offset as element indices first; arguments + * at idx_start/idx_end are element offsets. Working with element + * indices first also avoids potential for wrapping. + */ + + start_offset = duk_to_int(ctx, idx_start); + if (start_offset < 0) { + start_offset = buffer_length + start_offset; + } + if (duk_is_undefined(ctx, idx_end)) { + end_offset = buffer_length; + } else { + end_offset = duk_to_int(ctx, idx_end); + if (end_offset < 0) { + end_offset = buffer_length + end_offset; + } + } + /* Note: start_offset/end_offset can still be < 0 here. */ + + if (start_offset < 0) { + start_offset = 0; + } else if (start_offset > buffer_length) { + start_offset = buffer_length; + } + if (end_offset < start_offset) { + end_offset = start_offset; + } else if (end_offset > buffer_length) { + end_offset = buffer_length; + } + DUK_ASSERT(start_offset >= 0); + DUK_ASSERT(start_offset <= buffer_length); + DUK_ASSERT(end_offset >= 0); + DUK_ASSERT(end_offset <= buffer_length); + DUK_ASSERT(start_offset <= end_offset); + + /* Convert indices to byte offsets. */ + start_offset <<= h_bufobj->shift; + end_offset <<= h_bufobj->shift; + + *out_start_offset = start_offset; + *out_end_offset = end_offset; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Indexed read/write helpers (also used from outside this file) + */ + +DUK_INTERNAL void duk_hbufferobject_push_validated_read(duk_context *ctx, duk_hbufferobject *h_bufobj, duk_uint8_t *p, duk_small_uint_t elem_size) { + duk_double_union du; + + DUK_MEMCPY((void *) du.uc, (const void *) p, (size_t) elem_size); + + switch (h_bufobj->elem_type) { + case DUK_HBUFFEROBJECT_ELEM_UINT8: +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) + case DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED: +#endif + duk_push_uint(ctx, (duk_uint_t) du.uc[0]); + break; +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) + /* These are not needed when only Duktape.Buffer is supported. */ + case DUK_HBUFFEROBJECT_ELEM_INT8: + duk_push_int(ctx, (duk_int_t) (duk_int8_t) du.uc[0]); + break; + case DUK_HBUFFEROBJECT_ELEM_UINT16: + duk_push_uint(ctx, (duk_uint_t) du.us[0]); + break; + case DUK_HBUFFEROBJECT_ELEM_INT16: + duk_push_int(ctx, (duk_int_t) (duk_int16_t) du.us[0]); + break; + case DUK_HBUFFEROBJECT_ELEM_UINT32: + duk_push_uint(ctx, (duk_uint_t) du.ui[0]); + break; + case DUK_HBUFFEROBJECT_ELEM_INT32: + duk_push_int(ctx, (duk_int_t) (duk_int32_t) du.ui[0]); + break; + case DUK_HBUFFEROBJECT_ELEM_FLOAT32: + duk_push_number(ctx, (duk_double_t) du.f[0]); + break; + case DUK_HBUFFEROBJECT_ELEM_FLOAT64: + duk_push_number(ctx, (duk_double_t) du.d); + break; +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + default: + DUK_UNREACHABLE(); + } +} + +DUK_INTERNAL void duk_hbufferobject_validated_write(duk_context *ctx, duk_hbufferobject *h_bufobj, duk_uint8_t *p, duk_small_uint_t elem_size) { + duk_double_union du; + + /* NOTE! Caller must ensure that any side effects from the + * coercions below are safe. If that cannot be guaranteed + * (which is normally the case), caller must coerce the + * argument using duk_to_number() before any pointer + * validations; the result of duk_to_number() always coerces + * without side effects here. + */ + + switch (h_bufobj->elem_type) { + case DUK_HBUFFEROBJECT_ELEM_UINT8: + du.uc[0] = (duk_uint8_t) duk_to_uint32(ctx, -1); + break; +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) + /* These are not needed when only Duktape.Buffer is supported. */ + case DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED: + du.uc[0] = (duk_uint8_t) duk_to_uint8clamped(ctx, -1); + break; + case DUK_HBUFFEROBJECT_ELEM_INT8: + du.uc[0] = (duk_uint8_t) duk_to_int32(ctx, -1); + break; + case DUK_HBUFFEROBJECT_ELEM_UINT16: + du.us[0] = (duk_uint16_t) duk_to_uint32(ctx, -1); + break; + case DUK_HBUFFEROBJECT_ELEM_INT16: + du.us[0] = (duk_uint16_t) duk_to_int32(ctx, -1); + break; + case DUK_HBUFFEROBJECT_ELEM_UINT32: + du.ui[0] = (duk_uint32_t) duk_to_uint32(ctx, -1); + break; + case DUK_HBUFFEROBJECT_ELEM_INT32: + du.ui[0] = (duk_uint32_t) duk_to_int32(ctx, -1); + break; + case DUK_HBUFFEROBJECT_ELEM_FLOAT32: + du.f[0] = (duk_float_t) duk_to_number(ctx, -1); + break; + case DUK_HBUFFEROBJECT_ELEM_FLOAT64: + du.d = (duk_double_t) duk_to_number(ctx, -1); + break; +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + default: + DUK_UNREACHABLE(); + } + + DUK_MEMCPY((void *) p, (const void *) du.uc, (size_t) elem_size); +} + +/* + * Duktape.Buffer: constructor */ DUK_INTERNAL duk_ret_t duk_bi_buffer_constructor(duk_context *ctx) { + duk_hthread *thr; duk_size_t buf_size; duk_small_int_t buf_dynamic; duk_uint8_t *buf_data; const duk_uint8_t *src_data; - duk_hobject *h_obj; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); /* * Constructor arguments are currently somewhat compatible with @@ -20470,54 +25289,75 @@ DUK_INTERNAL duk_ret_t duk_bi_buffer_constructor(duk_context *ctx) { buf_dynamic = duk_get_boolean(ctx, 1); /* default to false */ switch (duk_get_type(ctx, 0)) { - case DUK_TYPE_NUMBER: + case DUK_TYPE_NUMBER: { /* new buffer of specified size */ buf_size = (duk_size_t) duk_to_int(ctx, 0); (void) duk_push_buffer(ctx, buf_size, buf_dynamic); break; - case DUK_TYPE_BUFFER: - /* return input buffer, converted to a Buffer object if called as a - * constructor (no change if called as a function). + } + case DUK_TYPE_BUFFER: { + /* return input buffer, converted to a Duktape.Buffer object + * if called as a constructor (no change if called as a + * function). */ duk_set_top(ctx, 1); break; - case DUK_TYPE_STRING: + } + case DUK_TYPE_STRING: { /* new buffer with string contents */ src_data = (const duk_uint8_t *) duk_get_lstring(ctx, 0, &buf_size); DUK_ASSERT(src_data != NULL); /* even for zero-length string */ buf_data = (duk_uint8_t *) duk_push_buffer(ctx, buf_size, buf_dynamic); DUK_MEMCPY((void *) buf_data, (const void *) src_data, (size_t) buf_size); break; - case DUK_TYPE_OBJECT: - /* Buffer object: get the plain buffer inside. If called as as - * constructor, a new Buffer object pointing to the same plain - * buffer is created below. + } + case DUK_TYPE_OBJECT: { + /* For all duk_hbufferobjects, get the plain buffer inside + * without making a copy. This is compatible with Duktape 1.2 + * but means that a slice/view information is ignored and the + * full underlying buffer is returned. + * + * If called as a constructor, a new Duktape.Buffer object + * pointing to the same plain buffer is created below. */ - h_obj = duk_get_hobject(ctx, 0); - DUK_ASSERT(h_obj != NULL); - if (DUK_HOBJECT_GET_CLASS_NUMBER(h_obj) != DUK_HOBJECT_CLASS_BUFFER) { + duk_hbufferobject *h_bufobj; + h_bufobj = (duk_hbufferobject *) duk_get_hobject(ctx, 0); + DUK_ASSERT(h_bufobj != NULL); + if (!DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) h_bufobj)) { return DUK_RET_TYPE_ERROR; } - duk_get_prop_stridx(ctx, 0, DUK_STRIDX_INT_VALUE); - DUK_ASSERT(duk_is_buffer(ctx, -1)); + if (h_bufobj->buf == NULL) { + return DUK_RET_TYPE_ERROR; + } + duk_push_hbuffer(ctx, h_bufobj->buf); break; + } case DUK_TYPE_NONE: - default: + default: { return DUK_RET_TYPE_ERROR; } + } + DUK_ASSERT(duk_is_buffer(ctx, -1)); /* stack is unbalanced, but: [ buf ] */ if (duk_is_constructor_call(ctx)) { - duk_push_object_helper(ctx, - DUK_HOBJECT_FLAG_EXTENSIBLE | - DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ | - DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BUFFER), - DUK_BIDX_BUFFER_PROTOTYPE); + duk_hbufferobject *h_bufobj; + duk_hbuffer *h_val; - /* Buffer object internal value is immutable */ - duk_dup(ctx, -2); - duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_NONE); + h_val = duk_get_hbuffer(ctx, -1); + DUK_ASSERT(h_val != NULL); + + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BUFFER), + DUK_BIDX_BUFFER_PROTOTYPE); + DUK_ASSERT(h_bufobj != NULL); + + duk__set_bufobj_buffer(ctx, h_bufobj, h_val); + + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); } /* Note: unbalanced stack on purpose */ @@ -20525,29 +25365,705 @@ DUK_INTERNAL duk_ret_t duk_bi_buffer_constructor(duk_context *ctx) { } /* - * toString(), valueOf() + * Node.js Buffer: constructor */ +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_constructor(duk_context *ctx) { + /* Internal class is Object: Object.prototype.toString.call(new Buffer(0)) + * prints "[object Object]". + */ + duk_int_t len; + duk_int_t i; + duk_uint8_t *buf; + duk_hbuffer *h_buf; + duk_hbufferobject *h_bufobj; + duk_size_t buf_size; + + switch (duk_get_type(ctx, 0)) { + case DUK_TYPE_BUFFER: { + /* Custom behavior: plain buffer is used as internal buffer + * without making a copy (matches Duktape.Buffer). + */ + duk_set_top(ctx, 1); /* -> [ buffer ] */ + break; + } + case DUK_TYPE_NUMBER: { + len = duk_to_int_clamped(ctx, 0, 0, DUK_INT_MAX); + buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, (duk_size_t) len); + break; + } + case DUK_TYPE_OBJECT: { + (void) duk_get_prop_string(ctx, 0, "length"); + len = duk_to_int_clamped(ctx, -1, 0, DUK_INT_MAX); + duk_pop(ctx); + buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, (duk_size_t) len); + for (i = 0; i < len; i++) { + /* XXX: fast path for array arguments? */ + duk_get_prop_index(ctx, 0, (duk_uarridx_t) i); + buf[i] = (duk_uint8_t) (duk_to_uint32(ctx, -1) & 0xffU); + duk_pop(ctx); + } + break; + } + case DUK_TYPE_STRING: { + /* ignore encoding for now */ + duk_dup(ctx, 0); + buf = (duk_uint8_t *) duk_to_buffer(ctx, -1, &buf_size); + break; + } + default: + return DUK_RET_TYPE_ERROR; + } + + DUK_ASSERT(duk_is_buffer(ctx, -1)); + h_buf = duk_get_hbuffer(ctx, -1); + DUK_ASSERT(h_buf != NULL); + + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BUFFER), + DUK_BIDX_NODEJS_BUFFER_PROTOTYPE); + DUK_ASSERT(h_bufobj != NULL); + + h_bufobj->buf = h_buf; + DUK_HBUFFER_INCREF(thr, h_buf); + DUK_ASSERT(h_bufobj->offset == 0); + h_bufobj->length = (duk_int_t) DUK_HBUFFER_GET_SIZE(h_buf); + DUK_ASSERT(h_bufobj->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8); + + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_constructor(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * ArrayBuffer, DataView, and TypedArray constructors + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_arraybuffer_constructor(duk_context *ctx) { + duk_hthread *thr; + duk_hbufferobject *h_bufobj; + duk_hbuffer *h_val; + + DUK_ASSERT_CTX_VALID(ctx); + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + /* XXX: function flag to make this automatic? */ + if (!duk_is_constructor_call(ctx)) { + return DUK_RET_TYPE_ERROR; + } + + if (duk_is_buffer(ctx, 0)) { + /* Custom behavior: plain buffer is used as internal buffer + * without making a copy (matches Duktape.Buffer). + */ + + h_val = duk_get_hbuffer(ctx, 0); + DUK_ASSERT(h_val != NULL); + + /* XXX: accept any duk_hbufferobject type as an input also? */ + } else { + duk_int_t len; + len = duk_to_int(ctx, 0); + if (len < 0) { + goto fail_length; + } + (void) duk_push_fixed_buffer(ctx, (duk_size_t) len); + h_val = (duk_hbuffer *) duk_get_hbuffer(ctx, -1); + DUK_ASSERT(h_val != NULL); + +#if !defined(DUK_USE_ZERO_BUFFER_DATA) + /* Khronos/ES6 requires zeroing even when DUK_USE_ZERO_BUFFER_DATA + * is not set. + */ + DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC((duk_hbuffer *) h_val)); + DUK_MEMZERO((void *) DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, h_val), (duk_size_t) len); +#endif + } + + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ARRAYBUFFER), + DUK_BIDX_ARRAYBUFFER_PROTOTYPE); + DUK_ASSERT(h_bufobj != NULL); + + duk__set_bufobj_buffer(ctx, h_bufobj, h_val); + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + return 1; + + fail_length: + return DUK_RET_RANGE_ERROR; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_arraybuffer_constructor(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + + +/* Format of magic, bits: + * 0...1: elem size shift (0-3) + * 2...5: elem type (DUK_HBUFFEROBJECT_ELEM_xxx) + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_typedarray_constructor(duk_context *ctx) { + duk_hthread *thr; + duk_tval *tv; + duk_hobject *h_obj; + duk_hbufferobject *h_bufobj = NULL; + duk_hbufferobject *h_bufarr = NULL; + duk_hbufferobject *h_bufarg = NULL; + duk_hbuffer *h_val; + duk_small_uint_t magic; + duk_small_uint_t shift; + duk_small_uint_t elem_type; + duk_small_uint_t elem_size; + duk_small_uint_t class_num; + duk_small_uint_t proto_bidx; + duk_uint_t align_mask; + duk_uint_t elem_length; + duk_int_t elem_length_signed; + duk_uint_t byte_length; + duk_small_uint_t copy_mode; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + /* XXX: function flag to make this automatic? */ + if (!duk_is_constructor_call(ctx)) { + return DUK_RET_TYPE_ERROR; + } + + /* We could fit built-in index into magic but that'd make the magic + * number dependent on built-in numbering (genbuiltins.py doesn't + * handle that yet). So map both class and prototype from the + * element type. + */ + magic = duk_get_current_magic(ctx); + shift = magic & 0x03; /* bits 0...1: shift */ + elem_type = (magic >> 2) & 0x0f; /* bits 2...5: type */ + elem_size = 1 << shift; + align_mask = elem_size - 1; + DUK_ASSERT(elem_type < sizeof(duk__buffer_proto_from_elemtype) / sizeof(duk_uint8_t)); + proto_bidx = duk__buffer_proto_from_elemtype[elem_type]; + DUK_ASSERT(proto_bidx < DUK_NUM_BUILTINS); + DUK_ASSERT(elem_type < sizeof(duk__buffer_class_from_elemtype) / sizeof(duk_uint8_t)); + class_num = duk__buffer_class_from_elemtype[elem_type]; + + DUK_DD(DUK_DDPRINT("typedarray constructor, magic=%d, shift=%d, elem_type=%d, " + "elem_size=%d, proto_bidx=%d, class_num=%d", + (int) magic, (int) shift, (int) elem_type, (int) elem_size, + (int) proto_bidx, (int) class_num)); + + /* Argument variants. When the argument is an ArrayBuffer a view to + * the same buffer is created; otherwise a new ArrayBuffer is always + * created. + */ + + tv = duk_get_tval(ctx, 0); + DUK_ASSERT(tv != NULL); /* arg count */ + if (DUK_TVAL_IS_OBJECT(tv)) { + h_obj = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h_obj != NULL); + + if (DUK_HOBJECT_GET_CLASS_NUMBER(h_obj) == DUK_HOBJECT_CLASS_ARRAYBUFFER) { + /* ArrayBuffer: unlike any other argument variant, create + * a view into the existing buffer. + */ + + duk_int_t byte_offset_signed; + duk_uint_t byte_offset; + + h_bufarg = (duk_hbufferobject *) h_obj; + + byte_offset_signed = duk_to_int(ctx, 1); + if (byte_offset_signed < 0) { + goto fail_arguments; + } + byte_offset = (duk_uint_t) byte_offset_signed; + if (byte_offset > h_bufarg->length || + (byte_offset & align_mask) != 0) { + /* Must be >= 0 and multiple of element size. */ + goto fail_arguments; + } + if (duk_is_undefined(ctx, 2)) { + DUK_ASSERT(h_bufarg->length >= byte_offset); + byte_length = h_bufarg->length - byte_offset; + if ((byte_length & align_mask) != 0) { + /* Must be element size multiple from + * start offset to end of buffer. + */ + goto fail_arguments; + } + elem_length = (byte_length >> shift); + } else { + elem_length_signed = duk_to_int(ctx, 2); + if (elem_length_signed < 0) { + goto fail_arguments; + } + elem_length = (duk_uint_t) elem_length_signed; + byte_length = elem_length << shift; + if ((byte_length >> shift) != elem_length) { + /* Byte length would overflow. */ + /* XXX: easier check with less code? */ + goto fail_arguments; + } + DUK_ASSERT(h_bufarg->length >= byte_offset); + if (byte_length > h_bufarg->length - byte_offset) { + /* Not enough data. */ + goto fail_arguments; + } + } + DUK_ASSERT_DISABLE(byte_offset >= 0); + DUK_ASSERT(byte_offset <= h_bufarg->length); + DUK_ASSERT_DISABLE(byte_length >= 0); + DUK_ASSERT(byte_offset + byte_length <= h_bufarg->length); + DUK_ASSERT((elem_length << shift) == byte_length); + + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(class_num), + proto_bidx); + h_val = h_bufarg->buf; + if (h_val == NULL) { + return DUK_RET_TYPE_ERROR; + } + h_bufobj->buf = h_val; + DUK_HBUFFER_INCREF(thr, h_val); + h_bufobj->offset = h_bufarg->offset + byte_offset; + h_bufobj->length = byte_length; + h_bufobj->shift = (duk_uint8_t) shift; + h_bufobj->elem_type = (duk_uint8_t) elem_type; + h_bufobj->is_view = 1; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + /* Set .buffer to the argument ArrayBuffer. */ + duk_dup(ctx, 0); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LC_BUFFER, DUK_PROPDESC_FLAGS_NONE); + duk_compact(ctx, -1); + return 1; + } else if (DUK_HOBJECT_IS_BUFFEROBJECT(h_obj)) { + /* TypedArray (or other non-ArrayBuffer duk_hbufferobject). + * Conceptually same behavior as for an Array-like argument, + * with a few fast paths. + */ + + h_bufarg = (duk_hbufferobject *) h_obj; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufarg); + elem_length_signed = (duk_int_t) (h_bufarg->length >> h_bufarg->shift); + if (h_bufarg->buf == NULL) { + return DUK_RET_TYPE_ERROR; + } + + /* Select copy mode. Must take into account element + * compatibility and validity of the underlying source + * buffer. + */ + + DUK_DDD(DUK_DDDPRINT("selecting copy mode for bufobj arg, " + "src byte_length=%ld, src shift=%d, " + "src/dst elem_length=%ld; " + "dst shift=%d -> dst byte_length=%ld", + (long) h_bufarg->length, (int) h_bufarg->shift, + (long) elem_length_signed, (int) shift, + (long) (elem_length_signed << shift))); + + copy_mode = 2; /* default is explicit index read/write copy */ + DUK_ASSERT(elem_type < sizeof(duk__buffer_elemtype_copy_compatible) / sizeof(duk_uint16_t)); + if (DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg)) { + if ((duk__buffer_elemtype_copy_compatible[elem_type] & (1 << h_bufarg->elem_type)) != 0) { + DUK_DDD(DUK_DDDPRINT("source/target are copy compatible, memcpy")); + DUK_ASSERT(shift == h_bufarg->shift); /* byte sizes will match */ + copy_mode = 0; + } else { + DUK_DDD(DUK_DDDPRINT("source/target not copy compatible but valid, fast copy")); + copy_mode = 1; + } + } + } else { + /* Array or Array-like */ + elem_length_signed = (duk_int_t) duk_get_length(ctx, 0); + copy_mode = 2; + } + } else if (DUK_TVAL_IS_BUFFER(tv)) { + /* Accept plain buffer values like array initializers + * (new in Duktape 1.4.0). + */ + duk_hbuffer *h_srcbuf; + h_srcbuf = DUK_TVAL_GET_BUFFER(tv); + elem_length_signed = (duk_int_t) DUK_HBUFFER_GET_SIZE(h_srcbuf); + copy_mode = 2; /* XXX: could add fast path for u8 compatible views */ + } else { + /* Non-object argument is simply int coerced, matches + * V8 behavior (except for "null", which we coerce to + * 0 but V8 TypeErrors). + */ + elem_length_signed = duk_to_int(ctx, 0); + copy_mode = 3; + } + if (elem_length_signed < 0) { + goto fail_arguments; + } + elem_length = (duk_uint_t) elem_length_signed; + byte_length = (duk_uint_t) (elem_length << shift); + if ((byte_length >> shift) != elem_length) { + /* Byte length would overflow. */ + /* XXX: easier check with less code? */ + goto fail_arguments; + } + + DUK_DDD(DUK_DDDPRINT("elem_length=%ld, byte_length=%ld", + (long) elem_length, (long) byte_length)); + + /* ArrayBuffer argument is handled specially above; the rest of the + * argument variants are handled by shared code below. + */ + + /* Push a new ArrayBuffer (becomes view .buffer) */ + h_bufarr = duk__push_arraybuffer_with_length(ctx, byte_length); + DUK_ASSERT(h_bufarr != NULL); + h_val = h_bufarr->buf; + DUK_ASSERT(h_val != NULL); + + /* Push the resulting view object and attach the ArrayBuffer. */ + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(class_num), + proto_bidx); + + h_bufobj->buf = h_val; + DUK_HBUFFER_INCREF(thr, h_val); + DUK_ASSERT(h_bufobj->offset == 0); + h_bufobj->length = byte_length; + h_bufobj->shift = (duk_uint8_t) shift; + h_bufobj->elem_type = (duk_uint8_t) elem_type; + h_bufobj->is_view = 1; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + /* Set .buffer */ + duk_dup(ctx, -2); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LC_BUFFER, DUK_PROPDESC_FLAGS_NONE); + duk_compact(ctx, -1); + + /* Copy values, the copy method depends on the arguments. + * + * Copy mode decision may depend on the validity of the underlying + * buffer of the source argument; there must be no harmful side effects + * from there to here for copy_mode to still be valid. + */ + DUK_DDD(DUK_DDDPRINT("copy mode: %d", (int) copy_mode)); + switch (copy_mode) { + case 0: { + /* Use byte copy. */ + + duk_uint8_t *p_src; + duk_uint8_t *p_dst; + + DUK_ASSERT(h_bufobj != NULL); + DUK_ASSERT(h_bufobj->buf != NULL); + DUK_ASSERT(DUK_HBUFFEROBJECT_VALID_SLICE(h_bufobj)); + DUK_ASSERT(h_bufarg != NULL); + DUK_ASSERT(h_bufarg->buf != NULL); + DUK_ASSERT(DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg)); + + p_dst = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufobj); + p_src = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufarg); + + DUK_DDD(DUK_DDDPRINT("using memcpy: p_src=%p, p_dst=%p, byte_length=%ld", + (void *) p_src, (void *) p_dst, (long) byte_length)); + + DUK_MEMCPY((void *) p_dst, (const void *) p_src, (size_t) byte_length); + break; + } + case 1: { + /* Copy values through direct validated reads and writes. */ + + duk_small_uint_t src_elem_size; + duk_small_uint_t dst_elem_size; + duk_uint8_t *p_src; + duk_uint8_t *p_src_end; + duk_uint8_t *p_dst; + + DUK_ASSERT(h_bufobj != NULL); + DUK_ASSERT(h_bufobj->buf != NULL); + DUK_ASSERT(DUK_HBUFFEROBJECT_VALID_SLICE(h_bufobj)); + DUK_ASSERT(h_bufarg != NULL); + DUK_ASSERT(h_bufarg->buf != NULL); + DUK_ASSERT(DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg)); + + src_elem_size = 1 << h_bufarg->shift; + dst_elem_size = elem_size; + + p_src = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufarg); + p_dst = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufobj); + p_src_end = p_src + h_bufarg->length; + + DUK_DDD(DUK_DDDPRINT("using fast copy: p_src=%p, p_src_end=%p, p_dst=%p, " + "src_elem_size=%d, dst_elem_size=%d", + (void *) p_src, (void *) p_src_end, (void *) p_dst, + (int) src_elem_size, (int) dst_elem_size)); + + while (p_src != p_src_end) { + DUK_DDD(DUK_DDDPRINT("fast path per element copy loop: " + "p_src=%p, p_src_end=%p, p_dst=%p", + (void *) p_src, (void *) p_src_end, (void *) p_dst)); + /* A validated read() is always a number, so it's write coercion + * is always side effect free an won't invalidate pointers etc. + */ + duk_hbufferobject_push_validated_read(ctx, h_bufarg, p_src, src_elem_size); + duk_hbufferobject_validated_write(ctx, h_bufobj, p_dst, dst_elem_size); + duk_pop(ctx); + p_src += src_elem_size; + p_dst += dst_elem_size; + } + break; + } + case 2: { + /* Copy values by index reads and writes. Let virtual + * property handling take care of coercion. + */ + duk_uint_t i; + + DUK_DDD(DUK_DDDPRINT("using slow copy")); + + for (i = 0; i < elem_length; i++) { + duk_get_prop_index(ctx, 0, (duk_uarridx_t) i); + duk_put_prop_index(ctx, -2, (duk_uarridx_t) i); + } + break; + } + default: + case 3: { + /* No copy, leave zero bytes in the buffer. There's no + * ambiguity with Float32/Float64 because zero bytes also + * represent 0.0. + */ +#if !defined(DUK_USE_ZERO_BUFFER_DATA) + /* Khronos/ES6 requires zeroing even when DUK_USE_ZERO_BUFFER_DATA + * is not set. + */ + DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC((duk_hbuffer *) h_val)); + DUK_MEMZERO((void *) DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, h_val), (duk_size_t) byte_length); +#endif + + DUK_DDD(DUK_DDDPRINT("using no copy")); + break; + } + } + + return 1; + + fail_arguments: + return DUK_RET_RANGE_ERROR; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_typedarray_constructor(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_dataview_constructor(duk_context *ctx) { + duk_hbufferobject *h_bufarg; + duk_hbufferobject *h_bufobj; + duk_hbuffer *h_val; + duk_uint_t offset; + duk_uint_t length; + + /* XXX: function flag to make this automatic? */ + if (!duk_is_constructor_call(ctx)) { + return DUK_RET_TYPE_ERROR; + } + + h_bufarg = duk__require_bufobj_value(ctx, 0); + DUK_ASSERT(h_bufarg != NULL); + + duk__resolve_offset_opt_length(ctx, h_bufarg, 1, 2, &offset, &length, 1 /*throw_flag*/); + DUK_ASSERT(offset <= h_bufarg->length); + DUK_ASSERT(offset + length <= h_bufarg->length); + + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DATAVIEW), + DUK_BIDX_DATAVIEW_PROTOTYPE); + + h_val = h_bufarg->buf; + if (h_val == NULL) { + return DUK_RET_TYPE_ERROR; + } + h_bufobj->buf = h_val; + DUK_HBUFFER_INCREF(thr, h_val); + h_bufobj->offset = h_bufarg->offset + offset; + h_bufobj->length = length; + DUK_ASSERT(h_bufobj->shift == 0); + DUK_ASSERT(h_bufobj->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8); + h_bufobj->is_view = 1; + + /* The DataView .buffer property is ordinarily set to the argument + * which is an ArrayBuffer. We accept any duk_hbufferobject as + * an argument and .buffer will be set to the argument regardless + * of what it is. This may be a bit confusing if the argument + * is e.g. a DataView or another TypedArray view. + * + * XXX: Copy .buffer property from a DataView/TypedArray argument? + * Create a fresh ArrayBuffer for Duktape.Buffer and Node.js Buffer + * arguments? See: test-bug-dataview-buffer-prop.js. + */ + + duk_dup(ctx, 0); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LC_BUFFER, DUK_PROPDESC_FLAGS_NONE); + duk_compact(ctx, -1); + + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_dataview_constructor(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * ArrayBuffer.isView() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_arraybuffer_isview(duk_context *ctx) { + duk_hobject *h_obj; + duk_bool_t ret = 0; + + h_obj = duk_get_hobject(ctx, 0); + if (h_obj != NULL && DUK_HOBJECT_IS_BUFFEROBJECT(h_obj)) { + ret = ((duk_hbufferobject *) h_obj)->is_view; + } + duk_push_boolean(ctx, ret); + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_arraybuffer_isview(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer: toString([encoding], [start], [end]) + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_tostring(duk_context *ctx) { + duk_hthread *thr; + duk_hbufferobject *h_this; + duk_int_t start_offset, end_offset; + duk_uint8_t *buf_slice; + duk_size_t slice_length; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + h_this = duk__get_bufobj_this(ctx); + if (h_this == NULL) { + /* XXX: happens e.g. when evaluating: String(Buffer.prototype). */ + duk_push_string(ctx, "[object Object]"); + return 1; + } + DUK_ASSERT_HBUFFEROBJECT_VALID(h_this); + + /* ignore encoding for now */ + + duk__clamp_startend_nonegidx_noshift(ctx, h_this, 1 /*idx_start*/, 2 /*idx_end*/, &start_offset, &end_offset); + + slice_length = (duk_size_t) (end_offset - start_offset); + buf_slice = (duk_uint8_t *) duk_push_fixed_buffer(ctx, slice_length); + DUK_ASSERT(buf_slice != NULL); + + if (h_this->buf == NULL) { + goto type_error; + } + + if (DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_this, start_offset + slice_length)) { + DUK_MEMCPY((void *) buf_slice, + (const void *) (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this) + start_offset), + (size_t) slice_length); + } else { + /* not covered, return all zeroes */ + ; + } + + duk_to_string(ctx, -1); + return 1; + + type_error: + return DUK_RET_TYPE_ERROR; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_tostring(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Duktape.Buffer: toString(), valueOf() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) DUK_INTERNAL duk_ret_t duk_bi_buffer_prototype_tostring_shared(duk_context *ctx) { + duk_hthread *thr; duk_tval *tv; duk_small_int_t to_string = duk_get_current_magic(ctx); - duk_push_this(ctx); - tv = duk_require_tval(ctx, -1); + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + tv = duk_get_borrowed_this_tval(ctx); DUK_ASSERT(tv != NULL); if (DUK_TVAL_IS_BUFFER(tv)) { - /* nop */ + duk_hbuffer *h_buf; + h_buf = DUK_TVAL_GET_BUFFER(tv); + DUK_ASSERT(h_buf != NULL); + duk_push_hbuffer(ctx, h_buf); } else if (DUK_TVAL_IS_OBJECT(tv)) { - duk_hobject *h = DUK_TVAL_GET_OBJECT(tv); - DUK_ASSERT(h != NULL); + duk_hobject *h; + duk_hbufferobject *h_bufobj; - /* Must be a "buffer object", i.e. class "Buffer" */ - if (DUK_HOBJECT_GET_CLASS_NUMBER(h) != DUK_HOBJECT_CLASS_BUFFER) { + /* Accept any duk_hbufferobject, though we're only normally + * called for Duktape.Buffer values. + */ + h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + if (!DUK_HOBJECT_IS_BUFFEROBJECT(h)) { + DUK_DD(DUK_DDPRINT("toString/valueOf() called for a non-bufferobject object")); goto type_error; } + h_bufobj = (duk_hbufferobject *) h; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); - duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE); + if (h_bufobj->buf == NULL) { + DUK_DD(DUK_DDPRINT("toString/valueOf() called for a bufferobject with NULL buf")); + goto type_error; + } + duk_push_hbuffer(ctx, h_bufobj->buf); } else { goto type_error; } @@ -20560,121 +26076,1608 @@ DUK_INTERNAL duk_ret_t duk_bi_buffer_prototype_tostring_shared(duk_context *ctx) type_error: return DUK_RET_TYPE_ERROR; } +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_buffer_prototype_tostring_shared(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.prototype: toJSON() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_tojson(duk_context *ctx) { + duk_hthread *thr; + duk_hbufferobject *h_this; + duk_uint8_t *buf; + duk_uint_t i; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + h_this = duk__require_bufobj_this(ctx); + DUK_ASSERT(h_this != NULL); + + if (h_this->buf == NULL || !DUK_HBUFFEROBJECT_VALID_SLICE(h_this)) { + /* Serialize uncovered backing buffer as a null; doesn't + * really matter as long we're memory safe. + */ + duk_push_null(ctx); + return 1; + } + + duk_push_object(ctx); + duk_push_hstring_stridx(ctx, DUK_STRIDX_UC_BUFFER); + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_TYPE); + + duk_push_array(ctx); + for (i = 0; i < h_this->length; i++) { + /* XXX: regetting the pointer may be overkill - we're writing + * to a side-effect free array here. + */ + DUK_ASSERT(h_this->buf != NULL); + buf = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this); + duk_push_uint(ctx, (duk_uint_t) buf[i]); + duk_put_prop_index(ctx, -2, (duk_idx_t) i); + } + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_DATA); + + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_tojson(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.prototype.equals() + * Node.js Buffer.prototype.compare() + * Node.js Buffer.compare() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_buffer_compare_shared(duk_context *ctx) { + duk_hthread *thr; + duk_small_uint_t magic; + duk_hbufferobject *h_bufarg1; + duk_hbufferobject *h_bufarg2; + duk_small_int_t comp_res; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + magic = duk_get_current_magic(ctx); + if (magic & 0x02) { + /* Static call style. */ + h_bufarg1 = duk__require_bufobj_value(ctx, 0); + h_bufarg2 = duk__require_bufobj_value(ctx, 1); + } else { + h_bufarg1 = duk__require_bufobj_this(ctx); + h_bufarg2 = duk__require_bufobj_value(ctx, 0); + } + DUK_ASSERT(h_bufarg1 != NULL); + DUK_ASSERT(h_bufarg2 != NULL); + + /* We want to compare the slice/view areas of the arguments. + * If either slice/view is invalid (underlying buffer is shorter) + * ensure equals() is false, but otherwise the only thing that + * matters is to be memory safe. + */ + + if (DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg1) && + DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg2)) { + comp_res = duk_js_data_compare((const duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufarg1->buf) + h_bufarg1->offset, + (const duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufarg2->buf) + h_bufarg2->offset, + (duk_size_t) h_bufarg1->length, + (duk_size_t) h_bufarg2->length); + } else { + comp_res = -1; /* either nonzero value is ok */ + } + + if (magic & 0x01) { + /* compare: similar to string comparison but for buffer data. */ + duk_push_int(ctx, comp_res); + } else { + /* equals */ + duk_push_boolean(ctx, (comp_res == 0)); + } + + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_buffer_compare_shared(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.prototype.fill() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_fill(duk_context *ctx) { + duk_hthread *thr; + duk_hbufferobject *h_this; + const duk_uint8_t *fill_str_ptr; + duk_size_t fill_str_len; + duk_uint8_t fill_value; + duk_int_t fill_offset; + duk_int_t fill_end; + duk_size_t fill_length; + duk_uint8_t *p; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + h_this = duk__require_bufobj_this(ctx); + DUK_ASSERT(h_this != NULL); + if (h_this->buf == NULL) { + return DUK_RET_TYPE_ERROR; + } + + /* [ value offset end ] */ + + if (duk_is_string(ctx, 0)) { + fill_str_ptr = (const duk_uint8_t *) duk_get_lstring(ctx, 0, &fill_str_len); + DUK_ASSERT(fill_str_ptr != NULL); + } else { + fill_value = (duk_uint8_t) duk_to_uint32(ctx, 0); + fill_str_ptr = (const duk_uint8_t *) &fill_value; + fill_str_len = 1; + } + + /* Fill offset handling is more lenient than in Node.js. */ + + duk__clamp_startend_nonegidx_noshift(ctx, h_this, 1 /*idx_start*/, 2 /*idx_end*/, &fill_offset, &fill_end); + + DUK_DDD(DUK_DDDPRINT("fill: fill_value=%02x, fill_offset=%ld, fill_end=%ld, view length=%ld", + (unsigned int) fill_value, (long) fill_offset, (long) fill_end, (long) h_this->length)); + + DUK_ASSERT(fill_end - fill_offset >= 0); + DUK_ASSERT(h_this->buf != NULL); + + p = (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this) + fill_offset); + fill_length = (duk_size_t) (fill_end - fill_offset); + if (fill_str_len == 1) { + /* Handle single character fills as memset() even when + * the fill data comes from a one-char argument. + */ + DUK_MEMSET((void *) p, (int) fill_str_ptr[0], (size_t) fill_length); + } else if (fill_str_len > 1) { + duk_size_t i, n, t; + + for (i = 0, n = (fill_end - fill_offset), t = 0; i < n; i++) { + p[i] = fill_str_ptr[t++]; + if (t >= fill_str_len) { + t = 0; + } + } + } else { + DUK_DDD(DUK_DDDPRINT("zero size fill pattern, ignore silently")); + } + + /* Return the Buffer to allow chaining: b.fill(0x11).fill(0x22, 3, 5).toString() */ + duk_push_this(ctx); + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_fill(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.prototype.write(string, [offset], [length], [encoding]) + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_write(duk_context *ctx) { + duk_hthread *thr; + duk_hbufferobject *h_this; + duk_uint_t offset; + duk_uint_t length; + const duk_uint8_t *str_data; + duk_size_t str_len; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + h_this = duk__require_bufobj_this(ctx); + DUK_ASSERT(h_this != NULL); + + /* Argument must be a string, e.g. a buffer is not allowed. */ + str_data = (const duk_uint8_t *) duk_require_lstring(ctx, 0, &str_len); + + duk__resolve_offset_opt_length(ctx, h_this, 1, 2, &offset, &length, 0 /*throw_flag*/); + DUK_ASSERT(offset <= h_this->length); + DUK_ASSERT(offset + length <= h_this->length); + + /* XXX: encoding is ignored now. */ + + if (length > str_len) { + length = (duk_uint_t) str_len; + } + + if (DUK_HBUFFEROBJECT_VALID_SLICE(h_this)) { + /* Cannot overlap. */ + DUK_MEMCPY((void *) (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this) + offset), + (const void *) str_data, + (size_t) length); + } else { + DUK_DDD(DUK_DDDPRINT("write() target buffer is not covered, silent ignore")); + } + + duk_push_uint(ctx, length); + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_write(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.prototype.copy() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_copy(duk_context *ctx) { + duk_hthread *thr; + duk_hbufferobject *h_this; + duk_hbufferobject *h_bufarg; + duk_int_t source_length; + duk_int_t target_length; + duk_int_t target_start, source_start, source_end; + duk_uint_t target_ustart, source_ustart, source_uend; + duk_uint_t copy_size = 0; + + /* [ targetBuffer targetStart sourceStart sourceEnd ] */ + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + h_this = duk__require_bufobj_this(ctx); + h_bufarg = duk__require_bufobj_value(ctx, 0); + DUK_ASSERT(h_this != NULL); + DUK_ASSERT(h_bufarg != NULL); + source_length = (duk_int_t) h_this->length; + target_length = (duk_int_t) h_bufarg->length; + + target_start = duk_to_int(ctx, 1); + source_start = duk_to_int(ctx, 2); + if (duk_is_undefined(ctx, 3)) { + source_end = source_length; + } else { + source_end = duk_to_int(ctx, 3); + } + + DUK_DDD(DUK_DDDPRINT("checking copy args: target_start=%ld, target_length=%ld, " + "source_start=%ld, source_end=%ld, source_length=%ld", + (long) target_start, (long) h_bufarg->length, + (long) source_start, (long) source_end, (long) source_length)); + + /* This behavior mostly mimics Node.js now. */ + + if (source_start < 0 || source_end < 0 || target_start < 0) { + /* Negative offsets cause a RangeError. */ + goto fail_bounds; + } + source_ustart = (duk_uint_t) source_start; + source_uend = (duk_uint_t) source_end; + target_ustart = (duk_uint_t) target_start; + if (source_ustart >= source_uend || /* crossed offsets or zero size */ + source_ustart >= (duk_uint_t) source_length || /* source out-of-bounds (but positive) */ + target_ustart >= (duk_uint_t) target_length) { /* target out-of-bounds (but positive) */ + goto silent_ignore; + } + if (source_uend >= (duk_uint_t) source_length) { + /* Source end clamped silently to available length. */ + source_uend = source_length; + } + copy_size = source_uend - source_ustart; + if (target_ustart + copy_size > (duk_uint_t) target_length) { + /* Clamp to target's end if too long. + * + * NOTE: there's no overflow possibility in the comparison; + * both target_ustart and copy_size are >= 0 and based on + * values in duk_int_t range. Adding them as duk_uint_t + * values is then guaranteed not to overflow. + */ + DUK_ASSERT(target_ustart + copy_size >= target_ustart); /* no overflow */ + DUK_ASSERT(target_ustart + copy_size >= copy_size); /* no overflow */ + copy_size = (duk_uint_t) target_length - target_ustart; + } + + DUK_DDD(DUK_DDDPRINT("making copy: target_ustart=%lu source_ustart=%lu copy_size=%lu", + (unsigned long) target_ustart, (unsigned long) source_ustart, + (unsigned long) copy_size)); + + DUK_ASSERT(copy_size >= 1); + DUK_ASSERT(source_ustart <= (duk_uint_t) source_length); + DUK_ASSERT(source_ustart + copy_size <= (duk_uint_t) source_length); + DUK_ASSERT(target_ustart <= (duk_uint_t) target_length); + DUK_ASSERT(target_ustart + copy_size <= (duk_uint_t) target_length); + + /* Ensure copy is covered by underlying buffers. */ + DUK_ASSERT(h_bufarg->buf != NULL); /* length check */ + DUK_ASSERT(h_this->buf != NULL); /* length check */ + if (DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_bufarg, target_ustart + copy_size) && + DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_this, source_ustart + copy_size)) { + /* Must use memmove() because copy area may overlap (source and target + * buffer may be the same, or from different slices. + */ + DUK_MEMMOVE((void *) (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufarg) + target_ustart), + (const void *) (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this) + source_ustart), + (size_t) copy_size); + } else { + DUK_DDD(DUK_DDDPRINT("buffer copy not covered by underlying buffer(s), ignoring")); + } + + silent_ignore: + /* Return value is like write(), number of bytes written. + * The return value matters because of code like: + * "off += buf.copy(...)". + */ + duk_push_uint(ctx, copy_size); + return 1; + + fail_bounds: + return DUK_RET_RANGE_ERROR; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_copy(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * TypedArray.prototype.set() + * + * TypedArray set() is pretty interesting to implement because: + * + * - The source argument may be a plain array or a typedarray. If the + * source is a TypedArray, values are decoded and re-encoded into the + * target (not as a plain byte copy). This may happen even when the + * element byte size is the same, e.g. integer values may be re-encoded + * into floats. + * + * - Source and target may refer to the same underlying buffer, so that + * the set() operation may overlap. The specification requires that this + * must work as if a copy was made before the operation. Note that this + * is NOT a simple memmove() situation because the source and target + * byte sizes may be different -- e.g. a 4-byte source (Int8Array) may + * expand to a 16-byte target (Uint32Array) so that the target overlaps + * the source both from beginning and the end (unlike in typical memmove). + * + * - Even if 'buf' pointers of the source and target differ, there's no + * guarantee that their memory areas don't overlap. This may be the + * case with external buffers. + * + * Even so, it is nice to optimize for the common case: + * + * - Source and target separate buffers or non-overlapping. + * + * - Source and target have a compatible type so that a plain byte copy + * is possible. Note that while e.g. uint8 and int8 are compatible + * (coercion one way or another doesn't change the byte representation), + * e.g. int8 and uint8clamped are NOT compatible when writing int8 + * values into uint8clamped typedarray (-1 would clamp to 0 for instance). + * + * See test-bi-typedarray-proto-set.js. + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_typedarray_set(duk_context *ctx) { + duk_hthread *thr; + duk_hbufferobject *h_this; + duk_hobject *h_obj; + duk_uarridx_t i, n; + duk_int_t offset_signed; + duk_uint_t offset_elems; + duk_uint_t offset_bytes; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + h_this = duk__require_bufobj_this(ctx); + DUK_ASSERT(h_this != NULL); + DUK_ASSERT_HBUFFEROBJECT_VALID(h_this); + + if (h_this->buf == NULL) { + DUK_DDD(DUK_DDDPRINT("source neutered, skip copy")); + return 0; + } + + h_obj = duk_require_hobject(ctx, 0); + DUK_ASSERT(h_obj != NULL); + + /* XXX: V8 throws a TypeError for negative values. Would it + * be more useful to interpret negative offsets here from the + * end of the buffer too? + */ + offset_signed = duk_to_int(ctx, 1); + if (offset_signed < 0) { + return DUK_RET_TYPE_ERROR; + } + offset_elems = (duk_uint_t) offset_signed; + offset_bytes = offset_elems << h_this->shift; + if ((offset_bytes >> h_this->shift) != offset_elems) { + /* Byte length would overflow. */ + /* XXX: easier check with less code? */ + return DUK_RET_RANGE_ERROR; + } + if (offset_bytes > h_this->length) { + /* Equality may be OK but >length not. Checking + * this explicitly avoids some overflow cases + * below. + */ + return DUK_RET_RANGE_ERROR; + } + DUK_ASSERT(offset_bytes <= h_this->length); + + /* Fast path: source is a TypedArray (or any bufferobject). */ + + if (DUK_HOBJECT_IS_BUFFEROBJECT(h_obj)) { + duk_hbufferobject *h_bufarg; + duk_uint16_t comp_mask; + duk_small_int_t no_overlap = 0; + duk_uint_t src_length; + duk_uint_t dst_length; + duk_uint_t dst_length_elems; + duk_uint8_t *p_src_base; + duk_uint8_t *p_src_end; + duk_uint8_t *p_src; + duk_uint8_t *p_dst_base; + duk_uint8_t *p_dst; + duk_small_uint_t src_elem_size; + duk_small_uint_t dst_elem_size; + + h_bufarg = (duk_hbufferobject *) h_obj; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufarg); + + if (h_bufarg->buf == NULL) { + DUK_DDD(DUK_DDDPRINT("target neutered, skip copy")); + return 0; + } + + /* Nominal size check. */ + src_length = h_bufarg->length; /* bytes in source */ + dst_length_elems = (src_length >> h_bufarg->shift); /* elems in source and dest */ + dst_length = dst_length_elems << h_this->shift; /* bytes in dest */ + if ((dst_length >> h_this->shift) != dst_length_elems) { + /* Byte length would overflow. */ + /* XXX: easier check with less code? */ + return DUK_RET_RANGE_ERROR; + } + DUK_DDD(DUK_DDDPRINT("nominal size check: src_length=%ld, dst_length=%ld", + (long) src_length, (long) dst_length)); + DUK_ASSERT(offset_bytes <= h_this->length); + if (dst_length > h_this->length - offset_bytes) { + /* Overflow not an issue because subtraction is used on the right + * side and guaranteed to be >= 0. + */ + DUK_DDD(DUK_DDDPRINT("copy exceeds target buffer nominal length")); + return DUK_RET_RANGE_ERROR; + } + if (!DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_this, offset_bytes + dst_length)) { + DUK_DDD(DUK_DDDPRINT("copy not covered by underlying target buffer, ignore")); + return 0; + } + + p_src_base = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufarg); + p_dst_base = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this) + offset_bytes; + + /* Check actual underlying buffers for validity and that they + * cover the copy. No side effects are allowed after the check + * so that the validity status doesn't change. + */ + if (!DUK_HBUFFEROBJECT_VALID_SLICE(h_this) || + !DUK_HBUFFEROBJECT_VALID_SLICE(h_bufarg)) { + /* The condition could be more narrow and check for the + * copy area only, but there's no need for fine grained + * behavior when the underlying buffer is misconfigured. + */ + DUK_DDD(DUK_DDDPRINT("source and/or target not covered by underlying buffer, skip copy")); + return 0; + } + + /* We want to do a straight memory copy if possible: this is + * an important operation because .set() is the TypedArray + * way to copy chunks of memory. However, because set() + * conceptually works in terms of elements, not all views are + * compatible with direct byte copying. + * + * If we do manage a direct copy, the "overlap issue" handled + * below can just be solved using memmove() because the source + * and destination element sizes are necessarily equal. + */ + + DUK_ASSERT(h_this->elem_type < sizeof(duk__buffer_elemtype_copy_compatible) / sizeof(duk_uint16_t)); + comp_mask = duk__buffer_elemtype_copy_compatible[h_this->elem_type]; + if (comp_mask & (1 << h_bufarg->elem_type)) { + DUK_ASSERT(src_length == dst_length); + + DUK_DDD(DUK_DDDPRINT("fast path: able to use memmove() because views are compatible")); + DUK_MEMMOVE((void *) p_dst_base, (const void *) p_src_base, (size_t) dst_length); + return 0; + } + DUK_DDD(DUK_DDDPRINT("fast path: views are not compatible with a byte copy, copy by item")); + + /* We want to avoid making a copy to process set() but that's + * not always possible: the source and the target may overlap + * and because element sizes are different, the overlap cannot + * always be handled with a memmove() or choosing the copy + * direction in a certain way. For example, if source type is + * uint8 and target type is uint32, the target area may exceed + * the source area from both ends! + * + * Note that because external buffers may point to the same + * memory areas, we must ultimately make this check using + * pointers. + * + * NOTE: careful with side effects: any side effect may cause + * a buffer resize (or external buffer pointer/length update)! + */ + + DUK_DDD(DUK_DDDPRINT("overlap check: p_src_base=%p, src_length=%ld, " + "p_dst_base=%p, dst_length=%ld", + (void *) p_src_base, (long) src_length, + (void *) p_dst_base, (long) dst_length)); + + if (p_src_base >= p_dst_base + dst_length || /* source starts after dest ends */ + p_src_base + src_length <= p_dst_base) { /* source ends before dest starts */ + no_overlap = 1; + } + + if (!no_overlap) { + /* There's overlap: the desired end result is that + * conceptually a copy is made to avoid "trampling" + * of source data by destination writes. We make + * an actual temporary copy to handle this case. + */ + duk_uint8_t *p_src_copy; + + DUK_DDD(DUK_DDDPRINT("there is overlap, make a copy of the source")); + p_src_copy = (duk_uint8_t *) duk_push_fixed_buffer(ctx, src_length); + DUK_ASSERT(p_src_copy != NULL); + DUK_MEMCPY((void *) p_src_copy, (const void *) p_src_base, (size_t) src_length); + + p_src_base = p_src_copy; /* use p_src_base from now on */ + } + /* Value stack intentionally mixed size here. */ + + DUK_DDD(DUK_DDDPRINT("after overlap check: p_src_base=%p, src_length=%ld, " + "p_dst_base=%p, dst_length=%ld, valstack top=%ld", + (void *) p_src_base, (long) src_length, + (void *) p_dst_base, (long) dst_length, + (long) duk_get_top(ctx))); + + /* Ready to make the copy. We must proceed element by element + * and must avoid any side effects that might cause the buffer + * validity check above to become invalid. + * + * Although we work through the value stack here, only plain + * numbers are handled which should be side effect safe. + */ + + src_elem_size = 1 << h_bufarg->shift; + dst_elem_size = 1 << h_this->shift; + p_src = p_src_base; + p_dst = p_dst_base; + p_src_end = p_src_base + src_length; + + while (p_src != p_src_end) { + DUK_DDD(DUK_DDDPRINT("fast path per element copy loop: " + "p_src=%p, p_src_end=%p, p_dst=%p", + (void *) p_src, (void *) p_src_end, (void *) p_dst)); + /* A validated read() is always a number, so it's write coercion + * is always side effect free an won't invalidate pointers etc. + */ + duk_hbufferobject_push_validated_read(ctx, h_bufarg, p_src, src_elem_size); + duk_hbufferobject_validated_write(ctx, h_this, p_dst, dst_elem_size); + duk_pop(ctx); + p_src += src_elem_size; + p_dst += dst_elem_size; + } + + return 0; + } else { + /* Slow path: quite slow, but we save space by using the property code + * to write coerce target values. We don't need to worry about overlap + * here because the source is not a TypedArray. + * + * We could use the bufferobject write coercion helper but since the + * property read may have arbitrary side effects, full validity checks + * would be needed for every element anyway. + */ + + n = (duk_uarridx_t) duk_get_length(ctx, 0); + DUK_ASSERT(offset_bytes <= h_this->length); + if ((n << h_this->shift) > h_this->length - offset_bytes) { + /* Overflow not an issue because subtraction is used on the right + * side and guaranteed to be >= 0. + */ + DUK_DDD(DUK_DDDPRINT("copy exceeds target buffer nominal length")); + return DUK_RET_RANGE_ERROR; + } + + /* There's no need to check for buffer validity status for the + * target here: the property access code will do that for each + * element. Moreover, if we did check the validity here, side + * effects from reading the source argument might invalidate + * the results anyway. + */ + + DUK_ASSERT_TOP(ctx, 2); + duk_push_this(ctx); + + for (i = 0; i < n; i++) { + duk_get_prop_index(ctx, 0, i); + duk_put_prop_index(ctx, 2, offset_elems + i); + } + } + + return 0; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_typedarray_set(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.prototype.slice([start], [end]) + * ArrayBuffer.prototype.slice(begin, [end]) + * TypedArray.prototype.slice(begin, [end]) + * + * The API calls are almost identical; negative indices are counted from end + * of buffer, and final indices are clamped (allowing crossed indices). Main + * differences: + * + * - Copy/view behavior; Node.js .slice() and TypedArray .subarray() create + * views, ArrayBuffer .slice() creates a copy + * + * - Resulting object has a different class and prototype depending on the + * call (or 'this' argument) + * + * - TypedArray .subarray() arguments are element indices, not byte offsets + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_buffer_slice_shared(duk_context *ctx) { + duk_hthread *thr; + duk_small_int_t magic; + duk_small_uint_t res_class_num; + duk_hobject *res_proto; + duk_hbufferobject *h_this; + duk_hbufferobject *h_bufobj; + duk_hbuffer *h_val; + duk_int_t start_offset, end_offset; + duk_uint_t slice_length; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + /* [ start end ] */ + + magic = duk_get_current_magic(ctx); + h_this = duk__require_bufobj_this(ctx); + + /* Slice offsets are element (not byte) offsets, which only matters + * for TypedArray views, Node.js Buffer and ArrayBuffer have shift + * zero so byte and element offsets are the same. Negative indices + * are counted from end of slice, crossed indices are allowed (and + * result in zero length result), and final values are clamped + * against the current slice. There's intentionally no check + * against the underlying buffer here. + */ + + duk__clamp_startend_negidx_shifted(ctx, h_this, 0 /*idx_start*/, 1 /*idx_end*/, &start_offset, &end_offset); + DUK_ASSERT(end_offset >= start_offset); + slice_length = (duk_uint_t) (end_offset - start_offset); + + /* The resulting buffer object gets the same class and prototype as + * the buffer in 'this', e.g. if the input is a Node.js Buffer the + * result is a Node.js Buffer; if the input is a Float32Array, the + * result is a Float32Array. + * + * For the class number this seems correct. The internal prototype + * is not so clear: if 'this' is a bufferobject with a non-standard + * prototype object, that value gets copied over into the result + * (instead of using the standard prototype for that object type). + */ + + res_class_num = DUK_HOBJECT_GET_CLASS_NUMBER((duk_hobject *) h_this); + h_bufobj = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(res_class_num), + DUK_BIDX_OBJECT_PROTOTYPE); /* replaced */ + DUK_ASSERT(h_bufobj != NULL); + res_proto = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, (duk_hobject *) h_this); /* may be NULL */ + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) h_bufobj, res_proto); + + h_bufobj->length = slice_length; + h_bufobj->shift = h_this->shift; /* inherit */ + h_bufobj->elem_type = h_this->elem_type; /* inherit */ + h_bufobj->is_view = magic & 0x01; + DUK_ASSERT(h_bufobj->is_view == 0 || h_bufobj->is_view == 1); + + h_val = h_this->buf; + if (h_val == NULL) { + return DUK_RET_TYPE_ERROR; + } + + if (magic & 0x02) { + /* non-zero: make copy */ + duk_uint8_t *p_copy; + duk_size_t copy_length; + + p_copy = (duk_uint8_t *) duk_push_fixed_buffer(ctx, (duk_size_t) slice_length); + DUK_ASSERT(p_copy != NULL); + + /* Copy slice, respecting underlying buffer limits; remainder + * is left as zero. + */ + copy_length = DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH(h_this, slice_length); + DUK_MEMCPY((void *) p_copy, + (const void *) (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this) + start_offset), + copy_length); + + h_val = duk_get_hbuffer(ctx, -1); + DUK_ASSERT(h_val != NULL); + + h_bufobj->buf = h_val; + DUK_HBUFFER_INCREF(thr, h_val); + DUK_ASSERT(h_bufobj->offset == 0); + + duk_pop(ctx); /* reachable so pop OK */ + } else { + h_bufobj->buf = h_val; + DUK_HBUFFER_INCREF(thr, h_val); + h_bufobj->offset = (duk_uint_t) (h_this->offset + start_offset); + + /* Copy the .buffer property, needed for TypedArray.prototype.subarray(). + * + * XXX: limit copy only for TypedArray classes specifically? + */ + + duk_push_this(ctx); + if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_LC_BUFFER)) { + duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_LC_BUFFER, DUK_PROPDESC_FLAGS_NONE); + duk_pop(ctx); + } else { + duk_pop_2(ctx); + } + } + /* unbalanced stack on purpose */ + + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_buffer_slice_shared(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.isEncoding() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_is_encoding(duk_context *ctx) { + const char *encoding; + + /* only accept lowercase 'utf8' now. */ + + encoding = duk_to_string(ctx, 0); + DUK_ASSERT(duk_is_string(ctx, 0)); /* guaranteed by duk_to_string() */ + duk_push_boolean(ctx, DUK_STRCMP(encoding, "utf8") == 0); + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_is_encoding(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.isBuffer() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_is_buffer(duk_context *ctx) { + duk_hthread *thr; + duk_tval *tv; + duk_hobject *h; + duk_hobject *h_proto; + duk_bool_t ret = 0; + + thr = (duk_hthread *) ctx; + + DUK_ASSERT(duk_get_top(ctx) >= 1); /* nargs */ + tv = duk_get_tval(ctx, 0); + DUK_ASSERT(tv != NULL); + + if (DUK_TVAL_IS_OBJECT(tv)) { + h = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(h != NULL); + + h_proto = thr->builtins[DUK_BIDX_NODEJS_BUFFER_PROTOTYPE]; + DUK_ASSERT(h_proto != NULL); + + h = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h); + if (h) { + ret = duk_hobject_prototype_chain_contains(thr, h, h_proto, 0 /*ignore_loop*/); + } + } + + duk_push_boolean(ctx, ret); + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_is_buffer(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.byteLength() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_byte_length(duk_context *ctx) { + const char *str; + duk_size_t len; + + /* At the moment Buffer() will just use the string bytes as + * is (ignoring encoding), so we return the string length here + * unconditionally. + */ + + str = duk_to_lstring(ctx, 0, &len); + DUK_UNREF(str); + duk_push_size_t(ctx, len); + return 1; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_byte_length(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Node.js Buffer.concat() + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_concat(duk_context *ctx) { + duk_hthread *thr; + duk_hobject *h_arg; + duk_int_t total_length = 0; + duk_hbufferobject *h_bufobj; + duk_hbufferobject *h_bufres; + duk_hbuffer *h_val; + duk_uint_t i, n; + duk_uint8_t *p; + duk_size_t space_left; + duk_size_t copy_size; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + /* Node.js accepts only actual Arrays. */ + h_arg = duk_require_hobject(ctx, 0); + if (DUK_HOBJECT_GET_CLASS_NUMBER(h_arg) != DUK_HOBJECT_CLASS_ARRAY) { + return DUK_RET_TYPE_ERROR; + } + + /* Compute result length and validate argument buffers. */ + n = (duk_uint_t) duk_get_length(ctx, 0); + for (i = 0; i < n; i++) { + /* Neutered checks not necessary here: neutered buffers have + * zero 'length' so we'll effectively skip them. + */ + DUK_ASSERT_TOP(ctx, 2); /* [ array totalLength ] */ + duk_get_prop_index(ctx, 0, (duk_uarridx_t) i); /* -> [ array totalLength buf ] */ + h_bufobj = duk__require_bufobj_value(ctx, 2); + DUK_ASSERT(h_bufobj != NULL); + total_length += h_bufobj->length; + duk_pop(ctx); + } + if (n == 1) { + /* For the case n==1 Node.js doesn't seem to type check + * the sole member but we do it before returning it. + * For this case only the original buffer object is + * returned (not a copy). + */ + duk_get_prop_index(ctx, 0, 0); + return 1; + } + + /* User totalLength overrides a computed length, but we'll check + * every copy in the copy loop. Note that duk_to_uint() can + * technically have arbitrary side effects so we need to recheck + * the buffers in the copy loop. + */ + if (!duk_is_undefined(ctx, 1) && n > 0) { + /* For n == 0, Node.js ignores totalLength argument and + * returns a zero length buffer. + */ + total_length = duk_to_int(ctx, 1); + } + if (total_length < 0) { + return DUK_RET_RANGE_ERROR; + } + + h_bufres = duk_push_bufferobject_raw(ctx, + DUK_HOBJECT_FLAG_EXTENSIBLE | + DUK_HOBJECT_FLAG_BUFFEROBJECT | + DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BUFFER), + DUK_BIDX_NODEJS_BUFFER_PROTOTYPE); + DUK_ASSERT(h_bufres != NULL); + + p = (duk_uint8_t *) duk_push_fixed_buffer(ctx, total_length); + DUK_ASSERT(p != NULL); + space_left = total_length; + + for (i = 0; i < n; i++) { + DUK_ASSERT_TOP(ctx, 4); /* [ array totalLength bufres buf ] */ + + duk_get_prop_index(ctx, 0, (duk_uarridx_t) i); + h_bufobj = duk__require_bufobj_value(ctx, 4); + DUK_ASSERT(h_bufobj != NULL); + + copy_size = h_bufobj->length; + if (copy_size > space_left) { + copy_size = space_left; + } + + if (h_bufobj->buf != NULL && + DUK_HBUFFEROBJECT_VALID_SLICE(h_bufobj)) { + DUK_MEMCPY((void *) p, + (const void *) DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufobj), + copy_size); + } else { + /* Just skip, leaving zeroes in the result. */ + ; + } + p += copy_size; + space_left -= copy_size; + + duk_pop(ctx); + } + + h_val = duk_get_hbuffer(ctx, -1); + DUK_ASSERT(h_val != NULL); + + duk__set_bufobj_buffer(ctx, h_bufres, h_val); + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufres); + + duk_pop(ctx); /* pop plain buffer, now reachable through h_bufres */ + + return 1; /* return h_bufres */ +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_nodejs_buffer_concat(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +/* + * Shared readfield and writefield methods + * + * The readfield/writefield methods need support for endianness and field + * types. All offsets are byte based so no offset shifting is needed. + */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* Format of magic, bits: + * 0...1: field type; 0=uint8, 1=uint16, 2=uint32, 3=float, 4=double, 5=unused, 6=unused, 7=unused + * 3: endianness: 0=little, 1=big + * 4: signed: 1=yes, 0=no + * 5: typedarray: 1=yes, 0=no + */ +#define DUK__FLD_8BIT 0 +#define DUK__FLD_16BIT 1 +#define DUK__FLD_32BIT 2 +#define DUK__FLD_FLOAT 3 +#define DUK__FLD_DOUBLE 4 +#define DUK__FLD_VARINT 5 +#define DUK__FLD_BIGENDIAN (1 << 3) +#define DUK__FLD_SIGNED (1 << 4) +#define DUK__FLD_TYPEDARRAY (1 << 5) + +/* XXX: split into separate functions for each field type? */ +DUK_INTERNAL duk_ret_t duk_bi_buffer_readfield(duk_context *ctx) { + duk_hthread *thr; + duk_small_int_t magic = (duk_small_int_t) duk_get_current_magic(ctx); + duk_small_int_t magic_ftype; + duk_small_int_t magic_bigendian; + duk_small_int_t magic_signed; + duk_small_int_t magic_typedarray; + duk_small_int_t endswap; + duk_hbufferobject *h_this; + duk_bool_t no_assert; + duk_int_t offset_signed; + duk_uint_t offset; + duk_uint_t buffer_length; + duk_uint_t check_length; + duk_uint8_t *buf; + duk_double_union du; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + magic_ftype = magic & 0x0007; + magic_bigendian = magic & 0x0008; + magic_signed = magic & 0x0010; + magic_typedarray = magic & 0x0020; + + h_this = duk__require_bufobj_this(ctx); + DUK_ASSERT(h_this != NULL); + buffer_length = h_this->length; + + /* [ offset noAssert ], when ftype != DUK__FLD_VARINT */ + /* [ offset fieldByteLength noAssert ], when ftype == DUK__FLD_VARINT */ + /* [ offset littleEndian ], when DUK__FLD_TYPEDARRAY (regardless of ftype) */ + + /* Handle TypedArray vs. Node.js Buffer arg differences */ + if (magic_typedarray) { + no_assert = 0; +#if defined(DUK_USE_INTEGER_LE) + endswap = !duk_to_boolean(ctx, 1); /* 1=little endian */ +#else + endswap = duk_to_boolean(ctx, 1); /* 1=little endian */ +#endif + } else { + no_assert = duk_to_boolean(ctx, (magic_ftype == DUK__FLD_VARINT) ? 2 : 1); +#if defined(DUK_USE_INTEGER_LE) + endswap = magic_bigendian; +#else + endswap = !magic_bigendian; +#endif + } + + /* Offset is coerced first to signed integer range and then to unsigned. + * This ensures we can add a small byte length (1-8) to the offset in + * bound checks and not wrap. + */ + offset_signed = duk_to_int(ctx, 0); + offset = (duk_uint_t) offset_signed; + if (offset_signed < 0) { + goto fail_bounds; + } + + DUK_DDD(DUK_DDDPRINT("readfield, buffer_length=%ld, offset=%ld, no_assert=%d, " + "magic=%04x, magic_fieldtype=%d, magic_bigendian=%d, magic_signed=%d, " + "endswap=%d", + (long) buffer_length, (long) offset, (int) no_assert, + (unsigned int) magic, (int) magic_ftype, (int) (magic_bigendian >> 3), + (int) (magic_signed >> 4), (int) endswap)); + + /* Update 'buffer_length' to be the effective, safe limit which + * takes into account the underlying buffer. This value will be + * potentially invalidated by any side effect. + */ + check_length = DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH(h_this, buffer_length); + DUK_DDD(DUK_DDDPRINT("buffer_length=%ld, check_length=%ld", + (long) buffer_length, (long) check_length)); + + if (h_this->buf) { + buf = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this); + } else { + /* neutered, value doesn't matter because check_length is 0. */ + DUK_ASSERT(check_length == 0); + buf = NULL; + } + + switch (magic_ftype) { + case DUK__FLD_8BIT: { + duk_uint8_t tmp; + if (offset + 1U > check_length) { + goto fail_bounds; + } + tmp = buf[offset]; + if (magic_signed) { + duk_push_int(ctx, (duk_int_t) ((duk_int8_t) tmp)); + } else { + duk_push_uint(ctx, (duk_uint_t) tmp); + } + break; + } + case DUK__FLD_16BIT: { + duk_uint16_t tmp; + if (offset + 2U > check_length) { + goto fail_bounds; + } + DUK_MEMCPY((void *) du.uc, (const void *) (buf + offset), 2); + tmp = du.us[0]; + if (endswap) { + tmp = DUK_BSWAP16(tmp); + } + if (magic_signed) { + duk_push_int(ctx, (duk_int_t) ((duk_int16_t) tmp)); + } else { + duk_push_uint(ctx, (duk_uint_t) tmp); + } + break; + } + case DUK__FLD_32BIT: { + duk_uint32_t tmp; + if (offset + 4U > check_length) { + goto fail_bounds; + } + DUK_MEMCPY((void *) du.uc, (const void *) (buf + offset), 4); + tmp = du.ui[0]; + if (endswap) { + tmp = DUK_BSWAP32(tmp); + } + if (magic_signed) { + duk_push_int(ctx, (duk_int_t) ((duk_int32_t) tmp)); + } else { + duk_push_uint(ctx, (duk_uint_t) tmp); + } + break; + } + case DUK__FLD_FLOAT: { + duk_uint32_t tmp; + if (offset + 4U > check_length) { + goto fail_bounds; + } + DUK_MEMCPY((void *) du.uc, (const void *) (buf + offset), 4); + if (endswap) { + tmp = du.ui[0]; + tmp = DUK_BSWAP32(tmp); + du.ui[0] = tmp; + } + duk_push_number(ctx, (duk_double_t) du.f[0]); + break; + } + case DUK__FLD_DOUBLE: { + if (offset + 8U > check_length) { + goto fail_bounds; + } + DUK_MEMCPY((void *) du.uc, (const void *) (buf + offset), 8); + if (endswap) { + DUK_DBLUNION_BSWAP64(&du); + } + duk_push_number(ctx, (duk_double_t) du.d); + break; + } + case DUK__FLD_VARINT: { + /* Node.js Buffer variable width integer field. We don't really + * care about speed here, so aim for shortest algorithm. + */ + duk_int_t field_bytelen; + duk_int_t i, i_step, i_end; +#if defined(DUK_USE_64BIT_OPS) + duk_int64_t tmp; + duk_small_uint_t shift_tmp; +#else + duk_double_t tmp; + duk_small_int_t highbyte; +#endif + const duk_uint8_t *p; + + field_bytelen = duk_get_int(ctx, 1); /* avoid side effects! */ + if (field_bytelen < 1 || field_bytelen > 6) { + goto fail_field_length; + } + if (offset + (duk_uint_t) field_bytelen > check_length) { + goto fail_bounds; + } + p = (const duk_uint8_t *) (buf + offset); + + /* Slow gathering of value using either 64-bit arithmetic + * or IEEE doubles if 64-bit types not available. Handling + * of negative numbers is a bit non-obvious in both cases. + */ + + if (magic_bigendian) { + /* Gather in big endian */ + i = 0; + i_step = 1; + i_end = field_bytelen; /* one i_step over */ + } else { + /* Gather in little endian */ + i = field_bytelen - 1; + i_step = -1; + i_end = -1; /* one i_step over */ + } + +#if defined(DUK_USE_64BIT_OPS) + tmp = 0; + do { + DUK_ASSERT(i >= 0 && i < field_bytelen); + tmp = (tmp << 8) + (duk_int64_t) p[i]; + i += i_step; + } while (i != i_end); + + if (magic_signed) { + /* Shift to sign extend. */ + shift_tmp = 64 - (field_bytelen * 8); + tmp = (tmp << shift_tmp) >> shift_tmp; + } + + duk_push_i64(ctx, tmp); +#else + highbyte = p[i]; + if (magic_signed && (highbyte & 0x80) != 0) { + /* 0xff => 255 - 256 = -1; 0x80 => 128 - 256 = -128 */ + tmp = (duk_double_t) (highbyte - 256); + } else { + tmp = (duk_double_t) highbyte; + } + for (;;) { + i += i_step; + if (i == i_end) { + break; + } + DUK_ASSERT(i >= 0 && i < field_bytelen); + tmp = (tmp * 256.0) + (duk_double_t) p[i]; + } + + duk_push_number(ctx, tmp); +#endif + break; + } + default: { /* should never happen but default here */ + goto fail_bounds; + } + } + + return 1; + + fail_field_length: + fail_bounds: + if (no_assert) { + /* Node.js return value for noAssert out-of-bounds reads is + * usually (but not always) NaN. Return NaN consistently. + */ + duk_push_nan(ctx); + return 1; + } + + return DUK_RET_RANGE_ERROR; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_buffer_readfield(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +/* XXX: split into separate functions for each field type? */ +DUK_INTERNAL duk_ret_t duk_bi_buffer_writefield(duk_context *ctx) { + duk_hthread *thr; + duk_small_int_t magic = (duk_small_int_t) duk_get_current_magic(ctx); + duk_small_int_t magic_ftype; + duk_small_int_t magic_bigendian; + duk_small_int_t magic_signed; + duk_small_int_t magic_typedarray; + duk_small_int_t endswap; + duk_hbufferobject *h_this; + duk_bool_t no_assert; + duk_int_t offset_signed; + duk_uint_t offset; + duk_uint_t buffer_length; + duk_uint_t check_length; + duk_uint8_t *buf; + duk_double_union du; + duk_int_t nbytes = 0; + + thr = (duk_hthread *) ctx; + DUK_UNREF(thr); + + magic_ftype = magic & 0x0007; + magic_bigendian = magic & 0x0008; + magic_signed = magic & 0x0010; + magic_typedarray = magic & 0x0020; + DUK_UNREF(magic_signed); + + h_this = duk__require_bufobj_this(ctx); + DUK_ASSERT(h_this != NULL); + buffer_length = h_this->length; + + /* [ value offset noAssert ], when ftype != DUK__FLD_VARINT */ + /* [ value offset fieldByteLength noAssert ], when ftype == DUK__FLD_VARINT */ + /* [ offset value littleEndian ], when DUK__FLD_TYPEDARRAY (regardless of ftype) */ + + /* Handle TypedArray vs. Node.js Buffer arg differences */ + if (magic_typedarray) { + no_assert = 0; +#if defined(DUK_USE_INTEGER_LE) + endswap = !duk_to_boolean(ctx, 2); /* 1=little endian */ +#else + endswap = duk_to_boolean(ctx, 2); /* 1=little endian */ +#endif + duk_swap(ctx, 0, 1); /* offset/value order different from Node.js */ + } else { + no_assert = duk_to_boolean(ctx, (magic_ftype == DUK__FLD_VARINT) ? 3 : 2); +#if defined(DUK_USE_INTEGER_LE) + endswap = magic_bigendian; +#else + endswap = !magic_bigendian; +#endif + } + + /* Offset is coerced first to signed integer range and then to unsigned. + * This ensures we can add a small byte length (1-8) to the offset in + * bound checks and not wrap. + */ + offset_signed = duk_to_int(ctx, 1); + offset = (duk_uint_t) offset_signed; + + /* We need 'nbytes' even for a failed offset; return value must be + * (offset + nbytes) even when write fails due to invalid offset. + */ + if (magic_ftype != DUK__FLD_VARINT) { + DUK_ASSERT(magic_ftype >= 0 && magic_ftype < (duk_small_int_t) (sizeof(duk__buffer_nbytes_from_fldtype) / sizeof(duk_uint8_t))); + nbytes = duk__buffer_nbytes_from_fldtype[magic_ftype]; + } else { + nbytes = duk_get_int(ctx, 2); + if (nbytes < 1 || nbytes > 6) { + goto fail_field_length; + } + } + DUK_ASSERT(nbytes >= 1 && nbytes <= 8); + + /* Now we can check offset validity. */ + if (offset_signed < 0) { + goto fail_bounds; + } + + DUK_DDD(DUK_DDDPRINT("writefield, value=%!T, buffer_length=%ld, offset=%ld, no_assert=%d, " + "magic=%04x, magic_fieldtype=%d, magic_bigendian=%d, magic_signed=%d, " + "endswap=%d", + duk_get_tval(ctx, 0), (long) buffer_length, (long) offset, (int) no_assert, + (unsigned int) magic, (int) magic_ftype, (int) (magic_bigendian >> 3), + (int) (magic_signed >> 4), (int) endswap)); + + /* Coerce value to a number before computing check_length, so that + * the field type specific coercion below can't have side effects + * that would invalidate check_length. + */ + duk_to_number(ctx, 0); + + /* Update 'buffer_length' to be the effective, safe limit which + * takes into account the underlying buffer. This value will be + * potentially invalidated by any side effect. + */ + check_length = DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH(h_this, buffer_length); + DUK_DDD(DUK_DDDPRINT("buffer_length=%ld, check_length=%ld", + (long) buffer_length, (long) check_length)); + + if (h_this->buf) { + buf = DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_this); + } else { + /* neutered, value doesn't matter because check_length is 0. */ + DUK_ASSERT(check_length == 0); + buf = NULL; + } + + switch (magic_ftype) { + case DUK__FLD_8BIT: { + if (offset + 1U > check_length) { + goto fail_bounds; + } + /* sign doesn't matter when writing */ + buf[offset] = (duk_uint8_t) duk_to_uint32(ctx, 0); + break; + } + case DUK__FLD_16BIT: { + duk_uint16_t tmp; + if (offset + 2U > check_length) { + goto fail_bounds; + } + tmp = (duk_uint16_t) duk_to_uint32(ctx, 0); + if (endswap) { + tmp = DUK_BSWAP16(tmp); + } + du.us[0] = tmp; + /* sign doesn't matter when writing */ + DUK_MEMCPY((void *) (buf + offset), (const void *) du.uc, 2); + break; + } + case DUK__FLD_32BIT: { + duk_uint32_t tmp; + if (offset + 4U > check_length) { + goto fail_bounds; + } + tmp = (duk_uint32_t) duk_to_uint32(ctx, 0); + if (endswap) { + tmp = DUK_BSWAP32(tmp); + } + du.ui[0] = tmp; + /* sign doesn't matter when writing */ + DUK_MEMCPY((void *) (buf + offset), (const void *) du.uc, 4); + break; + } + case DUK__FLD_FLOAT: { + duk_uint32_t tmp; + if (offset + 4U > check_length) { + goto fail_bounds; + } + du.f[0] = (duk_float_t) duk_to_number(ctx, 0); + if (endswap) { + tmp = du.ui[0]; + tmp = DUK_BSWAP32(tmp); + du.ui[0] = tmp; + } + /* sign doesn't matter when writing */ + DUK_MEMCPY((void *) (buf + offset), (const void *) du.uc, 4); + break; + } + case DUK__FLD_DOUBLE: { + if (offset + 8U > check_length) { + goto fail_bounds; + } + du.d = (duk_double_t) duk_to_number(ctx, 0); + if (endswap) { + DUK_DBLUNION_BSWAP64(&du); + } + /* sign doesn't matter when writing */ + DUK_MEMCPY((void *) (buf + offset), (const void *) du.uc, 8); + break; + } + case DUK__FLD_VARINT: { + /* Node.js Buffer variable width integer field. We don't really + * care about speed here, so aim for shortest algorithm. + */ + duk_int_t field_bytelen; + duk_int_t i, i_step, i_end; +#if defined(DUK_USE_64BIT_OPS) + duk_int64_t tmp; +#else + duk_double_t tmp; +#endif + duk_uint8_t *p; + + field_bytelen = (duk_int_t) nbytes; + if (offset + (duk_uint_t) field_bytelen > check_length) { + goto fail_bounds; + } + + /* Slow writing of value using either 64-bit arithmetic + * or IEEE doubles if 64-bit types not available. There's + * no special sign handling when writing varints. + */ + + if (magic_bigendian) { + /* Write in big endian */ + i = field_bytelen; /* one i_step added at top of loop */ + i_step = -1; + i_end = 0; + } else { + /* Write in little endian */ + i = -1; /* one i_step added at top of loop */ + i_step = 1; + i_end = field_bytelen - 1; + } + + /* XXX: The duk_to_number() cast followed by integer coercion + * is platform specific so NaN, +/- Infinity, and out-of-bounds + * values result in platform specific output now. + * See: test-bi-nodejs-buffer-proto-varint-special.js + */ + +#if defined(DUK_USE_64BIT_OPS) + tmp = (duk_int64_t) duk_to_number(ctx, 0); + p = (duk_uint8_t *) (buf + offset); + do { + i += i_step; + DUK_ASSERT(i >= 0 && i < field_bytelen); + p[i] = (duk_uint8_t) (tmp & 0xff); + tmp = tmp >> 8; /* unnecessary shift for last byte */ + } while (i != i_end); +#else + tmp = duk_to_number(ctx, 0); + p = (duk_uint8_t *) (buf + offset); + do { + i += i_step; + tmp = DUK_FLOOR(tmp); + DUK_ASSERT(i >= 0 && i < field_bytelen); + p[i] = (duk_uint8_t) (DUK_FMOD(tmp, 256.0)); + tmp = tmp / 256.0; /* unnecessary div for last byte */ + } while (i != i_end); +#endif + break; + } + default: { /* should never happen but default here */ + goto fail_bounds; + } + } + + /* Node.js Buffer: return offset + #bytes written (i.e. next + * write offset). + */ + if (magic_typedarray) { + /* For TypedArrays 'undefined' return value is specified + * by ES6 (matches V8). + */ + return 0; + } + duk_push_uint(ctx, offset + nbytes); + return 1; + + fail_field_length: + fail_bounds: + if (no_assert) { + /* Node.js return value for failed writes is offset + #bytes + * that would have been written. + */ + /* XXX: for negative input offsets, 'offset' will be a large + * positive value so the result here is confusing. + */ + if (magic_typedarray) { + return 0; + } + duk_push_uint(ctx, offset + nbytes); + return 1; + } + return DUK_RET_RANGE_ERROR; +} +#else /* DUK_USE_BUFFEROBJECT_SUPPORT */ +DUK_INTERNAL duk_ret_t duk_bi_buffer_writefield(duk_context *ctx) { + DUK_UNREF(ctx); + return DUK_RET_UNSUPPORTED_ERROR; +} +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ + +#undef DUK__FLD_8BIT +#undef DUK__FLD_16BIT +#undef DUK__FLD_32BIT +#undef DUK__FLD_FLOAT +#undef DUK__FLD_DOUBLE +#undef DUK__FLD_VARINT +#undef DUK__FLD_BIGENDIAN +#undef DUK__FLD_SIGNED +#undef DUK__FLD_TYPEDARRAY #line 1 "duk_bi_date.c" /* * Date built-ins * - * Unlike most built-ins, Date has a lot of platform dependencies for - * getting UTC time, converting between UTC and local time, and parsing - * and formatting time values. + * Unlike most built-ins, Date has some platform dependencies for getting + * UTC time, converting between UTC and local time, and parsing and + * formatting time values. These are all abstracted behind DUK_USE_xxx + * config options. There are built-in platform specific providers for + * POSIX and Windows, but external providers can also be used. * - * See doc/datetime.txt. + * See doc/datetime.rst. * - * Platform specific links: - * - * - http://msdn.microsoft.com/en-us/library/windows/desktop/ms725473(v=vs.85).aspx */ /* include removed: duk_internal.h */ /* - * Platform specific includes and defines - * - * Note that necessary system headers (like ) are included - * by duk_internal.h (or duk_features.h, which is included by duk_internal.h) - * because the header locations vary between systems and we don't want - * that clutter here. + * Forward declarations */ -#define DUK__GET_NOW_TIMEVAL duk_bi_date_get_now -#define DUK__GET_LOCAL_TZOFFSET duk__get_local_tzoffset - -/* Buffer sizes for some UNIX calls. Larger than strictly necessary - * to avoid Valgrind errors. - */ -#define DUK__STRPTIME_BUF_SIZE 64 -#define DUK__STRFTIME_BUF_SIZE 64 +DUK_LOCAL_DECL duk_double_t duk__push_this_get_timeval_tzoffset(duk_context *ctx, duk_small_uint_t flags, duk_int_t *out_tzoffset); +DUK_LOCAL_DECL duk_double_t duk__push_this_get_timeval(duk_context *ctx, duk_small_uint_t flags); +DUK_LOCAL_DECL void duk__twodigit_year_fixup(duk_context *ctx, duk_idx_t idx_val); +DUK_LOCAL_DECL duk_ret_t duk__set_this_timeval_from_dparts(duk_context *ctx, duk_double_t *dparts, duk_small_uint_t flags); /* * Other file level defines */ -/* Forward declarations. */ -DUK_LOCAL_DECL duk_double_t duk__push_this_get_timeval_tzoffset(duk_context *ctx, duk_small_uint_t flags, duk_int_t *out_tzoffset); -DUK_LOCAL_DECL duk_double_t duk__push_this_get_timeval(duk_context *ctx, duk_small_uint_t flags); -DUK_LOCAL_DECL void duk__timeval_to_parts(duk_double_t d, duk_int_t *parts, duk_double_t *dparts, duk_small_uint_t flags); -DUK_LOCAL_DECL duk_double_t duk__get_timeval_from_dparts(duk_double_t *dparts, duk_small_uint_t flags); -DUK_LOCAL_DECL void duk__twodigit_year_fixup(duk_context *ctx, duk_idx_t idx_val); -DUK_LOCAL_DECL duk_bool_t duk__is_leap_year(duk_int_t year); -DUK_LOCAL_DECL duk_bool_t duk__timeval_in_valid_range(duk_double_t x); -DUK_LOCAL_DECL duk_bool_t duk__timeval_in_leeway_range(duk_double_t x); -DUK_LOCAL_DECL duk_bool_t duk__year_in_valid_range(duk_double_t year); - -/* Millisecond count constants. */ -#define DUK__MS_SECOND 1000L -#define DUK__MS_MINUTE (60L * 1000L) -#define DUK__MS_HOUR (60L * 60L * 1000L) -#define DUK__MS_DAY (24L * 60L * 60L * 1000L) - -/* Ecmascript date range is 100 million days from Epoch: - * > 100e6 * 24 * 60 * 60 * 1000 // 100M days in millisecs - * 8640000000000000 - * (= 8.64e15) - */ -#define DUK__MS_100M_DAYS (8.64e15) -#define DUK__MS_100M_DAYS_LEEWAY (8.64e15 + 24 * 3600e3) - -/* Ecmascript year range: - * > new Date(100e6 * 24 * 3600e3).toISOString() - * '+275760-09-13T00:00:00.000Z' - * > new Date(-100e6 * 24 * 3600e3).toISOString() - * '-271821-04-20T00:00:00.000Z' - */ -#define DUK__MIN_ECMA_YEAR (-271821) -#define DUK__MAX_ECMA_YEAR 275760 - -/* Part indices for internal breakdowns. Part order from DUK__IDX_YEAR to - * DUK__IDX_MILLISECOND matches argument ordering of Ecmascript API calls - * (like Date constructor call). A few functions in this file depend - * on the specific ordering, so change with care. 16 bits are not enough - * for all parts (year, specifically). - * - * (Must be in-sync with genbuiltins.py.) - */ -#define DUK__IDX_YEAR 0 /* year */ -#define DUK__IDX_MONTH 1 /* month: 0 to 11 */ -#define DUK__IDX_DAY 2 /* day within month: 0 to 30 */ -#define DUK__IDX_HOUR 3 -#define DUK__IDX_MINUTE 4 -#define DUK__IDX_SECOND 5 -#define DUK__IDX_MILLISECOND 6 -#define DUK__IDX_WEEKDAY 7 /* weekday: 0 to 6, 0=sunday, 1=monday, etc */ -#define DUK__NUM_PARTS 8 - -/* Internal API call flags, used for various functions in this file. - * Certain flags are used by only certain functions, but since the flags - * don't overlap, a single flags value can be passed around to multiple - * functions. - * - * The unused top bits of the flags field are also used to pass values - * to helpers (duk__get_part_helper() and duk__set_part_helper()). - * - * (Must be in-sync with genbuiltins.py.) - */ -#define DUK__FLAG_NAN_TO_ZERO (1 << 0) /* timeval breakdown: internal time value NaN -> zero */ -#define DUK__FLAG_NAN_TO_RANGE_ERROR (1 << 1) /* timeval breakdown: internal time value NaN -> RangeError (toISOString) */ -#define DUK__FLAG_ONEBASED (1 << 2) /* timeval breakdown: convert month and day-of-month parts to one-based (default is zero-based) */ -#define DUK__FLAG_EQUIVYEAR (1 << 3) /* timeval breakdown: replace year with equivalent year in the [1971,2037] range for DST calculations */ -#define DUK__FLAG_LOCALTIME (1 << 4) /* convert time value to local time */ -#define DUK__FLAG_SUB1900 (1 << 5) /* getter: subtract 1900 from year when getting year part */ -#define DUK__FLAG_TOSTRING_DATE (1 << 6) /* include date part in string conversion result */ -#define DUK__FLAG_TOSTRING_TIME (1 << 7) /* include time part in string conversion result */ -#define DUK__FLAG_TOSTRING_LOCALE (1 << 8) /* use locale specific formatting if available */ -#define DUK__FLAG_TIMESETTER (1 << 9) /* setter: call is a time setter (affects hour, min, sec, ms); otherwise date setter (affects year, month, day-in-month) */ -#define DUK__FLAG_YEAR_FIXUP (1 << 10) /* setter: perform 2-digit year fixup (00...99 -> 1900...1999) */ -#define DUK__FLAG_SEP_T (1 << 11) /* string conversion: use 'T' instead of ' ' as a separator */ -#define DUK__FLAG_VALUE_SHIFT 12 /* additional values begin at bit 12 */ - /* Debug macro to print all parts and dparts (used manually because of debug level). */ #define DUK__DPRINT_PARTS_AND_DPARTS(parts,dparts) do { \ DUK_D(DUK_DPRINT("parts: %ld %ld %ld %ld %ld %ld %ld %ld, dparts: %lf %lf %lf %lf %lf %lf %lf %lf", \ @@ -20739,384 +27742,6 @@ DUK_LOCAL duk_uint8_t duk__date_equivyear[14] = { }; #undef DUK__YEAR -/* - * Platform specific helpers - */ - -#ifdef DUK_USE_DATE_NOW_GETTIMEOFDAY -/* Get current Ecmascript time (= UNIX/Posix time, but in milliseconds). */ -DUK_INTERNAL duk_double_t duk_bi_date_get_now(duk_context *ctx) { - duk_hthread *thr = (duk_hthread *) ctx; - struct timeval tv; - duk_double_t d; - - if (gettimeofday(&tv, NULL) != 0) { - DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, "gettimeofday failed"); - } - - d = ((duk_double_t) tv.tv_sec) * 1000.0 + - ((duk_double_t) (tv.tv_usec / 1000)); - DUK_ASSERT(DUK_FLOOR(d) == d); /* no fractions */ - - return d; -} -#endif /* DUK_USE_DATE_NOW_GETTIMEOFDAY */ - -#ifdef DUK_USE_DATE_NOW_TIME -/* Not a very good provider: only full seconds are available. */ -DUK_INTERNAL duk_double_t duk_bi_date_get_now(duk_context *ctx) { - time_t t = time(NULL); - return ((duk_double_t) t) * 1000.0; -} -#endif /* DUK_USE_DATE_NOW_TIME */ - -#if defined(DUK_USE_DATE_NOW_WINDOWS) || defined(DUK_USE_DATE_TZO_WINDOWS) -/* Shared Windows helpers. */ -DUK_LOCAL void duk__convert_systime_to_ularge(const SYSTEMTIME *st, ULARGE_INTEGER *res) { - FILETIME ft; - if (SystemTimeToFileTime(st, &ft) == 0) { - DUK_D(DUK_DPRINT("SystemTimeToFileTime() failed, returning 0")); - res->QuadPart = 0; - } else { - res->LowPart = ft.dwLowDateTime; - res->HighPart = ft.dwHighDateTime; - } -} -DUK_LOCAL void duk__set_systime_jan1970(SYSTEMTIME *st) { - DUK_MEMZERO((void *) st, sizeof(*st)); - st->wYear = 1970; - st->wMonth = 1; - st->wDayOfWeek = 4; /* not sure whether or not needed; Thursday */ - st->wDay = 1; - DUK_ASSERT(st->wHour == 0); - DUK_ASSERT(st->wMinute == 0); - DUK_ASSERT(st->wSecond == 0); - DUK_ASSERT(st->wMilliseconds == 0); -} -#endif /* defined(DUK_USE_DATE_NOW_WINDOWS) || defined(DUK_USE_DATE_TZO_WINDOWS) */ - -#ifdef DUK_USE_DATE_NOW_WINDOWS -DUK_INTERNAL duk_double_t duk_bi_date_get_now(duk_context *ctx) { - /* Suggested step-by-step method from documentation of RtlTimeToSecondsSince1970: - * http://msdn.microsoft.com/en-us/library/windows/desktop/ms724928(v=vs.85).aspx - */ - SYSTEMTIME st1, st2; - ULARGE_INTEGER tmp1, tmp2; - - DUK_UNREF(ctx); - - GetSystemTime(&st1); - duk__convert_systime_to_ularge((const SYSTEMTIME *) &st1, &tmp1); - - duk__set_systime_jan1970(&st2); - duk__convert_systime_to_ularge((const SYSTEMTIME *) &st2, &tmp2); - - /* Difference is in 100ns units, convert to milliseconds w/o fractions */ - return (duk_double_t) ((tmp1.QuadPart - tmp2.QuadPart) / 10000LL); -} -#endif /* DUK_USE_DATE_NOW_WINDOWS */ - -#if defined(DUK_USE_DATE_TZO_GMTIME) || defined(DUK_USE_DATE_TZO_GMTIME_R) -/* Get local time offset (in seconds) for a certain (UTC) instant 'd'. */ -DUK_LOCAL duk_int_t duk__get_local_tzoffset(duk_double_t d) { - time_t t, t1, t2; - duk_int_t parts[DUK__NUM_PARTS]; - duk_double_t dparts[DUK__NUM_PARTS]; - struct tm tms[2]; -#ifdef DUK_USE_DATE_TZO_GMTIME - struct tm *tm_ptr; -#endif - - /* For NaN/inf, the return value doesn't matter. */ - if (!DUK_ISFINITE(d)) { - return 0; - } - - /* If not within Ecmascript range, some integer time calculations - * won't work correctly (and some asserts will fail), so bail out - * if so. This fixes test-bug-date-insane-setyear.js. There is - * a +/- 24h leeway in this range check to avoid a test262 corner - * case documented in test-bug-date-timeval-edges.js. - */ - if (!duk__timeval_in_leeway_range(d)) { - DUK_DD(DUK_DDPRINT("timeval not within valid range, skip tzoffset computation to avoid integer overflows")); - return 0; - } - - /* - * This is a bit tricky to implement portably. The result depends - * on the timestamp (specifically, DST depends on the timestamp). - * If e.g. UNIX APIs are used, they'll have portability issues with - * very small and very large years. - * - * Current approach: - * - * - Stay within portable UNIX limits by using equivalent year mapping. - * Avoid year 1970 and 2038 as some conversions start to fail, at - * least on some platforms. Avoiding 1970 means that there are - * currently DST discrepancies for 1970. - * - * - Create a UTC and local time breakdowns from 't'. Then create - * a time_t using gmtime() and localtime() and compute the time - * difference between the two. - * - * Equivalent year mapping (E5 Section 15.9.1.8): - * - * If the host environment provides functionality for determining - * daylight saving time, the implementation of ECMAScript is free - * to map the year in question to an equivalent year (same - * leap-year-ness and same starting week day for the year) for which - * the host environment provides daylight saving time information. - * The only restriction is that all equivalent years should produce - * the same result. - * - * This approach is quite reasonable but not entirely correct, e.g. - * the specification also states (E5 Section 15.9.1.8): - * - * The implementation of ECMAScript should not try to determine - * whether the exact time was subject to daylight saving time, but - * just whether daylight saving time would have been in effect if - * the _current daylight saving time algorithm_ had been used at the - * time. This avoids complications such as taking into account the - * years that the locale observed daylight saving time year round. - * - * Since we rely on the platform APIs for conversions between local - * time and UTC, we can't guarantee the above. Rather, if the platform - * has historical DST rules they will be applied. This seems to be the - * general preferred direction in Ecmascript standardization (or at least - * implementations) anyway, and even the equivalent year mapping should - * be disabled if the platform is known to handle DST properly for the - * full Ecmascript range. - * - * The following has useful discussion and links: - * - * https://bugzilla.mozilla.org/show_bug.cgi?id=351066 - */ - - duk__timeval_to_parts(d, parts, dparts, DUK__FLAG_EQUIVYEAR /*flags*/); - DUK_ASSERT(parts[DUK__IDX_YEAR] >= 1970 && parts[DUK__IDX_YEAR] <= 2038); - - d = duk__get_timeval_from_dparts(dparts, 0 /*flags*/); - DUK_ASSERT(d >= 0 && d < 2147483648.0 * 1000.0); /* unsigned 31-bit range */ - t = (time_t) (d / 1000.0); - DUK_DDD(DUK_DDDPRINT("timeval: %lf -> time_t %ld", (double) d, (long) t)); - - t1 = t; - - DUK_MEMZERO((void *) tms, sizeof(struct tm) * 2); - -#if defined(DUK_USE_DATE_TZO_GMTIME_R) - (void) gmtime_r(&t, &tms[0]); - (void) localtime_r(&t, &tms[1]); -#elif defined(DUK_USE_DATE_TZO_GMTIME) - tm_ptr = gmtime(&t); - DUK_MEMCPY((void *) &tms[0], tm_ptr, sizeof(struct tm)); - tm_ptr = localtime(&t); - DUK_MEMCPY((void *) &tms[1], tm_ptr, sizeof(struct tm)); -#else -#error internal error -#endif - DUK_DDD(DUK_DDDPRINT("gmtime result: tm={sec:%ld,min:%ld,hour:%ld,mday:%ld,mon:%ld,year:%ld," - "wday:%ld,yday:%ld,isdst:%ld}", - (long) tms[0].tm_sec, (long) tms[0].tm_min, (long) tms[0].tm_hour, - (long) tms[0].tm_mday, (long) tms[0].tm_mon, (long) tms[0].tm_year, - (long) tms[0].tm_wday, (long) tms[0].tm_yday, (long) tms[0].tm_isdst)); - DUK_DDD(DUK_DDDPRINT("localtime result: tm={sec:%ld,min:%ld,hour:%ld,mday:%ld,mon:%ld,year:%ld," - "wday:%ld,yday:%ld,isdst:%ld}", - (long) tms[1].tm_sec, (long) tms[1].tm_min, (long) tms[1].tm_hour, - (long) tms[1].tm_mday, (long) tms[1].tm_mon, (long) tms[1].tm_year, - (long) tms[1].tm_wday, (long) tms[1].tm_yday, (long) tms[1].tm_isdst)); - - t1 = mktime(&tms[0]); /* UTC */ - t2 = mktime(&tms[1]); /* local */ - if (t1 == (time_t) -1 || t2 == (time_t) -1) { - /* This check used to be for (t < 0) but on some platforms - * time_t is unsigned and apparently the proper way to detect - * an mktime() error return is the cast above. See e.g.: - * http://pubs.opengroup.org/onlinepubs/009695299/functions/mktime.html - */ - goto error; - } - if (tms[1].tm_isdst > 0) { - t2 += 3600; - } else if (tms[1].tm_isdst < 0) { - DUK_D(DUK_DPRINT("tm_isdst is negative: %d", (int) tms[1].tm_isdst)); - } - DUK_DDD(DUK_DDDPRINT("t1=%ld (utc), t2=%ld (local)", (long) t1, (long) t2)); - - /* Compute final offset in seconds, positive if local time ahead of - * UTC (returned value is UTC-to-local offset). - * - * difftime() returns a double, so coercion to int generates quite - * a lot of code. Direct subtraction is not portable, however. - * XXX: allow direct subtraction on known platforms. - */ -#if 0 - return (duk_int_t) (t2 - t1); -#endif - return (duk_int_t) difftime(t2, t1); - - error: - /* XXX: return something more useful, so that caller can throw? */ - DUK_D(DUK_DPRINT("mktime() failed, d=%lf", (double) d)); - return 0; -} -#endif /* DUK_USE_DATE_TZO_GMTIME */ - -#if defined(DUK_USE_DATE_TZO_WINDOWS) -DUK_LOCAL duk_int_t duk__get_local_tzoffset(duk_double_t d) { - SYSTEMTIME st1; - SYSTEMTIME st2; - SYSTEMTIME st3; - ULARGE_INTEGER tmp1; - ULARGE_INTEGER tmp2; - ULARGE_INTEGER tmp3; - FILETIME ft1; - - /* XXX: handling of timestamps outside Windows supported range. - * How does Windows deal with dates before 1600? Does windows - * support all Ecmascript years (like -200000 and +200000)? - * Should equivalent year mapping be used here too? If so, use - * a shared helper (currently integrated into timeval-to-parts). - */ - - /* Use the approach described in "Remarks" of FileTimeToLocalFileTime: - * http://msdn.microsoft.com/en-us/library/windows/desktop/ms724277(v=vs.85).aspx - */ - - duk__set_systime_jan1970(&st1); - duk__convert_systime_to_ularge((const SYSTEMTIME *) &st1, &tmp1); - tmp2.QuadPart = (ULONGLONG) (d * 10000.0); /* millisec -> 100ns units since jan 1, 1970 */ - tmp2.QuadPart += tmp1.QuadPart; /* input 'd' in Windows UTC, 100ns units */ - - ft1.dwLowDateTime = tmp2.LowPart; - ft1.dwHighDateTime = tmp2.HighPart; - FileTimeToSystemTime((const FILETIME *) &ft1, &st2); - if (SystemTimeToTzSpecificLocalTime((LPTIME_ZONE_INFORMATION) NULL, &st2, &st3) == 0) { - DUK_D(DUK_DPRINT("SystemTimeToTzSpecificLocalTime() failed, return tzoffset 0")); - return 0; - } - duk__convert_systime_to_ularge((const SYSTEMTIME *) &st3, &tmp3); - - /* Positive if local time ahead of UTC. */ - return (duk_int_t) (((LONGLONG) tmp3.QuadPart - (LONGLONG) tmp2.QuadPart) / 10000000LL); /* seconds */ -} -#endif /* DUK_USE_DATE_TZO_WINDOWS */ - -#ifdef DUK_USE_DATE_PRS_STRPTIME -DUK_LOCAL duk_bool_t duk__parse_string_strptime(duk_context *ctx, const char *str) { - struct tm tm; - time_t t; - char buf[DUK__STRPTIME_BUF_SIZE]; - - /* copy to buffer with spare to avoid Valgrind gripes from strptime */ - DUK_ASSERT(str != NULL); - DUK_MEMZERO(buf, sizeof(buf)); /* valgrind whine without this */ - DUK_SNPRINTF(buf, sizeof(buf), "%s", (const char *) str); - buf[sizeof(buf) - 1] = (char) 0; - - DUK_DDD(DUK_DDDPRINT("parsing: '%s'", (const char *) buf)); - - DUK_MEMZERO(&tm, sizeof(tm)); - if (strptime((const char *) buf, "%c", &tm) != NULL) { - DUK_DDD(DUK_DDDPRINT("before mktime: tm={sec:%ld,min:%ld,hour:%ld,mday:%ld,mon:%ld,year:%ld," - "wday:%ld,yday:%ld,isdst:%ld}", - (long) tm.tm_sec, (long) tm.tm_min, (long) tm.tm_hour, - (long) tm.tm_mday, (long) tm.tm_mon, (long) tm.tm_year, - (long) tm.tm_wday, (long) tm.tm_yday, (long) tm.tm_isdst)); - tm.tm_isdst = -1; /* negative: dst info not available */ - - t = mktime(&tm); - DUK_DDD(DUK_DDDPRINT("mktime() -> %ld", (long) t)); - if (t >= 0) { - duk_push_number(ctx, ((duk_double_t) t) * 1000.0); - return 1; - } - } - - return 0; -} -#endif /* DUK_USE_DATE_PRS_STRPTIME */ - -#ifdef DUK_USE_DATE_PRS_GETDATE -DUK_LOCAL duk_bool_t duk__parse_string_getdate(duk_context *ctx, const char *str) { - struct tm tm; - duk_small_int_t rc; - time_t t; - - /* For this to work, DATEMSK must be set, so this is not very - * convenient for an embeddable interpreter. - */ - - DUK_MEMZERO(&tm, sizeof(struct tm)); - rc = (duk_small_int_t) getdate_r(str, &tm); - DUK_DDD(DUK_DDDPRINT("getdate_r() -> %ld", (long) rc)); - - if (rc == 0) { - t = mktime(&tm); - DUK_DDD(DUK_DDDPRINT("mktime() -> %ld", (long) t)); - if (t >= 0) { - duk_push_number(ctx, (duk_double_t) t); - return 1; - } - } - - return 0; -} -#endif /* DUK_USE_DATE_PRS_GETDATE */ - -#ifdef DUK_USE_DATE_FMT_STRFTIME -DUK_LOCAL duk_bool_t duk__format_parts_strftime(duk_context *ctx, duk_int_t *parts, duk_int_t tzoffset, duk_small_uint_t flags) { - char buf[DUK__STRFTIME_BUF_SIZE]; - struct tm tm; - const char *fmt; - - DUK_UNREF(tzoffset); - - /* If the platform doesn't support the entire Ecmascript range, we need - * to return 0 so that the caller can fall back to the default formatter. - * - * For now, assume that if time_t is 8 bytes or more, the whole Ecmascript - * range is supported. For smaller time_t values (4 bytes in practice), - * assumes that the signed 32-bit range is supported. - * - * XXX: detect this more correctly per platform. The size of time_t is - * probably not an accurate guarantee of strftime() supporting or not - * supporting a large time range (the full Ecmascript range). - */ - if (sizeof(time_t) < 8 && - (parts[DUK__IDX_YEAR] < 1970 || parts[DUK__IDX_YEAR] > 2037)) { - /* be paranoid for 32-bit time values (even avoiding negative ones) */ - return 0; - } - - DUK_MEMZERO(&tm, sizeof(tm)); - tm.tm_sec = parts[DUK__IDX_SECOND]; - tm.tm_min = parts[DUK__IDX_MINUTE]; - tm.tm_hour = parts[DUK__IDX_HOUR]; - tm.tm_mday = parts[DUK__IDX_DAY]; /* already one-based */ - tm.tm_mon = parts[DUK__IDX_MONTH] - 1; /* one-based -> zero-based */ - tm.tm_year = parts[DUK__IDX_YEAR] - 1900; - tm.tm_wday = parts[DUK__IDX_WEEKDAY]; - tm.tm_isdst = 0; - - DUK_MEMZERO(buf, sizeof(buf)); - if ((flags & DUK__FLAG_TOSTRING_DATE) && (flags & DUK__FLAG_TOSTRING_TIME)) { - fmt = "%c"; - } else if (flags & DUK__FLAG_TOSTRING_DATE) { - fmt = "%x"; - } else { - DUK_ASSERT(flags & DUK__FLAG_TOSTRING_TIME); - fmt = "%X"; - } - (void) strftime(buf, sizeof(buf) - 1, fmt, &tm); - DUK_ASSERT(buf[sizeof(buf) - 1] == 0); - - duk_push_string(ctx, buf); - return 1; -} -#endif /* DUK_USE_DATE_FMT_STRFTIME */ - /* * ISO 8601 subset parser. */ @@ -21214,7 +27839,7 @@ DUK_LOCAL const duk_uint32_t duk__parse_iso8601_control[] = { DUK_LOCAL duk_bool_t duk__parse_string_iso8601_subset(duk_context *ctx, const char *str) { duk_int_t parts[DUK__NUM_ISO8601_PARSER_PARTS]; - duk_double_t dparts[DUK__NUM_PARTS]; + duk_double_t dparts[DUK_DATE_IDX_NUM_PARTS]; duk_double_t d; const duk_uint8_t *p; duk_small_uint_t part_idx = 0; @@ -21227,9 +27852,9 @@ DUK_LOCAL duk_bool_t duk__parse_string_iso8601_subset(duk_context *ctx, const ch /* During parsing, month and day are one-based; set defaults here. */ DUK_MEMZERO(parts, sizeof(parts)); - DUK_ASSERT(parts[DUK__IDX_YEAR] == 0); /* don't care value, year is mandatory */ - parts[DUK__IDX_MONTH] = 1; - parts[DUK__IDX_DAY] = 1; + DUK_ASSERT(parts[DUK_DATE_IDX_YEAR] == 0); /* don't care value, year is mandatory */ + parts[DUK_DATE_IDX_MONTH] = 1; + parts[DUK_DATE_IDX_DAY] = 1; /* Special handling for year sign. */ p = (const duk_uint8_t *) str; @@ -21375,17 +28000,17 @@ DUK_LOCAL duk_bool_t duk__parse_string_iso8601_subset(duk_context *ctx, const ch /* Use double parts, they tolerate unnormalized time. * - * Note: DUK__IDX_WEEKDAY is initialized with a bogus value (DUK__PI_TZHOUR) - * on purpose. It won't be actually used by duk__get_timeval_from_dparts(), + * Note: DUK_DATE_IDX_WEEKDAY is initialized with a bogus value (DUK__PI_TZHOUR) + * on purpose. It won't be actually used by duk_bi_date_get_timeval_from_dparts(), * but will make the value initialized just in case, and avoid any * potential for Valgrind issues. */ - for (i = 0; i < DUK__NUM_PARTS; i++) { + for (i = 0; i < DUK_DATE_IDX_NUM_PARTS; i++) { DUK_DDD(DUK_DDDPRINT("part[%ld] = %ld", (long) i, (long) parts[i])); dparts[i] = parts[i]; } - d = duk__get_timeval_from_dparts(dparts, 0 /*flags*/); + d = duk_bi_date_get_timeval_from_dparts(dparts, 0 /*flags*/); duk_push_number(ctx, d); return 1; } @@ -21402,7 +28027,7 @@ DUK_LOCAL duk_bool_t duk__parse_string_iso8601_subset(duk_context *ctx, const ch * Note in particular that we must parse whatever toString(), toUTCString(), * and toISOString() can produce; see E5.1 Section 15.9.4.2. * - * Returns 1 to allow tailcalling. + * Returns 1 to allow tail calling. * * There is much room for improvement here with respect to supporting * alternative datetime formats. For instance, V8 parses '2012-01-01' as @@ -21422,12 +28047,13 @@ DUK_LOCAL duk_ret_t duk__parse_string(duk_context *ctx, const char *str) { return 1; } -#if defined(DUK_USE_DATE_PRS_STRPTIME) - if (duk__parse_string_strptime(ctx, str) != 0) { - return 1; - } -#elif defined(DUK_USE_DATE_PRS_GETDATE) - if (duk__parse_string_getdate(ctx, str) != 0) { +#if defined(DUK_USE_DATE_PARSE_STRING) + /* Contract, either: + * - Push value on stack and return 1 + * - Don't push anything on stack and return 0 + */ + + if (DUK_USE_DATE_PARSE_STRING(ctx, str) != 0) { return 1; } #else @@ -21466,7 +28092,7 @@ DUK_LOCAL duk_uint8_t duk__days_in_month[12] = { */ #define DUK__WEEKDAY_MOD_ADDER (20000000 * 7) /* 0x08583b00 */ -DUK_LOCAL duk_bool_t duk__is_leap_year(duk_int_t year) { +DUK_INTERNAL duk_bool_t duk_bi_date_is_leap_year(duk_int_t year) { if ((year % 4) != 0) { return 0; } @@ -21479,16 +28105,16 @@ DUK_LOCAL duk_bool_t duk__is_leap_year(duk_int_t year) { return 1; } -DUK_LOCAL duk_bool_t duk__timeval_in_valid_range(duk_double_t x) { - return (x >= -DUK__MS_100M_DAYS && x <= DUK__MS_100M_DAYS); +DUK_INTERNAL duk_bool_t duk_bi_date_timeval_in_valid_range(duk_double_t x) { + return (x >= -DUK_DATE_MSEC_100M_DAYS && x <= DUK_DATE_MSEC_100M_DAYS); } -DUK_LOCAL duk_bool_t duk__timeval_in_leeway_range(duk_double_t x) { - return (x >= -DUK__MS_100M_DAYS_LEEWAY && x <= DUK__MS_100M_DAYS_LEEWAY); +DUK_INTERNAL duk_bool_t duk_bi_date_timeval_in_leeway_range(duk_double_t x) { + return (x >= -DUK_DATE_MSEC_100M_DAYS_LEEWAY && x <= DUK_DATE_MSEC_100M_DAYS_LEEWAY); } -DUK_LOCAL duk_bool_t duk__year_in_valid_range(duk_double_t x) { - return (x >= DUK__MIN_ECMA_YEAR && x <= DUK__MAX_ECMA_YEAR); +DUK_INTERNAL duk_bool_t duk_bi_date_year_in_valid_range(duk_double_t x) { + return (x >= DUK_DATE_MIN_ECMA_YEAR && x <= DUK_DATE_MAX_ECMA_YEAR); } DUK_LOCAL duk_double_t duk__timeclip(duk_double_t x) { @@ -21496,7 +28122,7 @@ DUK_LOCAL duk_double_t duk__timeclip(duk_double_t x) { return DUK_DOUBLE_NAN; } - if (!duk__timeval_in_valid_range(x)) { + if (!duk_bi_date_timeval_in_valid_range(x)) { return DUK_DOUBLE_NAN; } @@ -21555,7 +28181,7 @@ DUK_LOCAL duk_int_t duk__year_from_day(duk_int_t day, duk_small_int_t *out_day_w DUK_DDD(DUK_DDDPRINT("--> year=%ld, day-within-year=%ld", (long) year, (long) *out_day_within_year)); DUK_ASSERT(*out_day_within_year >= 0); - DUK_ASSERT(*out_day_within_year < (duk__is_leap_year(year) ? 366 : 365)); + DUK_ASSERT(*out_day_within_year < (duk_bi_date_is_leap_year(year) ? 366 : 365)); return year; } @@ -21608,12 +28234,12 @@ DUK_LOCAL duk_double_t duk__make_day(duk_double_t year, duk_double_t month, duk_ * This fixes test-bug-setyear-overflow.js. */ - if (!duk__year_in_valid_range(year)) { + if (!duk_bi_date_year_in_valid_range(year)) { DUK_DD(DUK_DDPRINT("year not in ecmascript valid range, avoid integer overflow: %lf", (double) year)); return DUK_DOUBLE_NAN; } day_num = duk__day_from_year((duk_int_t) year); - is_leap = duk__is_leap_year((duk_int_t) year); + is_leap = duk_bi_date_is_leap_year((duk_int_t) year); n = (duk_small_int_t) month; for (i = 0; i < n; i++) { @@ -21631,7 +28257,7 @@ DUK_LOCAL duk_double_t duk__make_day(duk_double_t year, duk_double_t month, duk_ * one, i.e. finite, no fractions. Possible local time adjustment has already * been applied when reading the time value. */ -DUK_LOCAL void duk__timeval_to_parts(duk_double_t d, duk_int_t *parts, duk_double_t *dparts, duk_small_uint_t flags) { +DUK_INTERNAL void duk_bi_date_timeval_to_parts(duk_double_t d, duk_int_t *parts, duk_double_t *dparts, duk_small_uint_t flags) { duk_double_t d1, d2; duk_int_t t1, t2; duk_int_t day_since_epoch; @@ -21655,19 +28281,19 @@ DUK_LOCAL void duk__timeval_to_parts(duk_double_t d, duk_int_t *parts, duk_doubl * the value. In other words, although the UTC time is within the * Ecmascript range, the local part values can be just outside of it. */ - DUK_UNREF(duk__timeval_in_leeway_range); - DUK_ASSERT(duk__timeval_in_leeway_range(d)); + DUK_UNREF(duk_bi_date_timeval_in_leeway_range); + DUK_ASSERT(duk_bi_date_timeval_in_leeway_range(d)); /* these computations are guaranteed to be exact for the valid * E5 time value range, assuming milliseconds without fractions. */ - d1 = (duk_double_t) DUK_FMOD(d, (double) DUK__MS_DAY); + d1 = (duk_double_t) DUK_FMOD(d, (double) DUK_DATE_MSEC_DAY); if (d1 < 0.0) { /* deal with negative values */ - d1 += (duk_double_t) DUK__MS_DAY; + d1 += (duk_double_t) DUK_DATE_MSEC_DAY; } - d2 = DUK_FLOOR((double) (d / (duk_double_t) DUK__MS_DAY)); - DUK_ASSERT(d2 * ((duk_double_t) DUK__MS_DAY) + d1 == d); + d2 = DUK_FLOOR((double) (d / (duk_double_t) DUK_DATE_MSEC_DAY)); + DUK_ASSERT(d2 * ((duk_double_t) DUK_DATE_MSEC_DAY) + d1 == d); /* now expected to fit into a 32-bit integer */ t1 = (duk_int_t) d1; t2 = (duk_int_t) d2; @@ -21679,32 +28305,32 @@ DUK_LOCAL void duk__timeval_to_parts(duk_double_t d, duk_int_t *parts, duk_doubl * t2 = day number from epoch (fits 32 bit, may be negative) */ - parts[DUK__IDX_MILLISECOND] = t1 % 1000; t1 /= 1000; - parts[DUK__IDX_SECOND] = t1 % 60; t1 /= 60; - parts[DUK__IDX_MINUTE] = t1 % 60; t1 /= 60; - parts[DUK__IDX_HOUR] = t1; - DUK_ASSERT(parts[DUK__IDX_MILLISECOND] >= 0 && parts[DUK__IDX_MILLISECOND] <= 999); - DUK_ASSERT(parts[DUK__IDX_SECOND] >= 0 && parts[DUK__IDX_SECOND] <= 59); - DUK_ASSERT(parts[DUK__IDX_MINUTE] >= 0 && parts[DUK__IDX_MINUTE] <= 59); - DUK_ASSERT(parts[DUK__IDX_HOUR] >= 0 && parts[DUK__IDX_HOUR] <= 23); + parts[DUK_DATE_IDX_MILLISECOND] = t1 % 1000; t1 /= 1000; + parts[DUK_DATE_IDX_SECOND] = t1 % 60; t1 /= 60; + parts[DUK_DATE_IDX_MINUTE] = t1 % 60; t1 /= 60; + parts[DUK_DATE_IDX_HOUR] = t1; + DUK_ASSERT(parts[DUK_DATE_IDX_MILLISECOND] >= 0 && parts[DUK_DATE_IDX_MILLISECOND] <= 999); + DUK_ASSERT(parts[DUK_DATE_IDX_SECOND] >= 0 && parts[DUK_DATE_IDX_SECOND] <= 59); + DUK_ASSERT(parts[DUK_DATE_IDX_MINUTE] >= 0 && parts[DUK_DATE_IDX_MINUTE] <= 59); + DUK_ASSERT(parts[DUK_DATE_IDX_HOUR] >= 0 && parts[DUK_DATE_IDX_HOUR] <= 23); DUK_DDD(DUK_DDDPRINT("d=%lf, d1=%lf, d2=%lf, t1=%ld, t2=%ld, parts: hour=%ld min=%ld sec=%ld msec=%ld", (double) d, (double) d1, (double) d2, (long) t1, (long) t2, - (long) parts[DUK__IDX_HOUR], - (long) parts[DUK__IDX_MINUTE], - (long) parts[DUK__IDX_SECOND], - (long) parts[DUK__IDX_MILLISECOND])); + (long) parts[DUK_DATE_IDX_HOUR], + (long) parts[DUK_DATE_IDX_MINUTE], + (long) parts[DUK_DATE_IDX_SECOND], + (long) parts[DUK_DATE_IDX_MILLISECOND])); /* This assert depends on the input parts representing time inside * the Ecmascript range. */ DUK_ASSERT(t2 + DUK__WEEKDAY_MOD_ADDER >= 0); - parts[DUK__IDX_WEEKDAY] = (t2 + 4 + DUK__WEEKDAY_MOD_ADDER) % 7; /* E5.1 Section 15.9.1.6 */ - DUK_ASSERT(parts[DUK__IDX_WEEKDAY] >= 0 && parts[DUK__IDX_WEEKDAY] <= 6); + parts[DUK_DATE_IDX_WEEKDAY] = (t2 + 4 + DUK__WEEKDAY_MOD_ADDER) % 7; /* E5.1 Section 15.9.1.6 */ + DUK_ASSERT(parts[DUK_DATE_IDX_WEEKDAY] >= 0 && parts[DUK_DATE_IDX_WEEKDAY] <= 6); year = duk__year_from_day(t2, &day_in_year); day = day_in_year; - is_leap = duk__is_leap_year(year); + is_leap = duk_bi_date_is_leap_year(year); for (month = 0; month < 12; month++) { dim = duk__days_in_month[month]; if (month == 1 && is_leap) { @@ -21733,7 +28359,7 @@ DUK_LOCAL void duk__timeval_to_parts(duk_double_t d, duk_int_t *parts, duk_doubl * which breaks some DST computations for 1970 right now, see e.g. * test-bi-date-tzoffset-brute-fi.js. */ - if ((flags & DUK__FLAG_EQUIVYEAR) && (year < 1971 || year > 2037)) { + if ((flags & DUK_DATE_FLAG_EQUIVYEAR) && (year < 1971 || year > 2037)) { DUK_ASSERT(is_leap == 0 || is_leap == 1); jan1_since_epoch = day_since_epoch - day_in_year; /* day number for Jan 1 since epoch */ @@ -21754,17 +28380,17 @@ DUK_LOCAL void duk__timeval_to_parts(duk_double_t d, duk_int_t *parts, duk_doubl (long) jan1_since_epoch, (long) jan1_weekday, (long) equiv_year)); } - parts[DUK__IDX_YEAR] = year; - parts[DUK__IDX_MONTH] = month; - parts[DUK__IDX_DAY] = day; + parts[DUK_DATE_IDX_YEAR] = year; + parts[DUK_DATE_IDX_MONTH] = month; + parts[DUK_DATE_IDX_DAY] = day; - if (flags & DUK__FLAG_ONEBASED) { - parts[DUK__IDX_MONTH]++; /* zero-based -> one-based */ - parts[DUK__IDX_DAY]++; /* -""- */ + if (flags & DUK_DATE_FLAG_ONEBASED) { + parts[DUK_DATE_IDX_MONTH]++; /* zero-based -> one-based */ + parts[DUK_DATE_IDX_DAY]++; /* -""- */ } if (dparts != NULL) { - for (i = 0; i < DUK__NUM_PARTS; i++) { + for (i = 0; i < DUK_DATE_IDX_NUM_PARTS; i++) { dparts[i] = (duk_double_t) parts[i]; } } @@ -21776,7 +28402,7 @@ DUK_LOCAL void duk__timeval_to_parts(duk_double_t d, duk_int_t *parts, duk_doubl * wildly out of range (but may cancel each other and still come out in * the valid Date range). */ -DUK_LOCAL duk_double_t duk__get_timeval_from_dparts(duk_double_t *dparts, duk_small_uint_t flags) { +DUK_INTERNAL duk_double_t duk_bi_date_get_timeval_from_dparts(duk_double_t *dparts, duk_small_uint_t flags) { #if defined(DUK_USE_PARANOID_DATE_COMPUTATION) /* See comments below on MakeTime why these are volatile. */ volatile duk_double_t tmp_time; @@ -21797,10 +28423,10 @@ DUK_LOCAL duk_double_t duk__get_timeval_from_dparts(duk_double_t *dparts, duk_sm * zero. If ToInteger() has already been called, this has no side * effects and is idempotent. * - * Don't read dparts[DUK__IDX_WEEKDAY]; it will cause Valgrind issues - * if the value is uninitialized. + * Don't read dparts[DUK_DATE_IDX_WEEKDAY]; it will cause Valgrind + * issues if the value is uninitialized. */ - for (i = 0; i <= DUK__IDX_MILLISECOND; i++) { + for (i = 0; i <= DUK_DATE_IDX_MILLISECOND; i++) { /* SCANBUILD: scan-build complains here about assigned value * being garbage or undefined. This is correct but operating * on undefined values has no ill effect and is ignored by the @@ -21829,26 +28455,26 @@ DUK_LOCAL duk_double_t duk__get_timeval_from_dparts(duk_double_t *dparts, duk_sm /* MakeTime */ tmp_time = 0.0; - tmp_time += dparts[DUK__IDX_HOUR] * ((duk_double_t) DUK__MS_HOUR); - tmp_time += dparts[DUK__IDX_MINUTE] * ((duk_double_t) DUK__MS_MINUTE); - tmp_time += dparts[DUK__IDX_SECOND] * ((duk_double_t) DUK__MS_SECOND); - tmp_time += dparts[DUK__IDX_MILLISECOND]; + tmp_time += dparts[DUK_DATE_IDX_HOUR] * ((duk_double_t) DUK_DATE_MSEC_HOUR); + tmp_time += dparts[DUK_DATE_IDX_MINUTE] * ((duk_double_t) DUK_DATE_MSEC_MINUTE); + tmp_time += dparts[DUK_DATE_IDX_SECOND] * ((duk_double_t) DUK_DATE_MSEC_SECOND); + tmp_time += dparts[DUK_DATE_IDX_MILLISECOND]; /* MakeDay */ - tmp_day = duk__make_day(dparts[DUK__IDX_YEAR], dparts[DUK__IDX_MONTH], dparts[DUK__IDX_DAY]); + tmp_day = duk__make_day(dparts[DUK_DATE_IDX_YEAR], dparts[DUK_DATE_IDX_MONTH], dparts[DUK_DATE_IDX_DAY]); /* MakeDate */ - d = tmp_day * ((duk_double_t) DUK__MS_DAY) + tmp_time; + d = tmp_day * ((duk_double_t) DUK_DATE_MSEC_DAY) + tmp_time; DUK_DDD(DUK_DDDPRINT("time=%lf day=%lf --> timeval=%lf", (double) tmp_time, (double) tmp_day, (double) d)); /* Optional UTC conversion. */ - if (flags & DUK__FLAG_LOCALTIME) { - /* DUK__GET_LOCAL_TZOFFSET() needs to be called with a time - * value computed from UTC parts. At this point we only have - * 'd' which is a time value computed from local parts, so it - * is off by the UTC-to-local time offset which we don't know + if (flags & DUK_DATE_FLAG_LOCALTIME) { + /* DUK_USE_DATE_GET_LOCAL_TZOFFSET() needs to be called with a + * time value computed from UTC parts. At this point we only + * have 'd' which is a time value computed from local parts, so + * it is off by the UTC-to-local time offset which we don't know * yet. The current solution for computing the UTC-to-local * time offset is to iterate a few times and detect a fixed * point or a two-cycle loop (or a sanity iteration limit), @@ -21857,12 +28483,12 @@ DUK_LOCAL duk_double_t duk__get_timeval_from_dparts(duk_double_t *dparts, duk_sm * E5.1 Section 15.9.1.9: * UTC(t) = t - LocalTZA - DaylightSavingTA(t - LocalTZA) * - * For NaN/inf, DUK__GET_LOCAL_TZOFFSET() returns 0. + * For NaN/inf, DUK_USE_DATE_GET_LOCAL_TZOFFSET() returns 0. */ #if 0 /* Old solution: don't iterate, incorrect */ - tzoff = DUK__GET_LOCAL_TZOFFSET(d); + tzoff = DUK_USE_DATE_GET_LOCAL_TZOFFSET(d); DUK_DDD(DUK_DDDPRINT("tzoffset w/o iteration, tzoff=%ld", (long) tzoff)); d -= tzoff * 1000L; DUK_UNREF(tzoffprev1); @@ -21875,7 +28501,7 @@ DUK_LOCAL duk_double_t duk__get_timeval_from_dparts(duk_double_t *dparts, duk_sm for (i = 0; i < DUK__LOCAL_TZOFFSET_MAXITER; i++) { tzoffprev2 = tzoffprev1; tzoffprev1 = tzoff; - tzoff = DUK__GET_LOCAL_TZOFFSET(d - tzoff * 1000L); + tzoff = DUK_USE_DATE_GET_LOCAL_TZOFFSET(d - tzoff * 1000L); DUK_DDD(DUK_DDDPRINT("tzoffset iteration, i=%d, tzoff=%ld, tzoffprev1=%ld tzoffprev2=%ld", (int) i, (long) tzoff, (long) tzoffprev1, (long) tzoffprev2)); if (tzoff == tzoffprev1) { @@ -21931,21 +28557,21 @@ DUK_LOCAL duk_double_t duk__push_this_get_timeval_tzoffset(duk_context *ctx, duk duk_pop(ctx); if (DUK_ISNAN(d)) { - if (flags & DUK__FLAG_NAN_TO_ZERO) { + if (flags & DUK_DATE_FLAG_NAN_TO_ZERO) { d = 0.0; } - if (flags & DUK__FLAG_NAN_TO_RANGE_ERROR) { + if (flags & DUK_DATE_FLAG_NAN_TO_RANGE_ERROR) { DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, "Invalid Date"); } } /* if no NaN handling flag, may still be NaN here, but not Inf */ DUK_ASSERT(!DUK_ISINF(d)); - if (flags & DUK__FLAG_LOCALTIME) { + if (flags & DUK_DATE_FLAG_LOCALTIME) { /* Note: DST adjustment is determined using UTC time. * If 'd' is NaN, tzoffset will be 0. */ - tzoffset = DUK__GET_LOCAL_TZOFFSET(d); /* seconds */ + tzoffset = DUK_USE_DATE_GET_LOCAL_TZOFFSET(d); /* seconds */ d += tzoffset * 1000L; } if (out_tzoffset) { @@ -21961,7 +28587,7 @@ DUK_LOCAL duk_double_t duk__push_this_get_timeval(duk_context *ctx, duk_small_ui } /* Set timeval to 'this' from dparts, push the new time value onto the - * value stack and return 1 (caller can then tailcall us). Expects + * value stack and return 1 (caller can then tail call us). Expects * the value stack to contain 'this' on the stack top. */ DUK_LOCAL duk_ret_t duk__set_this_timeval_from_dparts(duk_context *ctx, duk_double_t *dparts, duk_small_uint_t flags) { @@ -21969,12 +28595,12 @@ DUK_LOCAL duk_ret_t duk__set_this_timeval_from_dparts(duk_context *ctx, duk_doub /* [ ... this ] */ - d = duk__get_timeval_from_dparts(dparts, flags); + d = duk_bi_date_get_timeval_from_dparts(dparts, flags); duk_push_number(ctx, d); /* -> [ ... this timeval_new ] */ duk_dup_top(ctx); /* -> [ ... this timeval_new timeval_new ] */ duk_put_prop_stridx(ctx, -3, DUK_STRIDX_INT_VALUE); - /* stack top: new time value, return 1 to allow tailcalls */ + /* stack top: new time value, return 1 to allow tail calls */ return 1; } @@ -21982,23 +28608,23 @@ DUK_LOCAL duk_ret_t duk__set_this_timeval_from_dparts(duk_context *ctx, duk_doub DUK_LOCAL void duk__format_parts_iso8601(duk_int_t *parts, duk_int_t tzoffset, duk_small_uint_t flags, duk_uint8_t *out_buf) { char yearstr[8]; /* "-123456\0" */ char tzstr[8]; /* "+11:22\0" */ - char sep = (flags & DUK__FLAG_SEP_T) ? DUK_ASC_UC_T : DUK_ASC_SPACE; + char sep = (flags & DUK_DATE_FLAG_SEP_T) ? DUK_ASC_UC_T : DUK_ASC_SPACE; - DUK_ASSERT(parts[DUK__IDX_MONTH] >= 1 && parts[DUK__IDX_MONTH] <= 12); - DUK_ASSERT(parts[DUK__IDX_DAY] >= 1 && parts[DUK__IDX_DAY] <= 31); - DUK_ASSERT(parts[DUK__IDX_YEAR] >= -999999 && parts[DUK__IDX_YEAR] <= 999999); + DUK_ASSERT(parts[DUK_DATE_IDX_MONTH] >= 1 && parts[DUK_DATE_IDX_MONTH] <= 12); + DUK_ASSERT(parts[DUK_DATE_IDX_DAY] >= 1 && parts[DUK_DATE_IDX_DAY] <= 31); + DUK_ASSERT(parts[DUK_DATE_IDX_YEAR] >= -999999 && parts[DUK_DATE_IDX_YEAR] <= 999999); /* Note: %06d for positive value, %07d for negative value to include * sign and 6 digits. */ DUK_SNPRINTF(yearstr, sizeof(yearstr), - (parts[DUK__IDX_YEAR] >= 0 && parts[DUK__IDX_YEAR] <= 9999) ? "%04ld" : - ((parts[DUK__IDX_YEAR] >= 0) ? "+%06ld" : "%07ld"), - (long) parts[DUK__IDX_YEAR]); + (parts[DUK_DATE_IDX_YEAR] >= 0 && parts[DUK_DATE_IDX_YEAR] <= 9999) ? "%04ld" : + ((parts[DUK_DATE_IDX_YEAR] >= 0) ? "+%06ld" : "%07ld"), + (long) parts[DUK_DATE_IDX_YEAR]); yearstr[sizeof(yearstr) - 1] = (char) 0; - if (flags & DUK__FLAG_LOCALTIME) { + if (flags & DUK_DATE_FLAG_LOCALTIME) { /* tzoffset seconds are dropped; 16 bits suffice for * time offset in minutes */ @@ -22018,19 +28644,19 @@ DUK_LOCAL void duk__format_parts_iso8601(duk_int_t *parts, duk_int_t tzoffset, d /* Unlike year, the other parts fit into 16 bits so %d format * is portable. */ - if ((flags & DUK__FLAG_TOSTRING_DATE) && (flags & DUK__FLAG_TOSTRING_TIME)) { + if ((flags & DUK_DATE_FLAG_TOSTRING_DATE) && (flags & DUK_DATE_FLAG_TOSTRING_TIME)) { DUK_SPRINTF((char *) out_buf, "%s-%02d-%02d%c%02d:%02d:%02d.%03d%s", - (const char *) yearstr, (int) parts[DUK__IDX_MONTH], (int) parts[DUK__IDX_DAY], (int) sep, - (int) parts[DUK__IDX_HOUR], (int) parts[DUK__IDX_MINUTE], - (int) parts[DUK__IDX_SECOND], (int) parts[DUK__IDX_MILLISECOND], (const char *) tzstr); - } else if (flags & DUK__FLAG_TOSTRING_DATE) { + (const char *) yearstr, (int) parts[DUK_DATE_IDX_MONTH], (int) parts[DUK_DATE_IDX_DAY], (int) sep, + (int) parts[DUK_DATE_IDX_HOUR], (int) parts[DUK_DATE_IDX_MINUTE], + (int) parts[DUK_DATE_IDX_SECOND], (int) parts[DUK_DATE_IDX_MILLISECOND], (const char *) tzstr); + } else if (flags & DUK_DATE_FLAG_TOSTRING_DATE) { DUK_SPRINTF((char *) out_buf, "%s-%02d-%02d", - (const char *) yearstr, (int) parts[DUK__IDX_MONTH], (int) parts[DUK__IDX_DAY]); + (const char *) yearstr, (int) parts[DUK_DATE_IDX_MONTH], (int) parts[DUK_DATE_IDX_DAY]); } else { - DUK_ASSERT(flags & DUK__FLAG_TOSTRING_TIME); + DUK_ASSERT(flags & DUK_DATE_FLAG_TOSTRING_TIME); DUK_SPRINTF((char *) out_buf, "%02d:%02d:%02d.%03d%s", - (int) parts[DUK__IDX_HOUR], (int) parts[DUK__IDX_MINUTE], - (int) parts[DUK__IDX_SECOND], (int) parts[DUK__IDX_MILLISECOND], + (int) parts[DUK_DATE_IDX_HOUR], (int) parts[DUK_DATE_IDX_MINUTE], + (int) parts[DUK_DATE_IDX_SECOND], (int) parts[DUK_DATE_IDX_MILLISECOND], (const char *) tzstr); } } @@ -22041,7 +28667,7 @@ DUK_LOCAL void duk__format_parts_iso8601(duk_int_t *parts, duk_int_t tzoffset, d */ DUK_LOCAL duk_ret_t duk__to_string_helper(duk_context *ctx, duk_small_uint_t flags) { duk_double_t d; - duk_int_t parts[DUK__NUM_PARTS]; + duk_int_t parts[DUK_DATE_IDX_NUM_PARTS]; duk_int_t tzoffset; /* seconds, doesn't fit into 16 bits */ duk_bool_t rc; duk_uint8_t buf[DUK_BI_DATE_ISO8601_BUFSIZE]; @@ -22056,17 +28682,22 @@ DUK_LOCAL duk_ret_t duk__to_string_helper(duk_context *ctx, duk_small_uint_t fla DUK_ASSERT(DUK_ISFINITE(d)); /* formatters always get one-based month/day-of-month */ - duk__timeval_to_parts(d, parts, NULL, DUK__FLAG_ONEBASED); - DUK_ASSERT(parts[DUK__IDX_MONTH] >= 1 && parts[DUK__IDX_MONTH] <= 12); - DUK_ASSERT(parts[DUK__IDX_DAY] >= 1 && parts[DUK__IDX_DAY] <= 31); + duk_bi_date_timeval_to_parts(d, parts, NULL, DUK_DATE_FLAG_ONEBASED); + DUK_ASSERT(parts[DUK_DATE_IDX_MONTH] >= 1 && parts[DUK_DATE_IDX_MONTH] <= 12); + DUK_ASSERT(parts[DUK_DATE_IDX_DAY] >= 1 && parts[DUK_DATE_IDX_DAY] <= 31); - if (flags & DUK__FLAG_TOSTRING_LOCALE) { + if (flags & DUK_DATE_FLAG_TOSTRING_LOCALE) { /* try locale specific formatter; if it refuses to format the * string, fall back to an ISO 8601 formatted value in local * time. */ -#ifdef DUK_USE_DATE_FMT_STRFTIME - rc = duk__format_parts_strftime(ctx, parts, tzoffset, flags); +#if defined(DUK_USE_DATE_FORMAT_STRING) + /* Contract, either: + * - Push string to value stack and return 1 + * - Don't push anything and return 0 + */ + + rc = DUK_USE_DATE_FORMAT_STRING(ctx, parts, tzoffset, flags); if (rc != 0) { return 1; } @@ -22088,15 +28719,15 @@ DUK_LOCAL duk_ret_t duk__to_string_helper(duk_context *ctx, duk_small_uint_t fla /* Helper for component getter calls: check 'this' binding, get the * internal time value, split it into parts (either as UTC time or * local time), push a specified component as a return value to the - * value stack and return 1 (caller can then tailcall us). + * value stack and return 1 (caller can then tail call us). */ DUK_LOCAL duk_ret_t duk__get_part_helper(duk_context *ctx, duk_small_uint_t flags_and_idx) { duk_double_t d; - duk_int_t parts[DUK__NUM_PARTS]; - duk_small_uint_t idx_part = (duk_small_uint_t) (flags_and_idx >> DUK__FLAG_VALUE_SHIFT); /* unpack args */ + duk_int_t parts[DUK_DATE_IDX_NUM_PARTS]; + duk_small_uint_t idx_part = (duk_small_uint_t) (flags_and_idx >> DUK_DATE_FLAG_VALUE_SHIFT); /* unpack args */ DUK_ASSERT_DISABLE(idx_part >= 0); /* unsigned */ - DUK_ASSERT(idx_part < DUK__NUM_PARTS); + DUK_ASSERT(idx_part < DUK_DATE_IDX_NUM_PARTS); d = duk__push_this_get_timeval(ctx, flags_and_idx); if (DUK_ISNAN(d)) { @@ -22105,13 +28736,13 @@ DUK_LOCAL duk_ret_t duk__get_part_helper(duk_context *ctx, duk_small_uint_t flag } DUK_ASSERT(DUK_ISFINITE(d)); - duk__timeval_to_parts(d, parts, NULL, flags_and_idx); /* no need to mask idx portion */ + duk_bi_date_timeval_to_parts(d, parts, NULL, flags_and_idx); /* no need to mask idx portion */ /* Setter APIs detect special year numbers (0...99) and apply a +1900 * only in certain cases. The legacy getYear() getter applies -1900 * unconditionally. */ - duk_push_int(ctx, (flags_and_idx & DUK__FLAG_SUB1900) ? parts[idx_part] - 1900 : parts[idx_part]); + duk_push_int(ctx, (flags_and_idx & DUK_DATE_FLAG_SUB1900) ? parts[idx_part] - 1900 : parts[idx_part]); return 1; } @@ -22120,14 +28751,14 @@ DUK_LOCAL duk_ret_t duk__get_part_helper(duk_context *ctx, duk_small_uint_t flag * local time), modify one or more components as specified, recompute * the time value, set it as the internal value. Finally, push the * new time value as a return value to the value stack and return 1 - * (caller can then tailcall us). + * (caller can then tail call us). */ DUK_LOCAL duk_ret_t duk__set_part_helper(duk_context *ctx, duk_small_uint_t flags_and_maxnargs) { duk_double_t d; - duk_int_t parts[DUK__NUM_PARTS]; - duk_double_t dparts[DUK__NUM_PARTS]; + duk_int_t parts[DUK_DATE_IDX_NUM_PARTS]; + duk_double_t dparts[DUK_DATE_IDX_NUM_PARTS]; duk_idx_t nargs; - duk_small_uint_t maxnargs = (duk_small_uint_t) (flags_and_maxnargs >> DUK__FLAG_VALUE_SHIFT); /* unpack args */ + duk_small_uint_t maxnargs = (duk_small_uint_t) (flags_and_maxnargs >> DUK_DATE_FLAG_VALUE_SHIFT); /* unpack args */ duk_small_uint_t idx_first, idx; duk_small_uint_t i; @@ -22136,7 +28767,7 @@ DUK_LOCAL duk_ret_t duk__set_part_helper(duk_context *ctx, duk_small_uint_t flag DUK_ASSERT(DUK_ISFINITE(d) || DUK_ISNAN(d)); if (DUK_ISFINITE(d)) { - duk__timeval_to_parts(d, parts, dparts, flags_and_maxnargs); + duk_bi_date_timeval_to_parts(d, parts, dparts, flags_and_maxnargs); } else { /* NaN timevalue: we need to coerce the arguments, but * the resulting internal timestamp needs to remain NaN. @@ -22150,7 +28781,7 @@ DUK_LOCAL duk_ret_t duk__set_part_helper(duk_context *ctx, duk_small_uint_t flag * stack arguments is a bit complicated, but important to factor * out from setters themselves for compactness. * - * If DUK__FLAG_TIMESETTER, maxnargs indicates setter type: + * If DUK_DATE_FLAG_TIMESETTER, maxnargs indicates setter type: * * 1 -> millisecond * 2 -> second, [millisecond] @@ -22167,15 +28798,15 @@ DUK_LOCAL duk_ret_t duk__set_part_helper(duk_context *ctx, duk_small_uint_t flag * components to override. We rely on part index ordering. */ - if (flags_and_maxnargs & DUK__FLAG_TIMESETTER) { + if (flags_and_maxnargs & DUK_DATE_FLAG_TIMESETTER) { DUK_ASSERT(maxnargs >= 1 && maxnargs <= 4); - idx_first = DUK__IDX_MILLISECOND - (maxnargs - 1); + idx_first = DUK_DATE_IDX_MILLISECOND - (maxnargs - 1); } else { DUK_ASSERT(maxnargs >= 1 && maxnargs <= 3); - idx_first = DUK__IDX_DAY - (maxnargs - 1); + idx_first = DUK_DATE_IDX_DAY - (maxnargs - 1); } DUK_ASSERT_DISABLE(idx_first >= 0); /* unsigned */ - DUK_ASSERT(idx_first < DUK__NUM_PARTS); + DUK_ASSERT(idx_first < DUK_DATE_IDX_NUM_PARTS); for (i = 0; i < maxnargs; i++) { if ((duk_idx_t) i >= nargs) { @@ -22184,15 +28815,15 @@ DUK_LOCAL duk_ret_t duk__set_part_helper(duk_context *ctx, duk_small_uint_t flag } idx = idx_first + i; DUK_ASSERT_DISABLE(idx >= 0); /* unsigned */ - DUK_ASSERT(idx < DUK__NUM_PARTS); + DUK_ASSERT(idx < DUK_DATE_IDX_NUM_PARTS); - if (idx == DUK__IDX_YEAR && (flags_and_maxnargs & DUK__FLAG_YEAR_FIXUP)) { + if (idx == DUK_DATE_IDX_YEAR && (flags_and_maxnargs & DUK_DATE_FLAG_YEAR_FIXUP)) { duk__twodigit_year_fixup(ctx, (duk_idx_t) i); } dparts[idx] = duk_to_number(ctx, i); - if (idx == DUK__IDX_DAY) { + if (idx == DUK_DATE_IDX_DAY) { /* Day-of-month is one-based in the API, but zero-based * internally, so fix here. Note that month is zero-based * both in the API and internally. @@ -22258,15 +28889,15 @@ DUK_LOCAL void duk__set_parts_from_args(duk_context *ctx, duk_double_t *dparts, duk__twodigit_year_fixup(ctx, 0); /* There are at most 7 args, but we use 8 here so that also - * DUK__IDX_WEEKDAY gets initialized (to zero) to avoid the potential + * DUK_DATE_IDX_WEEKDAY gets initialized (to zero) to avoid the potential * for any Valgrind gripes later. */ for (i = 0; i < 8; i++) { /* Note: rely on index ordering */ - idx = DUK__IDX_YEAR + i; + idx = DUK_DATE_IDX_YEAR + i; if ((duk_idx_t) i < nargs) { d = duk_to_number(ctx, (duk_idx_t) i); - if (idx == DUK__IDX_DAY) { + if (idx == DUK_DATE_IDX_DAY) { /* Convert day from one-based to zero-based (internal). This may * cause the day part to be negative, which is OK. */ @@ -22295,18 +28926,18 @@ DUK_LOCAL void duk__set_parts_from_args(duk_context *ctx, duk_double_t *dparts, */ DUK_INTERNAL void duk_bi_date_format_timeval(duk_double_t timeval, duk_uint8_t *out_buf) { - duk_int_t parts[DUK__NUM_PARTS]; + duk_int_t parts[DUK_DATE_IDX_NUM_PARTS]; - duk__timeval_to_parts(timeval, - parts, - NULL, - DUK__FLAG_ONEBASED); + duk_bi_date_timeval_to_parts(timeval, + parts, + NULL, + DUK_DATE_FLAG_ONEBASED); duk__format_parts_iso8601(parts, 0 /*tzoffset*/, - DUK__FLAG_TOSTRING_DATE | - DUK__FLAG_TOSTRING_TIME | - DUK__FLAG_SEP_T /*flags*/, + DUK_DATE_FLAG_TOSTRING_DATE | + DUK_DATE_FLAG_TOSTRING_TIME | + DUK_DATE_FLAG_SEP_T /*flags*/, out_buf); } @@ -22323,124 +28954,124 @@ DUK_INTERNAL void duk_bi_date_format_timeval(duk_double_t timeval, duk_uint8_t * static duk_uint16_t duk__date_magics[] = { /* 0: toString */ - DUK__FLAG_TOSTRING_DATE + DUK__FLAG_TOSTRING_TIME + DUK__FLAG_LOCALTIME, + DUK_DATE_FLAG_TOSTRING_DATE + DUK_DATE_FLAG_TOSTRING_TIME + DUK_DATE_FLAG_LOCALTIME, /* 1: toDateString */ - DUK__FLAG_TOSTRING_DATE + DUK__FLAG_LOCALTIME, + DUK_DATE_FLAG_TOSTRING_DATE + DUK_DATE_FLAG_LOCALTIME, /* 2: toTimeString */ - DUK__FLAG_TOSTRING_TIME + DUK__FLAG_LOCALTIME, + DUK_DATE_FLAG_TOSTRING_TIME + DUK_DATE_FLAG_LOCALTIME, /* 3: toLocaleString */ - DUK__FLAG_TOSTRING_DATE + DUK__FLAG_TOSTRING_TIME + DUK__FLAG_TOSTRING_LOCALE + DUK__FLAG_LOCALTIME, + DUK_DATE_FLAG_TOSTRING_DATE + DUK_DATE_FLAG_TOSTRING_TIME + DUK_DATE_FLAG_TOSTRING_LOCALE + DUK_DATE_FLAG_LOCALTIME, /* 4: toLocaleDateString */ - DUK__FLAG_TOSTRING_DATE + DUK__FLAG_TOSTRING_LOCALE + DUK__FLAG_LOCALTIME, + DUK_DATE_FLAG_TOSTRING_DATE + DUK_DATE_FLAG_TOSTRING_LOCALE + DUK_DATE_FLAG_LOCALTIME, /* 5: toLocaleTimeString */ - DUK__FLAG_TOSTRING_TIME + DUK__FLAG_TOSTRING_LOCALE + DUK__FLAG_LOCALTIME, + DUK_DATE_FLAG_TOSTRING_TIME + DUK_DATE_FLAG_TOSTRING_LOCALE + DUK_DATE_FLAG_LOCALTIME, /* 6: toUTCString */ - DUK__FLAG_TOSTRING_DATE + DUK__FLAG_TOSTRING_TIME, + DUK_DATE_FLAG_TOSTRING_DATE + DUK_DATE_FLAG_TOSTRING_TIME, /* 7: toISOString */ - DUK__FLAG_TOSTRING_DATE + DUK__FLAG_TOSTRING_TIME + DUK__FLAG_NAN_TO_RANGE_ERROR + DUK__FLAG_SEP_T, + DUK_DATE_FLAG_TOSTRING_DATE + DUK_DATE_FLAG_TOSTRING_TIME + DUK_DATE_FLAG_NAN_TO_RANGE_ERROR + DUK_DATE_FLAG_SEP_T, /* 8: getFullYear */ - DUK__FLAG_LOCALTIME + (DUK__IDX_YEAR << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_YEAR << DUK_DATE_FLAG_VALUE_SHIFT), /* 9: getUTCFullYear */ - 0 + (DUK__IDX_YEAR << DUK__FLAG_VALUE_SHIFT), + 0 + (DUK_DATE_IDX_YEAR << DUK_DATE_FLAG_VALUE_SHIFT), /* 10: getMonth */ - DUK__FLAG_LOCALTIME + (DUK__IDX_MONTH << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_MONTH << DUK_DATE_FLAG_VALUE_SHIFT), /* 11: getUTCMonth */ - 0 + (DUK__IDX_MONTH << DUK__FLAG_VALUE_SHIFT), + 0 + (DUK_DATE_IDX_MONTH << DUK_DATE_FLAG_VALUE_SHIFT), /* 12: getDate */ - DUK__FLAG_ONEBASED + DUK__FLAG_LOCALTIME + (DUK__IDX_DAY << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_ONEBASED + DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_DAY << DUK_DATE_FLAG_VALUE_SHIFT), /* 13: getUTCDate */ - DUK__FLAG_ONEBASED + (DUK__IDX_DAY << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_ONEBASED + (DUK_DATE_IDX_DAY << DUK_DATE_FLAG_VALUE_SHIFT), /* 14: getDay */ - DUK__FLAG_LOCALTIME + (DUK__IDX_WEEKDAY << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_WEEKDAY << DUK_DATE_FLAG_VALUE_SHIFT), /* 15: getUTCDay */ - 0 + (DUK__IDX_WEEKDAY << DUK__FLAG_VALUE_SHIFT), + 0 + (DUK_DATE_IDX_WEEKDAY << DUK_DATE_FLAG_VALUE_SHIFT), /* 16: getHours */ - DUK__FLAG_LOCALTIME + (DUK__IDX_HOUR << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_HOUR << DUK_DATE_FLAG_VALUE_SHIFT), /* 17: getUTCHours */ - 0 + (DUK__IDX_HOUR << DUK__FLAG_VALUE_SHIFT), + 0 + (DUK_DATE_IDX_HOUR << DUK_DATE_FLAG_VALUE_SHIFT), /* 18: getMinutes */ - DUK__FLAG_LOCALTIME + (DUK__IDX_MINUTE << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_MINUTE << DUK_DATE_FLAG_VALUE_SHIFT), /* 19: getUTCMinutes */ - 0 + (DUK__IDX_MINUTE << DUK__FLAG_VALUE_SHIFT), + 0 + (DUK_DATE_IDX_MINUTE << DUK_DATE_FLAG_VALUE_SHIFT), /* 20: getSeconds */ - DUK__FLAG_LOCALTIME + (DUK__IDX_SECOND << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_SECOND << DUK_DATE_FLAG_VALUE_SHIFT), /* 21: getUTCSeconds */ - 0 + (DUK__IDX_SECOND << DUK__FLAG_VALUE_SHIFT), + 0 + (DUK_DATE_IDX_SECOND << DUK_DATE_FLAG_VALUE_SHIFT), /* 22: getMilliseconds */ - DUK__FLAG_LOCALTIME + (DUK__IDX_MILLISECOND << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_LOCALTIME + (DUK_DATE_IDX_MILLISECOND << DUK_DATE_FLAG_VALUE_SHIFT), /* 23: getUTCMilliseconds */ - 0 + (DUK__IDX_MILLISECOND << DUK__FLAG_VALUE_SHIFT), + 0 + (DUK_DATE_IDX_MILLISECOND << DUK_DATE_FLAG_VALUE_SHIFT), /* 24: setMilliseconds */ - DUK__FLAG_TIMESETTER + DUK__FLAG_LOCALTIME + (1 << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_TIMESETTER + DUK_DATE_FLAG_LOCALTIME + (1 << DUK_DATE_FLAG_VALUE_SHIFT), /* 25: setUTCMilliseconds */ - DUK__FLAG_TIMESETTER + (1 << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_TIMESETTER + (1 << DUK_DATE_FLAG_VALUE_SHIFT), /* 26: setSeconds */ - DUK__FLAG_TIMESETTER + DUK__FLAG_LOCALTIME + (2 << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_TIMESETTER + DUK_DATE_FLAG_LOCALTIME + (2 << DUK_DATE_FLAG_VALUE_SHIFT), /* 27: setUTCSeconds */ - DUK__FLAG_TIMESETTER + (2 << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_TIMESETTER + (2 << DUK_DATE_FLAG_VALUE_SHIFT), /* 28: setMinutes */ - DUK__FLAG_TIMESETTER + DUK__FLAG_LOCALTIME + (3 << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_TIMESETTER + DUK_DATE_FLAG_LOCALTIME + (3 << DUK_DATE_FLAG_VALUE_SHIFT), /* 29: setUTCMinutes */ - DUK__FLAG_TIMESETTER + (3 << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_TIMESETTER + (3 << DUK_DATE_FLAG_VALUE_SHIFT), /* 30: setHours */ - DUK__FLAG_TIMESETTER + DUK__FLAG_LOCALTIME + (4 << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_TIMESETTER + DUK_DATE_FLAG_LOCALTIME + (4 << DUK_DATE_FLAG_VALUE_SHIFT), /* 31: setUTCHours */ - DUK__FLAG_TIMESETTER + (4 << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_TIMESETTER + (4 << DUK_DATE_FLAG_VALUE_SHIFT), /* 32: setDate */ - DUK__FLAG_LOCALTIME + (1 << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_LOCALTIME + (1 << DUK_DATE_FLAG_VALUE_SHIFT), /* 33: setUTCDate */ - 0 + (1 << DUK__FLAG_VALUE_SHIFT), + 0 + (1 << DUK_DATE_FLAG_VALUE_SHIFT), /* 34: setMonth */ - DUK__FLAG_LOCALTIME + (2 << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_LOCALTIME + (2 << DUK_DATE_FLAG_VALUE_SHIFT), /* 35: setUTCMonth */ - 0 + (2 << DUK__FLAG_VALUE_SHIFT), + 0 + (2 << DUK_DATE_FLAG_VALUE_SHIFT), /* 36: setFullYear */ - DUK__FLAG_NAN_TO_ZERO + DUK__FLAG_LOCALTIME + (3 << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_NAN_TO_ZERO + DUK_DATE_FLAG_LOCALTIME + (3 << DUK_DATE_FLAG_VALUE_SHIFT), /* 37: setUTCFullYear */ - DUK__FLAG_NAN_TO_ZERO + (3 << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_NAN_TO_ZERO + (3 << DUK_DATE_FLAG_VALUE_SHIFT), /* 38: getYear */ - DUK__FLAG_LOCALTIME + DUK__FLAG_SUB1900 + (DUK__IDX_YEAR << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_LOCALTIME + DUK_DATE_FLAG_SUB1900 + (DUK_DATE_IDX_YEAR << DUK_DATE_FLAG_VALUE_SHIFT), /* 39: setYear */ - DUK__FLAG_NAN_TO_ZERO + DUK__FLAG_YEAR_FIXUP + (3 << DUK__FLAG_VALUE_SHIFT), + DUK_DATE_FLAG_NAN_TO_ZERO + DUK_DATE_FLAG_YEAR_FIXUP + (3 << DUK_DATE_FLAG_VALUE_SHIFT), }; DUK_LOCAL duk_small_uint_t duk__date_get_indirect_magic(duk_context *ctx) { @@ -22456,7 +29087,7 @@ DUK_LOCAL duk_small_uint_t duk__date_get_indirect_magic(duk_context *ctx) { DUK_INTERNAL duk_ret_t duk_bi_date_constructor(duk_context *ctx) { duk_idx_t nargs = duk_get_top(ctx); duk_bool_t is_cons = duk_is_constructor_call(ctx); - duk_double_t dparts[DUK__NUM_PARTS]; + duk_double_t dparts[DUK_DATE_IDX_NUM_PARTS]; duk_double_t d; DUK_DDD(DUK_DDDPRINT("Date constructor, nargs=%ld, is_cons=%ld", (long) nargs, (long) is_cons)); @@ -22471,7 +29102,7 @@ DUK_INTERNAL duk_ret_t duk_bi_date_constructor(duk_context *ctx) { */ if (nargs == 0 || !is_cons) { - d = duk__timeclip(DUK__GET_NOW_TIMEVAL(ctx)); + d = duk__timeclip(DUK_USE_DATE_GET_NOW(ctx)); duk_push_number(ctx, d); duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_W); if (!is_cons) { @@ -22495,7 +29126,7 @@ DUK_INTERNAL duk_ret_t duk_bi_date_constructor(duk_context *ctx) { /* Parts are in local time, convert when setting. */ - (void) duk__set_this_timeval_from_dparts(ctx, dparts, DUK__FLAG_LOCALTIME /*flags*/); /* -> [ ... this timeval ] */ + (void) duk__set_this_timeval_from_dparts(ctx, dparts, DUK_DATE_FLAG_LOCALTIME /*flags*/); /* -> [ ... this timeval ] */ duk_pop(ctx); /* -> [ ... this ] */ return 1; } @@ -22506,7 +29137,7 @@ DUK_INTERNAL duk_ret_t duk_bi_date_constructor_parse(duk_context *ctx) { DUK_INTERNAL duk_ret_t duk_bi_date_constructor_utc(duk_context *ctx) { duk_idx_t nargs = duk_get_top(ctx); - duk_double_t dparts[DUK__NUM_PARTS]; + duk_double_t dparts[DUK_DATE_IDX_NUM_PARTS]; duk_double_t d; /* Behavior for nargs < 2 is implementation dependent: currently we'll @@ -22517,7 +29148,7 @@ DUK_INTERNAL duk_ret_t duk_bi_date_constructor_utc(duk_context *ctx) { duk_push_nan(ctx); } else { duk__set_parts_from_args(ctx, dparts, nargs); - d = duk__get_timeval_from_dparts(dparts, 0 /*flags*/); + d = duk_bi_date_get_timeval_from_dparts(dparts, 0 /*flags*/); duk_push_number(ctx, d); } return 1; @@ -22526,7 +29157,7 @@ DUK_INTERNAL duk_ret_t duk_bi_date_constructor_utc(duk_context *ctx) { DUK_INTERNAL duk_ret_t duk_bi_date_constructor_now(duk_context *ctx) { duk_double_t d; - d = DUK__GET_NOW_TIMEVAL(ctx); + d = DUK_USE_DATE_GET_NOW(ctx); DUK_ASSERT(duk__timeclip(d) == d); /* TimeClip() should never be necessary */ duk_push_number(ctx, d); return 1; @@ -22678,7 +29309,7 @@ DUK_INTERNAL duk_ret_t duk_bi_date_prototype_get_timezone_offset(duk_context *ct duk_push_nan(ctx); } else { DUK_ASSERT(DUK_ISFINITE(d)); - tzoffset = DUK__GET_LOCAL_TZOFFSET(d); + tzoffset = DUK_USE_DATE_GET_LOCAL_TZOFFSET(d); duk_push_int(ctx, -tzoffset / 60); } return 1; @@ -22749,6 +29380,417 @@ DUK_INTERNAL duk_ret_t duk_bi_date_prototype_set_time(duk_context *ctx) { return 1; } +#line 1 "duk_bi_date_unix.c" +/* + * Unix-like Date providers + * + * Generally useful Unix / POSIX / ANSI Date providers. + */ + +/* include removed: duk_internal.h */ + +/* The necessary #includes are in place in duk_config.h. */ + +/* Buffer sizes for some UNIX calls. Larger than strictly necessary + * to avoid Valgrind errors. + */ +#define DUK__STRPTIME_BUF_SIZE 64 +#define DUK__STRFTIME_BUF_SIZE 64 + +#if defined(DUK_USE_DATE_NOW_GETTIMEOFDAY) +/* Get current Ecmascript time (= UNIX/Posix time, but in milliseconds). */ +DUK_INTERNAL duk_double_t duk_bi_date_get_now_gettimeofday(duk_context *ctx) { + duk_hthread *thr = (duk_hthread *) ctx; + struct timeval tv; + duk_double_t d; + + if (gettimeofday(&tv, NULL) != 0) { + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, "gettimeofday failed"); + } + + d = ((duk_double_t) tv.tv_sec) * 1000.0 + + ((duk_double_t) (tv.tv_usec / 1000)); + DUK_ASSERT(DUK_FLOOR(d) == d); /* no fractions */ + + return d; +} +#endif /* DUK_USE_DATE_NOW_GETTIMEOFDAY */ + +#if defined(DUK_USE_DATE_NOW_TIME) +/* Not a very good provider: only full seconds are available. */ +DUK_INTERNAL duk_double_t duk_bi_date_get_now_time(duk_context *ctx) { + time_t t; + + DUK_UNREF(ctx); + t = time(NULL); + return ((duk_double_t) t) * 1000.0; +} +#endif /* DUK_USE_DATE_NOW_TIME */ + +#if defined(DUK_USE_DATE_TZO_GMTIME) || defined(DUK_USE_DATE_TZO_GMTIME_R) +/* Get local time offset (in seconds) for a certain (UTC) instant 'd'. */ +DUK_INTERNAL duk_int_t duk_bi_date_get_local_tzoffset_gmtime(duk_double_t d) { + time_t t, t1, t2; + duk_int_t parts[DUK_DATE_IDX_NUM_PARTS]; + duk_double_t dparts[DUK_DATE_IDX_NUM_PARTS]; + struct tm tms[2]; +#ifdef DUK_USE_DATE_TZO_GMTIME + struct tm *tm_ptr; +#endif + + /* For NaN/inf, the return value doesn't matter. */ + if (!DUK_ISFINITE(d)) { + return 0; + } + + /* If not within Ecmascript range, some integer time calculations + * won't work correctly (and some asserts will fail), so bail out + * if so. This fixes test-bug-date-insane-setyear.js. There is + * a +/- 24h leeway in this range check to avoid a test262 corner + * case documented in test-bug-date-timeval-edges.js. + */ + if (!duk_bi_date_timeval_in_leeway_range(d)) { + DUK_DD(DUK_DDPRINT("timeval not within valid range, skip tzoffset computation to avoid integer overflows")); + return 0; + } + + /* + * This is a bit tricky to implement portably. The result depends + * on the timestamp (specifically, DST depends on the timestamp). + * If e.g. UNIX APIs are used, they'll have portability issues with + * very small and very large years. + * + * Current approach: + * + * - Stay within portable UNIX limits by using equivalent year mapping. + * Avoid year 1970 and 2038 as some conversions start to fail, at + * least on some platforms. Avoiding 1970 means that there are + * currently DST discrepancies for 1970. + * + * - Create a UTC and local time breakdowns from 't'. Then create + * a time_t using gmtime() and localtime() and compute the time + * difference between the two. + * + * Equivalent year mapping (E5 Section 15.9.1.8): + * + * If the host environment provides functionality for determining + * daylight saving time, the implementation of ECMAScript is free + * to map the year in question to an equivalent year (same + * leap-year-ness and same starting week day for the year) for which + * the host environment provides daylight saving time information. + * The only restriction is that all equivalent years should produce + * the same result. + * + * This approach is quite reasonable but not entirely correct, e.g. + * the specification also states (E5 Section 15.9.1.8): + * + * The implementation of ECMAScript should not try to determine + * whether the exact time was subject to daylight saving time, but + * just whether daylight saving time would have been in effect if + * the _current daylight saving time algorithm_ had been used at the + * time. This avoids complications such as taking into account the + * years that the locale observed daylight saving time year round. + * + * Since we rely on the platform APIs for conversions between local + * time and UTC, we can't guarantee the above. Rather, if the platform + * has historical DST rules they will be applied. This seems to be the + * general preferred direction in Ecmascript standardization (or at least + * implementations) anyway, and even the equivalent year mapping should + * be disabled if the platform is known to handle DST properly for the + * full Ecmascript range. + * + * The following has useful discussion and links: + * + * https://bugzilla.mozilla.org/show_bug.cgi?id=351066 + */ + + duk_bi_date_timeval_to_parts(d, parts, dparts, DUK_DATE_FLAG_EQUIVYEAR /*flags*/); + DUK_ASSERT(parts[DUK_DATE_IDX_YEAR] >= 1970 && parts[DUK_DATE_IDX_YEAR] <= 2038); + + d = duk_bi_date_get_timeval_from_dparts(dparts, 0 /*flags*/); + DUK_ASSERT(d >= 0 && d < 2147483648.0 * 1000.0); /* unsigned 31-bit range */ + t = (time_t) (d / 1000.0); + DUK_DDD(DUK_DDDPRINT("timeval: %lf -> time_t %ld", (double) d, (long) t)); + + t1 = t; + + DUK_MEMZERO((void *) tms, sizeof(struct tm) * 2); + +#if defined(DUK_USE_DATE_TZO_GMTIME_R) + (void) gmtime_r(&t, &tms[0]); + (void) localtime_r(&t, &tms[1]); +#elif defined(DUK_USE_DATE_TZO_GMTIME) + tm_ptr = gmtime(&t); + DUK_MEMCPY((void *) &tms[0], tm_ptr, sizeof(struct tm)); + tm_ptr = localtime(&t); + DUK_MEMCPY((void *) &tms[1], tm_ptr, sizeof(struct tm)); +#else +#error internal error +#endif + DUK_DDD(DUK_DDDPRINT("gmtime result: tm={sec:%ld,min:%ld,hour:%ld,mday:%ld,mon:%ld,year:%ld," + "wday:%ld,yday:%ld,isdst:%ld}", + (long) tms[0].tm_sec, (long) tms[0].tm_min, (long) tms[0].tm_hour, + (long) tms[0].tm_mday, (long) tms[0].tm_mon, (long) tms[0].tm_year, + (long) tms[0].tm_wday, (long) tms[0].tm_yday, (long) tms[0].tm_isdst)); + DUK_DDD(DUK_DDDPRINT("localtime result: tm={sec:%ld,min:%ld,hour:%ld,mday:%ld,mon:%ld,year:%ld," + "wday:%ld,yday:%ld,isdst:%ld}", + (long) tms[1].tm_sec, (long) tms[1].tm_min, (long) tms[1].tm_hour, + (long) tms[1].tm_mday, (long) tms[1].tm_mon, (long) tms[1].tm_year, + (long) tms[1].tm_wday, (long) tms[1].tm_yday, (long) tms[1].tm_isdst)); + + /* tm_isdst is both an input and an output to mktime(), use 0 to + * avoid DST handling in mktime(): + * - https://github.com/svaarala/duktape/issues/406 + * - http://stackoverflow.com/questions/8558919/mktime-and-tm-isdst + */ + tms[0].tm_isdst = 0; + tms[1].tm_isdst = 0; + t1 = mktime(&tms[0]); /* UTC */ + t2 = mktime(&tms[1]); /* local */ + if (t1 == (time_t) -1 || t2 == (time_t) -1) { + /* This check used to be for (t < 0) but on some platforms + * time_t is unsigned and apparently the proper way to detect + * an mktime() error return is the cast above. See e.g.: + * http://pubs.opengroup.org/onlinepubs/009695299/functions/mktime.html + */ + goto error; + } + DUK_DDD(DUK_DDDPRINT("t1=%ld (utc), t2=%ld (local)", (long) t1, (long) t2)); + + /* Compute final offset in seconds, positive if local time ahead of + * UTC (returned value is UTC-to-local offset). + * + * difftime() returns a double, so coercion to int generates quite + * a lot of code. Direct subtraction is not portable, however. + * XXX: allow direct subtraction on known platforms. + */ +#if 0 + return (duk_int_t) (t2 - t1); +#endif + return (duk_int_t) difftime(t2, t1); + + error: + /* XXX: return something more useful, so that caller can throw? */ + DUK_D(DUK_DPRINT("mktime() failed, d=%lf", (double) d)); + return 0; +} +#endif /* DUK_USE_DATE_TZO_GMTIME */ + +#if defined(DUK_USE_DATE_PRS_STRPTIME) +DUK_INTERNAL duk_bool_t duk_bi_date_parse_string_strptime(duk_context *ctx, const char *str) { + struct tm tm; + time_t t; + char buf[DUK__STRPTIME_BUF_SIZE]; + + /* copy to buffer with spare to avoid Valgrind gripes from strptime */ + DUK_ASSERT(str != NULL); + DUK_MEMZERO(buf, sizeof(buf)); /* valgrind whine without this */ + DUK_SNPRINTF(buf, sizeof(buf), "%s", (const char *) str); + buf[sizeof(buf) - 1] = (char) 0; + + DUK_DDD(DUK_DDDPRINT("parsing: '%s'", (const char *) buf)); + + DUK_MEMZERO(&tm, sizeof(tm)); + if (strptime((const char *) buf, "%c", &tm) != NULL) { + DUK_DDD(DUK_DDDPRINT("before mktime: tm={sec:%ld,min:%ld,hour:%ld,mday:%ld,mon:%ld,year:%ld," + "wday:%ld,yday:%ld,isdst:%ld}", + (long) tm.tm_sec, (long) tm.tm_min, (long) tm.tm_hour, + (long) tm.tm_mday, (long) tm.tm_mon, (long) tm.tm_year, + (long) tm.tm_wday, (long) tm.tm_yday, (long) tm.tm_isdst)); + tm.tm_isdst = -1; /* negative: dst info not available */ + + t = mktime(&tm); + DUK_DDD(DUK_DDDPRINT("mktime() -> %ld", (long) t)); + if (t >= 0) { + duk_push_number(ctx, ((duk_double_t) t) * 1000.0); + return 1; + } + } + + return 0; +} +#endif /* DUK_USE_DATE_PRS_STRPTIME */ + +#if defined(DUK_USE_DATE_PRS_GETDATE) +DUK_INTERNAL duk_bool_t duk_bi_date_parse_string_getdate(duk_context *ctx, const char *str) { + struct tm tm; + duk_small_int_t rc; + time_t t; + + /* For this to work, DATEMSK must be set, so this is not very + * convenient for an embeddable interpreter. + */ + + DUK_MEMZERO(&tm, sizeof(struct tm)); + rc = (duk_small_int_t) getdate_r(str, &tm); + DUK_DDD(DUK_DDDPRINT("getdate_r() -> %ld", (long) rc)); + + if (rc == 0) { + t = mktime(&tm); + DUK_DDD(DUK_DDDPRINT("mktime() -> %ld", (long) t)); + if (t >= 0) { + duk_push_number(ctx, (duk_double_t) t); + return 1; + } + } + + return 0; +} +#endif /* DUK_USE_DATE_PRS_GETDATE */ + +#if defined(DUK_USE_DATE_FMT_STRFTIME) +DUK_INTERNAL duk_bool_t duk_bi_date_format_parts_strftime(duk_context *ctx, duk_int_t *parts, duk_int_t tzoffset, duk_small_uint_t flags) { + char buf[DUK__STRFTIME_BUF_SIZE]; + struct tm tm; + const char *fmt; + + DUK_UNREF(tzoffset); + + /* If the platform doesn't support the entire Ecmascript range, we need + * to return 0 so that the caller can fall back to the default formatter. + * + * For now, assume that if time_t is 8 bytes or more, the whole Ecmascript + * range is supported. For smaller time_t values (4 bytes in practice), + * assumes that the signed 32-bit range is supported. + * + * XXX: detect this more correctly per platform. The size of time_t is + * probably not an accurate guarantee of strftime() supporting or not + * supporting a large time range (the full Ecmascript range). + */ + if (sizeof(time_t) < 8 && + (parts[DUK_DATE_IDX_YEAR] < 1970 || parts[DUK_DATE_IDX_YEAR] > 2037)) { + /* be paranoid for 32-bit time values (even avoiding negative ones) */ + return 0; + } + + DUK_MEMZERO(&tm, sizeof(tm)); + tm.tm_sec = parts[DUK_DATE_IDX_SECOND]; + tm.tm_min = parts[DUK_DATE_IDX_MINUTE]; + tm.tm_hour = parts[DUK_DATE_IDX_HOUR]; + tm.tm_mday = parts[DUK_DATE_IDX_DAY]; /* already one-based */ + tm.tm_mon = parts[DUK_DATE_IDX_MONTH] - 1; /* one-based -> zero-based */ + tm.tm_year = parts[DUK_DATE_IDX_YEAR] - 1900; + tm.tm_wday = parts[DUK_DATE_IDX_WEEKDAY]; + tm.tm_isdst = 0; + + DUK_MEMZERO(buf, sizeof(buf)); + if ((flags & DUK_DATE_FLAG_TOSTRING_DATE) && (flags & DUK_DATE_FLAG_TOSTRING_TIME)) { + fmt = "%c"; + } else if (flags & DUK_DATE_FLAG_TOSTRING_DATE) { + fmt = "%x"; + } else { + DUK_ASSERT(flags & DUK_DATE_FLAG_TOSTRING_TIME); + fmt = "%X"; + } + (void) strftime(buf, sizeof(buf) - 1, fmt, &tm); + DUK_ASSERT(buf[sizeof(buf) - 1] == 0); + + duk_push_string(ctx, buf); + return 1; +} +#endif /* DUK_USE_DATE_FMT_STRFTIME */ + +#undef DUK__STRPTIME_BUF_SIZE +#undef DUK__STRFTIME_BUF_SIZE +#line 1 "duk_bi_date_windows.c" +/* + * Windows Date providers + * + * Platform specific links: + * + * - http://msdn.microsoft.com/en-us/library/windows/desktop/ms725473(v=vs.85).aspx + */ + +/* include removed: duk_internal.h */ + +/* The necessary #includes are in place in duk_config.h. */ + +#if defined(DUK_USE_DATE_NOW_WINDOWS) || defined(DUK_USE_DATE_TZO_WINDOWS) +/* Shared Windows helpers. */ +DUK_LOCAL void duk__convert_systime_to_ularge(const SYSTEMTIME *st, ULARGE_INTEGER *res) { + FILETIME ft; + if (SystemTimeToFileTime(st, &ft) == 0) { + DUK_D(DUK_DPRINT("SystemTimeToFileTime() failed, returning 0")); + res->QuadPart = 0; + } else { + res->LowPart = ft.dwLowDateTime; + res->HighPart = ft.dwHighDateTime; + } +} +DUK_LOCAL void duk__set_systime_jan1970(SYSTEMTIME *st) { + DUK_MEMZERO((void *) st, sizeof(*st)); + st->wYear = 1970; + st->wMonth = 1; + st->wDayOfWeek = 4; /* not sure whether or not needed; Thursday */ + st->wDay = 1; + DUK_ASSERT(st->wHour == 0); + DUK_ASSERT(st->wMinute == 0); + DUK_ASSERT(st->wSecond == 0); + DUK_ASSERT(st->wMilliseconds == 0); +} +#endif /* defined(DUK_USE_DATE_NOW_WINDOWS) || defined(DUK_USE_DATE_TZO_WINDOWS) */ + +#ifdef DUK_USE_DATE_NOW_WINDOWS +DUK_INTERNAL duk_double_t duk_bi_date_get_now_windows(duk_context *ctx) { + /* Suggested step-by-step method from documentation of RtlTimeToSecondsSince1970: + * http://msdn.microsoft.com/en-us/library/windows/desktop/ms724928(v=vs.85).aspx + */ + SYSTEMTIME st1, st2; + ULARGE_INTEGER tmp1, tmp2; + + DUK_UNREF(ctx); + + GetSystemTime(&st1); + duk__convert_systime_to_ularge((const SYSTEMTIME *) &st1, &tmp1); + + duk__set_systime_jan1970(&st2); + duk__convert_systime_to_ularge((const SYSTEMTIME *) &st2, &tmp2); + + /* Difference is in 100ns units, convert to milliseconds w/o fractions */ + return (duk_double_t) ((tmp1.QuadPart - tmp2.QuadPart) / 10000LL); +} +#endif /* DUK_USE_DATE_NOW_WINDOWS */ + + +#if defined(DUK_USE_DATE_TZO_WINDOWS) +DUK_INTERNAL_DECL duk_int_t duk_bi_date_get_local_tzoffset_windows(duk_double_t d) { + SYSTEMTIME st1; + SYSTEMTIME st2; + SYSTEMTIME st3; + ULARGE_INTEGER tmp1; + ULARGE_INTEGER tmp2; + ULARGE_INTEGER tmp3; + FILETIME ft1; + + /* XXX: handling of timestamps outside Windows supported range. + * How does Windows deal with dates before 1600? Does windows + * support all Ecmascript years (like -200000 and +200000)? + * Should equivalent year mapping be used here too? If so, use + * a shared helper (currently integrated into timeval-to-parts). + */ + + /* Use the approach described in "Remarks" of FileTimeToLocalFileTime: + * http://msdn.microsoft.com/en-us/library/windows/desktop/ms724277(v=vs.85).aspx + */ + + duk__set_systime_jan1970(&st1); + duk__convert_systime_to_ularge((const SYSTEMTIME *) &st1, &tmp1); + tmp2.QuadPart = (ULONGLONG) (d * 10000.0); /* millisec -> 100ns units since jan 1, 1970 */ + tmp2.QuadPart += tmp1.QuadPart; /* input 'd' in Windows UTC, 100ns units */ + + ft1.dwLowDateTime = tmp2.LowPart; + ft1.dwHighDateTime = tmp2.HighPart; + FileTimeToSystemTime((const FILETIME *) &ft1, &st2); + if (SystemTimeToTzSpecificLocalTime((LPTIME_ZONE_INFORMATION) NULL, &st2, &st3) == 0) { + DUK_D(DUK_DPRINT("SystemTimeToTzSpecificLocalTime() failed, return tzoffset 0")); + return 0; + } + duk__convert_systime_to_ularge((const SYSTEMTIME *) &st3, &tmp3); + + /* Positive if local time ahead of UTC. */ + return (duk_int_t) (((LONGLONG) tmp3.QuadPart - (LONGLONG) tmp2.QuadPart) / 10000000LL); /* seconds */ +} +#endif /* DUK_USE_DATE_TZO_WINDOWS */ #line 1 "duk_bi_duktape.c" /* * Duktape built-ins @@ -22850,12 +29892,15 @@ DUK_INTERNAL duk_ret_t duk_bi_duktape_object_info(duk_context *ctx) { case DUK_HTYPE_BUFFER: { duk_hbuffer *h_buf = (duk_hbuffer *) h; if (DUK_HBUFFER_HAS_DYNAMIC(h_buf)) { - /* XXX: when alloc_size == 0, dynamic buf ptr may now be NULL, in which case - * the second allocation does not exist. - */ - duk_hbuffer_dynamic *h_dyn = (duk_hbuffer_dynamic *) h; - duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hbuffer_dynamic))); - duk_push_uint(ctx, (duk_uint_t) (DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(h_dyn))); + if (DUK_HBUFFER_HAS_EXTERNAL(h_buf)) { + duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hbuffer_external))); + } else { + /* When alloc_size == 0 the second allocation may not + * actually exist. + */ + duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hbuffer_dynamic))); + } + duk_push_uint(ctx, (duk_uint_t) (DUK_HBUFFER_GET_SIZE(h_buf))); } else { duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hbuffer_fixed) + DUK_HBUFFER_GET_SIZE(h_buf) + 1)); } @@ -22897,14 +29942,11 @@ DUK_INTERNAL duk_ret_t duk_bi_duktape_object_act(duk_context *ctx) { duk_push_tval(ctx, &act->tv_func); - pc = (duk_uint_fast32_t) act->pc; - if (pc > 0) { - /* Relevant PC is just before current one because PC is - * post-incremented. This should match what error augment - * code does. - */ - pc--; - } + /* Relevant PC is just before current one because PC is + * post-incremented. This should match what error augment + * code does. + */ + pc = duk_hthread_get_act_prev_pc(thr, act); duk_push_uint(ctx, (duk_uint_t) pc); #if defined(DUK_USE_PC2LINE) @@ -23159,7 +30201,7 @@ DUK_INTERNAL duk_ret_t duk_bi_error_prototype_to_string(duk_context *ctx) { return 1; } -#ifdef DUK_USE_TRACEBACKS +#if defined(DUK_USE_TRACEBACKS) /* * Traceback handling @@ -23180,11 +30222,12 @@ DUK_INTERNAL duk_ret_t duk_bi_error_prototype_to_string(duk_context *ctx) { #define DUK__OUTPUT_TYPE_FILENAME 0 #define DUK__OUTPUT_TYPE_LINENUMBER 1 -DUK_LOCAL duk_ret_t duk__traceback_getter_helper(duk_context *ctx, duk_small_int_t output_type) { +DUK_LOCAL duk_ret_t duk__error_getter_helper(duk_context *ctx, duk_small_int_t output_type) { duk_hthread *thr = (duk_hthread *) ctx; duk_idx_t idx_td; duk_small_int_t i; /* traceback depth fits into 16 bits */ duk_small_int_t t; /* stack type fits into 16 bits */ + duk_small_int_t count_func = 0; /* traceback depth ensures fits into 16 bits */ const char *str_tailcalled = " tailcalled"; const char *str_strict = " strict"; const char *str_construct = " construct"; @@ -23200,9 +30243,8 @@ DUK_LOCAL duk_ret_t duk__traceback_getter_helper(duk_context *ctx, duk_small_int duk_push_hstring_stridx(ctx, DUK_STRIDX_NEWLINE_TAB); duk_push_this(ctx); - duk_to_string(ctx, -1); - /* [ ... this tracedata sep ToString(this) ] */ + /* [ ... this tracedata sep this ] */ /* XXX: skip null filename? */ @@ -23231,6 +30273,8 @@ DUK_LOCAL duk_ret_t duk__traceback_getter_helper(duk_context *ctx, duk_small_int * Ecmascript/native function call or lightfunc call */ + count_func++; + /* [ ... v1(func) v2(pc+flags) ] */ h_func = duk_get_hobject(ctx, -2); /* NULL for lightfunc */ @@ -23246,11 +30290,16 @@ DUK_LOCAL duk_ret_t duk__traceback_getter_helper(duk_context *ctx, duk_small_int /* [ ... v1 v2 name filename ] */ - if (output_type == DUK__OUTPUT_TYPE_FILENAME) { - return 1; - } else if (output_type == DUK__OUTPUT_TYPE_LINENUMBER) { - duk_push_int(ctx, line); - return 1; + /* When looking for .fileName/.lineNumber, blame first + * function which has a .fileName. + */ + if (duk_is_string(ctx, -1)) { + if (output_type == DUK__OUTPUT_TYPE_FILENAME) { + return 1; + } else if (output_type == DUK__OUTPUT_TYPE_LINENUMBER) { + duk_push_int(ctx, line); + return 1; + } } h_name = duk_get_hstring(ctx, -2); /* may be NULL */ @@ -23300,6 +30349,9 @@ DUK_LOCAL duk_ret_t duk__traceback_getter_helper(duk_context *ctx, duk_small_int /* [ ... v1(filename) v2(line+flags) ] */ + /* When looking for .fileName/.lineNumber, blame compilation + * or C call site unless flagged not to do so. + */ if (!(flags & DUK_TB_FLAG_NOBLAME_FILELINE)) { if (output_type == DUK__OUTPUT_TYPE_FILENAME) { duk_pop(ctx); @@ -23321,7 +30373,7 @@ DUK_LOCAL duk_ret_t duk__traceback_getter_helper(duk_context *ctx, duk_small_int } } - if (i >= DUK_USE_TRACEBACK_DEPTH * 2) { + if (count_func >= DUK_USE_TRACEBACK_DEPTH) { /* Possibly truncated; there is no explicit truncation * marker so this is the best we can do. */ @@ -23330,30 +30382,34 @@ DUK_LOCAL duk_ret_t duk__traceback_getter_helper(duk_context *ctx, duk_small_int } } - /* [ ... this tracedata sep ToString(this) str1 ... strN ] */ + /* [ ... this tracedata sep this str1 ... strN ] */ if (output_type != DUK__OUTPUT_TYPE_TRACEBACK) { return 0; } else { + /* The 'this' after 'sep' will get ToString() coerced by + * duk_join() automatically. We don't want to do that + * coercion when providing .fileName or .lineNumber (GH-254). + */ duk_join(ctx, duk_get_top(ctx) - (idx_td + 2) /*count, not including sep*/); return 1; } } -/* XXX: output type could be encoded into native function 'magic' value to - * save space. +/* XXX: Output type could be encoded into native function 'magic' value to + * save space. For setters the stridx could be encoded into 'magic'. */ DUK_INTERNAL duk_ret_t duk_bi_error_prototype_stack_getter(duk_context *ctx) { - return duk__traceback_getter_helper(ctx, DUK__OUTPUT_TYPE_TRACEBACK); + return duk__error_getter_helper(ctx, DUK__OUTPUT_TYPE_TRACEBACK); } DUK_INTERNAL duk_ret_t duk_bi_error_prototype_filename_getter(duk_context *ctx) { - return duk__traceback_getter_helper(ctx, DUK__OUTPUT_TYPE_FILENAME); + return duk__error_getter_helper(ctx, DUK__OUTPUT_TYPE_FILENAME); } DUK_INTERNAL duk_ret_t duk_bi_error_prototype_linenumber_getter(duk_context *ctx) { - return duk__traceback_getter_helper(ctx, DUK__OUTPUT_TYPE_LINENUMBER); + return duk__error_getter_helper(ctx, DUK__OUTPUT_TYPE_LINENUMBER); } #undef DUK__OUTPUT_TYPE_TRACEBACK @@ -23393,14 +30449,43 @@ DUK_INTERNAL duk_ret_t duk_bi_error_prototype_linenumber_getter(duk_context *ctx #endif /* DUK_USE_TRACEBACKS */ -DUK_INTERNAL duk_ret_t duk_bi_error_prototype_nop_setter(duk_context *ctx) { - /* Attempt to write 'stack', 'fileName', 'lineNumber' is a silent no-op. - * User can use Object.defineProperty() to override this behavior. +DUK_LOCAL duk_ret_t duk__error_setter_helper(duk_context *ctx, duk_small_uint_t stridx_key) { + /* Attempt to write 'stack', 'fileName', 'lineNumber' works as if + * user code called Object.defineProperty() to create an overriding + * own property. This allows user code to overwrite .fileName etc + * intuitively as e.g. "err.fileName = 'dummy'" as one might expect. + * See https://github.com/svaarala/duktape/issues/387. */ - DUK_ASSERT_TOP(ctx, 1); /* fixed arg count */ - DUK_UNREF(ctx); + + DUK_ASSERT_TOP(ctx, 1); /* fixed arg count: value */ + + duk_push_this(ctx); + duk_push_hstring_stridx(ctx, (duk_small_int_t) stridx_key); + duk_dup(ctx, 0); + + /* [ ... obj key value ] */ + + DUK_DD(DUK_DDPRINT("error setter: %!T %!T %!T", + duk_get_tval(ctx, -3), duk_get_tval(ctx, -2), duk_get_tval(ctx, -1))); + + duk_def_prop(ctx, -3, DUK_DEFPROP_HAVE_VALUE | + DUK_DEFPROP_HAVE_WRITABLE | DUK_DEFPROP_WRITABLE | + DUK_DEFPROP_HAVE_ENUMERABLE | /*not enumerable*/ + DUK_DEFPROP_HAVE_CONFIGURABLE | DUK_DEFPROP_CONFIGURABLE); return 0; } + +DUK_INTERNAL duk_ret_t duk_bi_error_prototype_stack_setter(duk_context *ctx) { + return duk__error_setter_helper(ctx, DUK_STRIDX_STACK); +} + +DUK_INTERNAL duk_ret_t duk_bi_error_prototype_filename_setter(duk_context *ctx) { + return duk__error_setter_helper(ctx, DUK_STRIDX_FILE_NAME); +} + +DUK_INTERNAL duk_ret_t duk_bi_error_prototype_linenumber_setter(duk_context *ctx) { + return duk__error_setter_helper(ctx, DUK_STRIDX_LINE_NUMBER); +} #line 1 "duk_bi_function.c" /* * Function built-ins @@ -23757,6 +30842,11 @@ DUK_INTERNAL duk_ret_t duk_bi_function_prototype_bind(duk_context *ctx) { * Encoding/decoding helpers */ +/* XXX: Could add fast path (for each transform callback) with direct byte + * lookups (no shifting) and no explicit check for x < 0x80 before table + * lookup. + */ + /* Macros for creating and checking bitmasks for character encoding. * Bit number is a bit counterintuitive, but minimizes code size. */ @@ -23828,16 +30918,18 @@ DUK_LOCAL const duk_uint8_t duk__escape_unescaped_table[16] = { }; #endif /* DUK_USE_SECTION_B */ +#undef DUK__MKBITS + typedef struct { duk_hthread *thr; duk_hstring *h_str; - duk_hbuffer_dynamic *h_buf; + duk_bufwriter_ctx bw; const duk_uint8_t *p; const duk_uint8_t *p_start; const duk_uint8_t *p_end; } duk__transform_context; -typedef void (*duk__transform_callback)(duk__transform_context *tfm_ctx, void *udata, duk_codepoint_t cp); +typedef void (*duk__transform_callback)(duk__transform_context *tfm_ctx, const void *udata, duk_codepoint_t cp); /* XXX: refactor and share with other code */ DUK_LOCAL duk_small_int_t duk__decode_hex_escape(const duk_uint8_t *p, duk_small_int_t n) { @@ -23857,7 +30949,7 @@ DUK_LOCAL duk_small_int_t duk__decode_hex_escape(const duk_uint8_t *p, duk_small return t; } -DUK_LOCAL int duk__transform_helper(duk_context *ctx, duk__transform_callback callback, void *udata) { +DUK_LOCAL int duk__transform_helper(duk_context *ctx, duk__transform_callback callback, const void *udata) { duk_hthread *thr = (duk_hthread *) ctx; duk__transform_context tfm_ctx_alloc; duk__transform_context *tfm_ctx = &tfm_ctx_alloc; @@ -23868,10 +30960,7 @@ DUK_LOCAL int duk__transform_helper(duk_context *ctx, duk__transform_callback ca tfm_ctx->h_str = duk_to_hstring(ctx, 0); DUK_ASSERT(tfm_ctx->h_str != NULL); - (void) duk_push_dynamic_buffer(ctx, 0); - tfm_ctx->h_buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1); - DUK_ASSERT(tfm_ctx->h_buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(tfm_ctx->h_buf)); + DUK_BW_INIT_PUSHBUF(thr, &tfm_ctx->bw, DUK_HSTRING_GET_BYTELEN(tfm_ctx->h_str)); /* initial size guess */ tfm_ctx->p_start = DUK_HSTRING_GET_DATA(tfm_ctx->h_str); tfm_ctx->p_end = tfm_ctx->p_start + DUK_HSTRING_GET_BYTELEN(tfm_ctx->h_str); @@ -23882,22 +30971,29 @@ DUK_LOCAL int duk__transform_helper(duk_context *ctx, duk__transform_callback ca callback(tfm_ctx, udata, cp); } + DUK_BW_COMPACT(thr, &tfm_ctx->bw); + duk_to_string(ctx, -1); return 1; } -DUK_LOCAL void duk__transform_callback_encode_uri(duk__transform_context *tfm_ctx, void *udata, duk_codepoint_t cp) { +DUK_LOCAL void duk__transform_callback_encode_uri(duk__transform_context *tfm_ctx, const void *udata, duk_codepoint_t cp) { duk_uint8_t xutf8_buf[DUK_UNICODE_MAX_XUTF8_LENGTH]; - duk_uint8_t buf[3]; duk_small_int_t len; duk_codepoint_t cp1, cp2; duk_small_int_t i, t; - const duk_uint8_t *unescaped_table = (duk_uint8_t *) udata; + const duk_uint8_t *unescaped_table = (const duk_uint8_t *) udata; + + /* UTF-8 encoded bytes escaped as %xx%xx%xx... -> 3 * nbytes. + * Codepoint range is restricted so this is a slightly too large + * but doesn't matter. + */ + DUK_BW_ENSURE(tfm_ctx->thr, &tfm_ctx->bw, 3 * DUK_UNICODE_MAX_XUTF8_LENGTH); if (cp < 0) { goto uri_error; } else if ((cp < 0x80L) && DUK__CHECK_BITMASK(unescaped_table, cp)) { - duk_hbuffer_append_byte(tfm_ctx->thr, tfm_ctx->h_buf, (duk_uint8_t) cp); + DUK_BW_WRITE_RAW_U8(tfm_ctx->thr, &tfm_ctx->bw, (duk_uint8_t) cp); return; } else if (cp >= 0xdc00L && cp <= 0xdfffL) { goto uri_error; @@ -23921,32 +31017,43 @@ DUK_LOCAL void duk__transform_callback_encode_uri(duk__transform_context *tfm_ct goto uri_error; } else { /* Non-BMP characters within valid UTF-8 range: encode as is. - * They'll decode back into surrogate pairs. + * They'll decode back into surrogate pairs if the escaped + * output is decoded. */ ; } len = duk_unicode_encode_xutf8((duk_ucodepoint_t) cp, xutf8_buf); - buf[0] = (duk_uint8_t) '%'; for (i = 0; i < len; i++) { t = (int) xutf8_buf[i]; - buf[1] = (duk_uint8_t) duk_uc_nybbles[t >> 4]; - buf[2] = (duk_uint8_t) duk_uc_nybbles[t & 0x0f]; - duk_hbuffer_append_bytes(tfm_ctx->thr, tfm_ctx->h_buf, buf, 3); + DUK_BW_WRITE_RAW_U8_3(tfm_ctx->thr, + &tfm_ctx->bw, + DUK_ASC_PERCENT, + (duk_uint8_t) duk_uc_nybbles[t >> 4], + (duk_uint8_t) duk_uc_nybbles[t & 0x0f]); } + return; uri_error: DUK_ERROR(tfm_ctx->thr, DUK_ERR_URI_ERROR, "invalid input"); } -DUK_LOCAL void duk__transform_callback_decode_uri(duk__transform_context *tfm_ctx, void *udata, duk_codepoint_t cp) { - const duk_uint8_t *reserved_table = (duk_uint8_t *) udata; +DUK_LOCAL void duk__transform_callback_decode_uri(duk__transform_context *tfm_ctx, const void *udata, duk_codepoint_t cp) { + const duk_uint8_t *reserved_table = (const duk_uint8_t *) udata; duk_small_uint_t utf8_blen; duk_codepoint_t min_cp; duk_small_int_t t; /* must be signed */ duk_small_uint_t i; + /* Maximum write size: XUTF8 path writes max DUK_UNICODE_MAX_XUTF8_LENGTH, + * percent escape path writes max two times CESU-8 encoded BMP length. + */ + DUK_BW_ENSURE(tfm_ctx->thr, + &tfm_ctx->bw, + (DUK_UNICODE_MAX_XUTF8_LENGTH >= 2 * DUK_UNICODE_MAX_CESU8_BMP_LENGTH ? + DUK_UNICODE_MAX_XUTF8_LENGTH : DUK_UNICODE_MAX_CESU8_BMP_LENGTH)); + if (cp == (duk_codepoint_t) '%') { const duk_uint8_t *p = tfm_ctx->p; duk_size_t left = (duk_size_t) (tfm_ctx->p_end - p); /* bytes left */ @@ -23967,9 +31074,13 @@ DUK_LOCAL void duk__transform_callback_decode_uri(duk__transform_context *tfm_ct if (DUK__CHECK_BITMASK(reserved_table, t)) { /* decode '%xx' to '%xx' if decoded char in reserved set */ DUK_ASSERT(tfm_ctx->p - 1 >= tfm_ctx->p_start); - duk_hbuffer_append_bytes(tfm_ctx->thr, tfm_ctx->h_buf, (duk_uint8_t *) (p - 1), 3); + DUK_BW_WRITE_RAW_U8_3(tfm_ctx->thr, + &tfm_ctx->bw, + DUK_ASC_PERCENT, + p[0], + p[1]); } else { - duk_hbuffer_append_byte(tfm_ctx->thr, tfm_ctx->h_buf, (duk_uint8_t) t); + DUK_BW_WRITE_RAW_U8(tfm_ctx->thr, &tfm_ctx->bw, (duk_uint8_t) t); } tfm_ctx->p += 2; return; @@ -24051,13 +31162,14 @@ DUK_LOCAL void duk__transform_callback_decode_uri(duk__transform_context *tfm_ct if (cp >= 0x10000L) { cp -= 0x10000L; DUK_ASSERT(cp < 0x100000L); - duk_hbuffer_append_xutf8(tfm_ctx->thr, tfm_ctx->h_buf, (duk_ucodepoint_t) ((cp >> 10) + 0xd800L)); - duk_hbuffer_append_xutf8(tfm_ctx->thr, tfm_ctx->h_buf, (duk_ucodepoint_t) ((cp & 0x03ffUL) + 0xdc00L)); + + DUK_BW_WRITE_RAW_XUTF8(tfm_ctx->thr, &tfm_ctx->bw, ((cp >> 10) + 0xd800L)); + DUK_BW_WRITE_RAW_XUTF8(tfm_ctx->thr, &tfm_ctx->bw, ((cp & 0x03ffUL) + 0xdc00L)); } else { - duk_hbuffer_append_xutf8(tfm_ctx->thr, tfm_ctx->h_buf, (duk_ucodepoint_t) cp); + DUK_BW_WRITE_RAW_XUTF8(tfm_ctx->thr, &tfm_ctx->bw, cp); } } else { - duk_hbuffer_append_xutf8(tfm_ctx->thr, tfm_ctx->h_buf, (duk_ucodepoint_t) cp); + DUK_BW_WRITE_RAW_XUTF8(tfm_ctx->thr, &tfm_ctx->bw, cp); } return; @@ -24066,30 +31178,30 @@ DUK_LOCAL void duk__transform_callback_decode_uri(duk__transform_context *tfm_ct } #ifdef DUK_USE_SECTION_B -DUK_LOCAL void duk__transform_callback_escape(duk__transform_context *tfm_ctx, void *udata, duk_codepoint_t cp) { - duk_uint8_t buf[6]; - duk_small_int_t len; - +DUK_LOCAL void duk__transform_callback_escape(duk__transform_context *tfm_ctx, const void *udata, duk_codepoint_t cp) { DUK_UNREF(udata); + DUK_BW_ENSURE(tfm_ctx->thr, &tfm_ctx->bw, 6); + if (cp < 0) { goto esc_error; } else if ((cp < 0x80L) && DUK__CHECK_BITMASK(duk__escape_unescaped_table, cp)) { - buf[0] = (duk_uint8_t) cp; - len = 1; + DUK_BW_WRITE_RAW_U8(tfm_ctx->thr, &tfm_ctx->bw, (duk_uint8_t) cp); } else if (cp < 0x100L) { - buf[0] = (duk_uint8_t) '%'; - buf[1] = (duk_uint8_t) duk_uc_nybbles[cp >> 4]; - buf[2] = (duk_uint8_t) duk_uc_nybbles[cp & 0x0f]; - len = 3; + DUK_BW_WRITE_RAW_U8_3(tfm_ctx->thr, + &tfm_ctx->bw, + (duk_uint8_t) DUK_ASC_PERCENT, + (duk_uint8_t) duk_uc_nybbles[cp >> 4], + (duk_uint8_t) duk_uc_nybbles[cp & 0x0f]); } else if (cp < 0x10000L) { - buf[0] = (duk_uint8_t) '%'; - buf[1] = (duk_uint8_t) 'u'; - buf[2] = (duk_uint8_t) duk_uc_nybbles[cp >> 12]; - buf[3] = (duk_uint8_t) duk_uc_nybbles[(cp >> 8) & 0x0f]; - buf[4] = (duk_uint8_t) duk_uc_nybbles[(cp >> 4) & 0x0f]; - buf[5] = (duk_uint8_t) duk_uc_nybbles[cp & 0x0f]; - len = 6; + DUK_BW_WRITE_RAW_U8_6(tfm_ctx->thr, + &tfm_ctx->bw, + (duk_uint8_t) DUK_ASC_PERCENT, + (duk_uint8_t) DUK_ASC_LC_U, + (duk_uint8_t) duk_uc_nybbles[cp >> 12], + (duk_uint8_t) duk_uc_nybbles[(cp >> 8) & 0x0f], + (duk_uint8_t) duk_uc_nybbles[(cp >> 4) & 0x0f], + (duk_uint8_t) duk_uc_nybbles[cp & 0x0f]); } else { /* Characters outside BMP cannot be escape()'d. We could * encode them as surrogate pairs (for codepoints inside @@ -24099,14 +31211,13 @@ DUK_LOCAL void duk__transform_callback_escape(duk__transform_context *tfm_ctx, v goto esc_error; } - duk_hbuffer_append_bytes(tfm_ctx->thr, tfm_ctx->h_buf, buf, len); return; esc_error: DUK_ERROR(tfm_ctx->thr, DUK_ERR_TYPE_ERROR, "invalid input"); } -DUK_LOCAL void duk__transform_callback_unescape(duk__transform_context *tfm_ctx, void *udata, duk_codepoint_t cp) { +DUK_LOCAL void duk__transform_callback_unescape(duk__transform_context *tfm_ctx, const void *udata, duk_codepoint_t cp) { duk_small_int_t t; DUK_UNREF(udata); @@ -24126,7 +31237,7 @@ DUK_LOCAL void duk__transform_callback_unescape(duk__transform_context *tfm_ctx, } } - duk_hbuffer_append_xutf8(tfm_ctx->thr, tfm_ctx->h_buf, cp); + DUK_BW_WRITE_ENSURE_XUTF8(tfm_ctx->thr, &tfm_ctx->bw, cp); } #endif /* DUK_USE_SECTION_B */ @@ -24152,8 +31263,9 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_eval(duk_context *ctx) { duk_hobject *outer_var_env; duk_bool_t this_to_global = 1; duk_small_uint_t comp_flags; + duk_int_t level = -2; - DUK_ASSERT_TOP(ctx, 1); + DUK_ASSERT(duk_get_top(ctx) == 1 || duk_get_top(ctx) == 2); /* 2 when called by debugger */ DUK_ASSERT(thr->callstack_top >= 1); /* at least this function exists */ DUK_ASSERT(((thr->callstack + thr->callstack_top - 1)->flags & DUK_ACT_FLAG_DIRECT_EVAL) == 0 || /* indirect eval */ (thr->callstack_top >= 2)); /* if direct eval, calling activation must exist */ @@ -24171,15 +31283,26 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_eval(duk_context *ctx) { return 1; /* return arg as-is */ } +#if defined(DUK_USE_DEBUGGER_SUPPORT) + /* NOTE: level is used only by the debugger and should never be present + * for an Ecmascript eval(). + */ + DUK_ASSERT(level == -2); /* by default, use caller's environment */ + if (duk_get_top(ctx) >= 2 && duk_is_number(ctx, 1)) { + level = duk_get_int(ctx, 1); + } + DUK_ASSERT(level <= -2); /* This is guaranteed by debugger code. */ +#endif + /* [ source ] */ comp_flags = DUK_JS_COMPILE_FLAG_EVAL; act_eval = thr->callstack + thr->callstack_top - 1; /* this function */ - if (thr->callstack_top >= 2) { + if (thr->callstack_top >= (duk_size_t) -level) { /* Have a calling activation, check for direct eval (otherwise * assume indirect eval. */ - act_caller = thr->callstack + thr->callstack_top - 2; /* caller */ + act_caller = thr->callstack + thr->callstack_top + level; /* caller */ if ((act_caller->flags & DUK_ACT_FLAG_STRICT) && (act_eval->flags & DUK_ACT_FLAG_DIRECT_EVAL)) { /* Only direct eval inherits strictness from calling code @@ -24209,14 +31332,14 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_eval(duk_context *ctx) { act = thr->callstack + thr->callstack_top - 1; /* this function */ if (act->flags & DUK_ACT_FLAG_DIRECT_EVAL) { DUK_ASSERT(thr->callstack_top >= 2); - act = thr->callstack + thr->callstack_top - 2; /* caller */ + act = thr->callstack + thr->callstack_top + level; /* caller */ if (act->lex_env == NULL) { DUK_ASSERT(act->var_env == NULL); DUK_DDD(DUK_DDDPRINT("delayed environment initialization")); /* this may have side effects, so re-lookup act */ duk_js_init_activation_environment_records_delayed(thr, act); - act = thr->callstack + thr->callstack_top - 2; + act = thr->callstack + thr->callstack_top + level; } DUK_ASSERT(act->lex_env != NULL); DUK_ASSERT(act->var_env != NULL); @@ -24231,7 +31354,7 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_eval(duk_context *ctx) { "var_env and lex_env to a fresh env, " "this_binding to caller's this_binding")); - act = thr->callstack + thr->callstack_top - 2; /* caller */ + act = thr->callstack + thr->callstack_top + level; /* caller */ act_lex_env = act->lex_env; act = NULL; /* invalidated */ @@ -24282,7 +31405,7 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_eval(duk_context *ctx) { } else { duk_tval *tv; DUK_ASSERT(thr->callstack_top >= 2); - act = thr->callstack + thr->callstack_top - 2; /* caller */ + act = thr->callstack + thr->callstack_top + level; /* caller */ tv = thr->valstack + act->idx_bottom - 1; /* this is just beneath bottom */ DUK_ASSERT(tv >= thr->valstack); duk_push_tval(ctx, tv); @@ -24307,43 +31430,38 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_eval(duk_context *ctx) { */ DUK_INTERNAL duk_ret_t duk_bi_global_object_parse_int(duk_context *ctx) { - duk_bool_t strip_prefix; duk_int32_t radix; duk_small_uint_t s2n_flags; DUK_ASSERT_TOP(ctx, 2); duk_to_string(ctx, 0); - strip_prefix = 1; radix = duk_to_int32(ctx, 1); - if (radix != 0) { - if (radix < 2 || radix > 36) { - goto ret_nan; - } - /* For octal, setting strip_prefix=0 is not necessary, as zero - * is tolerated anyway: - * - * parseInt('123', 8) === parseInt('0123', 8) with or without strip_prefix - * parseInt('123', 16) === parseInt('0x123', 16) requires strip_prefix = 1 - */ - if (radix != 16) { - strip_prefix = 0; - } - } else { - radix = 10; - } s2n_flags = DUK_S2N_FLAG_TRIM_WHITE | DUK_S2N_FLAG_ALLOW_GARBAGE | DUK_S2N_FLAG_ALLOW_PLUS | DUK_S2N_FLAG_ALLOW_MINUS | DUK_S2N_FLAG_ALLOW_LEADING_ZERO | -#ifdef DUK_USE_OCTAL_SUPPORT - (strip_prefix ? (DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT | DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT) : 0) -#else - (strip_prefix ? DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT : 0) -#endif - ; + DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT; + + /* Specification stripPrefix maps to DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT. + * + * Don't autodetect octals (from leading zeroes), require user code to + * provide an explicit radix 8 for parsing octal. See write-up from Mozilla: + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt#ECMAScript_5_Removes_Octal_Interpretation + */ + + if (radix != 0) { + if (radix < 2 || radix > 36) { + goto ret_nan; + } + if (radix != 16) { + s2n_flags &= ~DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT; + } + } else { + radix = 10; + } duk_dup(ctx, 0); duk_numconv_parse(ctx, radix, s2n_flags); @@ -24400,28 +31518,28 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_is_finite(duk_context *ctx) { */ DUK_INTERNAL duk_ret_t duk_bi_global_object_decode_uri(duk_context *ctx) { - return duk__transform_helper(ctx, duk__transform_callback_decode_uri, (void *) duk__decode_uri_reserved_table); + return duk__transform_helper(ctx, duk__transform_callback_decode_uri, (const void *) duk__decode_uri_reserved_table); } DUK_INTERNAL duk_ret_t duk_bi_global_object_decode_uri_component(duk_context *ctx) { - return duk__transform_helper(ctx, duk__transform_callback_decode_uri, (void *) duk__decode_uri_component_reserved_table); + return duk__transform_helper(ctx, duk__transform_callback_decode_uri, (const void *) duk__decode_uri_component_reserved_table); } DUK_INTERNAL duk_ret_t duk_bi_global_object_encode_uri(duk_context *ctx) { - return duk__transform_helper(ctx, duk__transform_callback_encode_uri, (void *) duk__encode_uriunescaped_table); + return duk__transform_helper(ctx, duk__transform_callback_encode_uri, (const void *) duk__encode_uriunescaped_table); } DUK_INTERNAL duk_ret_t duk_bi_global_object_encode_uri_component(duk_context *ctx) { - return duk__transform_helper(ctx, duk__transform_callback_encode_uri, (void *) duk__encode_uricomponent_unescaped_table); + return duk__transform_helper(ctx, duk__transform_callback_encode_uri, (const void *) duk__encode_uricomponent_unescaped_table); } #ifdef DUK_USE_SECTION_B DUK_INTERNAL duk_ret_t duk_bi_global_object_escape(duk_context *ctx) { - return duk__transform_helper(ctx, duk__transform_callback_escape, (void *) NULL); + return duk__transform_helper(ctx, duk__transform_callback_escape, (const void *) NULL); } DUK_INTERNAL duk_ret_t duk_bi_global_object_unescape(duk_context *ctx) { - return duk__transform_helper(ctx, duk__transform_callback_unescape, (void *) NULL); + return duk__transform_helper(ctx, duk__transform_callback_unescape, (const void *) NULL); } #else /* DUK_USE_SECTION_B */ DUK_INTERNAL duk_ret_t duk_bi_global_object_escape(duk_context *ctx) { @@ -24450,6 +31568,8 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_print_helper(duk_context *ctx) { duk_file *f_out; #endif + DUK_UNREF(thr); + magic = duk_get_current_magic(ctx); DUK_UNREF(magic); @@ -24490,13 +31610,13 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_print_helper(duk_context *ctx) { } if (sz_buf <= sizeof(buf_stack)) { - buf = (const duk_uint8_t *) buf_stack; + p = (duk_uint8_t *) buf_stack; } else { - buf = (const duk_uint8_t *) duk_push_fixed_buffer(ctx, sz_buf); - DUK_ASSERT(buf != NULL); + p = (duk_uint8_t *) duk_push_fixed_buffer(ctx, sz_buf); + DUK_ASSERT(p != NULL); } - p = (duk_uint8_t *) buf; + buf = (const duk_uint8_t *) p; for (i = 0; i < nargs; i++) { p_str = (const duk_uint8_t *) duk_get_lstring(ctx, i, &sz_str); DUK_ASSERT(p_str != NULL); @@ -24504,7 +31624,7 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_print_helper(duk_context *ctx) { p += sz_str; *p++ = (duk_uint8_t) (i == nargs - 1 ? DUK_ASC_LF : DUK_ASC_SPACE); } - DUK_ASSERT((const duk_uint8_t *) p == buf + sz_total); + DUK_ASSERT((const duk_uint8_t *) p == buf + sz_buf); #endif /* DUK_USE_PREFER_SIZE */ } else { buf = (const duk_uint8_t *) &nl; @@ -24707,6 +31827,7 @@ DUK_LOCAL void duk__bi_global_resolve_module_id(duk_context *ctx, const char *re DUK_INTERNAL duk_ret_t duk_bi_global_object_require(duk_context *ctx) { const char *str_req_id; /* requested identifier */ const char *str_mod_id; /* require.id of current module */ + duk_int_t pcall_rc; /* NOTE: we try to minimize code size by avoiding unnecessary pops, * so the stack looks a bit cluttered in this function. DUK_ASSERT_TOP() @@ -24760,6 +31881,7 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_require(duk_context *ctx) { /* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded Duktape.modLoaded[id] ] */ DUK_DD(DUK_DDPRINT("module already loaded: %!T", (duk_tval *) duk_get_tval(ctx, 3))); + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_EXPORTS); /* return module.exports */ return 1; } @@ -24790,19 +31912,30 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_require(duk_context *ctx) { duk_dup(ctx, 3); duk_xdef_prop_stridx(ctx, 7, DUK_STRIDX_ID, DUK_PROPDESC_FLAGS_C); /* a fresh require() with require.id = resolved target module id */ - /* Exports table. */ - duk_push_object(ctx); - - /* Module table: module.id is non-writable and non-configurable, as - * the CommonJS spec suggests this if possible. + /* Module table: + * - module.exports: initial exports table (may be replaced by user) + * - module.id is non-writable and non-configurable, as the CommonJS + * spec suggests this if possible. */ - duk_push_object(ctx); + duk_push_object(ctx); /* exports */ + duk_push_object(ctx); /* module */ + duk_dup(ctx, -2); + duk_xdef_prop_stridx(ctx, 9, DUK_STRIDX_EXPORTS, DUK_PROPDESC_FLAGS_WC); /* module.exports = exports */ duk_dup(ctx, 3); /* resolved id: require(id) must return this same module */ - duk_xdef_prop_stridx(ctx, 9, DUK_STRIDX_ID, DUK_PROPDESC_FLAGS_NONE); + duk_xdef_prop_stridx(ctx, 9, DUK_STRIDX_ID, DUK_PROPDESC_FLAGS_NONE); /* module.id = resolved_id */ + duk_compact(ctx, 9); /* module table remains registered to modLoaded, minimize its size */ /* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded undefined fresh_require exports module ] */ DUK_ASSERT_TOP(ctx, 10); + /* Register the module table early to modLoaded[] so that we can + * support circular references even in modSearch(). If an error + * is thrown, we'll delete the reference. + */ + duk_dup(ctx, 3); + duk_dup(ctx, 9); + duk_put_prop(ctx, 5); /* Duktape.modLoaded[resolved_id] = module */ + /* * Call user provided module search function and build the wrapped * module source code (if necessary). The module search function @@ -24815,11 +31948,9 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_require(duk_context *ctx) { * is returned the module is assumed to be a pure C one). If a module * cannot be found, an error must be thrown by the user callback. * - * NOTE: the current arrangement allows C modules to be implemented - * but since the exports table is registered to Duktape.modLoaded only - * after the search function returns, circular requires / partially - * loaded modules don't work for C modules. This is rarely an issue, - * as C modules usually simply expose a set of helper functions. + * Because Duktape.modLoaded[] already contains the module being + * loaded, circular references for C modules should also work + * (although expected to be quite rare). */ duk_push_string(ctx, "(function(require,exports,module){"); @@ -24830,23 +31961,23 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_require(duk_context *ctx) { duk_dup(ctx, 7); duk_dup(ctx, 8); duk_dup(ctx, 9); /* [ ... Duktape.modSearch resolved_id fresh_require exports module ] */ - duk_call(ctx, 4 /*nargs*/); /* -> [ ... source ] */ + pcall_rc = duk_pcall(ctx, 4 /*nargs*/); /* -> [ ... source ] */ DUK_ASSERT_TOP(ctx, 12); - /* Because user callback did not throw an error, remember exports table. */ - duk_dup(ctx, 3); - duk_dup(ctx, 8); - duk_xdef_prop(ctx, 5, DUK_PROPDESC_FLAGS_EC); /* Duktape.modLoaded[resolved_id] = exports */ + if (pcall_rc != DUK_EXEC_SUCCESS) { + /* Delete entry in Duktape.modLoaded[] and rethrow. */ + goto delete_rethrow; + } /* If user callback did not return source code, module loading * is finished (user callback initialized exports table directly). */ if (!duk_is_string(ctx, 11)) { - /* User callback did not return source code, so - * module loading is finished. + /* User callback did not return source code, so module loading + * is finished: just update modLoaded with final module.exports + * and we're done. */ - duk_dup(ctx, 8); - return 1; + goto return_exports; } /* Finish the wrapped module source. Force resolved module ID as the @@ -24871,6 +32002,9 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_require(duk_context *ctx) { /* * Call the wrapped module function. + * + * Use a protected call so that we can update Duktape.modLoaded[resolved_id] + * even if the module throws an error. */ /* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded undefined fresh_require exports module mod_func ] */ @@ -24878,19 +32012,35 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_require(duk_context *ctx) { duk_dup(ctx, 8); /* exports (this binding) */ duk_dup(ctx, 7); /* fresh require (argument) */ - duk_dup(ctx, 8); /* exports (argument) */ + duk_get_prop_stridx(ctx, 9, DUK_STRIDX_EXPORTS); /* relookup exports from module.exports in case it was changed by modSearch */ duk_dup(ctx, 9); /* module (argument) */ /* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded undefined fresh_require exports module mod_func exports fresh_require exports module ] */ DUK_ASSERT_TOP(ctx, 15); - duk_call_method(ctx, 3 /*nargs*/); + pcall_rc = duk_pcall_method(ctx, 3 /*nargs*/); + if (pcall_rc != DUK_EXEC_SUCCESS) { + /* Module loading failed. Node.js will forget the module + * registration so that another require() will try to load + * the module again. Mimic that behavior. + */ + goto delete_rethrow; + } /* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded undefined fresh_require exports module result(ignored) ] */ DUK_ASSERT_TOP(ctx, 11); - duk_pop_2(ctx); - return 1; /* return exports */ + /* fall through */ + + return_exports: + duk_get_prop_stridx(ctx, 9, DUK_STRIDX_EXPORTS); + return 1; /* return module.exports */ + + delete_rethrow: + duk_dup(ctx, 3); + duk_del_prop(ctx, 5); /* delete Duktape.modLoaded[resolved_id] */ + duk_throw(ctx); /* rethrow original error */ + return 0; /* not reachable */ } #else DUK_INTERNAL duk_ret_t duk_bi_global_object_require(duk_context *ctx) { @@ -24902,10 +32052,17 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_require(duk_context *ctx) { /* * JSON built-ins. * - * See doc/json.txt. + * See doc/json.rst. * * Codepoints are handled as duk_uint_fast32_t to ensure that the full * unsigned 32-bit range is supported. This matters to e.g. JX. + * + * Input parsing doesn't do an explicit end-of-input check at all. This is + * safe: input string data is always NUL-terminated (0x00) and valid JSON + * inputs never contain plain NUL characters, so that as long as syntax checks + * are correct, we'll never read past the NUL. This approach reduces code size + * and improves parsing performance, but it's critical that syntax checks are + * indeed correct! */ /* include removed: duk_internal.h */ @@ -24914,11 +32071,17 @@ DUK_INTERNAL duk_ret_t duk_bi_global_object_require(duk_context *ctx) { * Local defines and forward declarations. */ +#define DUK__JSON_DECSTR_BUFSIZE 128 +#define DUK__JSON_DECSTR_CHUNKSIZE 64 +#define DUK__JSON_ENCSTR_CHUNKSIZE 64 +#define DUK__JSON_STRINGIFY_BUFSIZE 128 +#define DUK__JSON_MAX_ESC_LEN 10 /* '\Udeadbeef' */ + DUK_LOCAL_DECL void duk__dec_syntax_error(duk_json_dec_ctx *js_ctx); DUK_LOCAL_DECL void duk__dec_eat_white(duk_json_dec_ctx *js_ctx); -DUK_LOCAL_DECL duk_small_int_t duk__dec_peek(duk_json_dec_ctx *js_ctx); -DUK_LOCAL_DECL duk_small_int_t duk__dec_get(duk_json_dec_ctx *js_ctx); -DUK_LOCAL_DECL duk_small_int_t duk__dec_get_nonwhite(duk_json_dec_ctx *js_ctx); +DUK_LOCAL_DECL duk_uint8_t duk__dec_peek(duk_json_dec_ctx *js_ctx); +DUK_LOCAL_DECL duk_uint8_t duk__dec_get(duk_json_dec_ctx *js_ctx); +DUK_LOCAL_DECL duk_uint8_t duk__dec_get_nonwhite(duk_json_dec_ctx *js_ctx); DUK_LOCAL_DECL duk_uint_fast32_t duk__dec_decode_hex_escape(duk_json_dec_ctx *js_ctx, duk_small_uint_t n); DUK_LOCAL_DECL void duk__dec_req_stridx(duk_json_dec_ctx *js_ctx, duk_small_uint_t stridx); DUK_LOCAL_DECL void duk__dec_string(duk_json_dec_ctx *js_ctx); @@ -24936,23 +32099,148 @@ DUK_LOCAL_DECL void duk__dec_value(duk_json_dec_ctx *js_ctx); DUK_LOCAL_DECL void duk__dec_reviver_walk(duk_json_dec_ctx *js_ctx); DUK_LOCAL_DECL void duk__emit_1(duk_json_enc_ctx *js_ctx, duk_uint_fast8_t ch); -DUK_LOCAL_DECL void duk__emit_2(duk_json_enc_ctx *js_ctx, duk_uint_fast16_t packed_chars); -DUK_LOCAL_DECL void duk__emit_esc_auto(duk_json_enc_ctx *js_ctx, duk_uint_fast32_t cp); -DUK_LOCAL_DECL void duk__emit_xutf8(duk_json_enc_ctx *js_ctx, duk_uint_fast32_t cp); +DUK_LOCAL_DECL void duk__emit_2(duk_json_enc_ctx *js_ctx, duk_uint_fast8_t ch1, duk_uint_fast8_t ch2); +#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH) +DUK_LOCAL_DECL void duk__unemit_1(duk_json_enc_ctx *js_ctx); +#endif DUK_LOCAL_DECL void duk__emit_hstring(duk_json_enc_ctx *js_ctx, duk_hstring *h); -#if defined(DUK_USE_JX) || defined(DUK_USE_JC) +#if defined(DUK_USE_FASTINT) DUK_LOCAL_DECL void duk__emit_cstring(duk_json_enc_ctx *js_ctx, const char *p); #endif DUK_LOCAL_DECL void duk__emit_stridx(duk_json_enc_ctx *js_ctx, duk_small_uint_t stridx); +DUK_LOCAL_DECL duk_uint8_t *duk__emit_esc_auto_fast(duk_json_enc_ctx *js_ctx, duk_uint_fast32_t cp, duk_uint8_t *q); DUK_LOCAL_DECL duk_bool_t duk__enc_key_quotes_needed(duk_hstring *h_key); +DUK_LOCAL_DECL void duk__enc_key_autoquote(duk_json_enc_ctx *js_ctx, duk_hstring *k); DUK_LOCAL_DECL void duk__enc_quote_string(duk_json_enc_ctx *js_ctx, duk_hstring *h_str); -DUK_LOCAL_DECL void duk__enc_objarr_entry(duk_json_enc_ctx *js_ctx, duk_hstring **h_stepback, duk_hstring **h_indent, duk_idx_t *entry_top); -DUK_LOCAL_DECL void duk__enc_objarr_exit(duk_json_enc_ctx *js_ctx, duk_hstring **h_stepback, duk_hstring **h_indent, duk_idx_t *entry_top); +DUK_LOCAL_DECL void duk__enc_objarr_entry(duk_json_enc_ctx *js_ctx, duk_idx_t *entry_top); +DUK_LOCAL_DECL void duk__enc_objarr_exit(duk_json_enc_ctx *js_ctx, duk_idx_t *entry_top); DUK_LOCAL_DECL void duk__enc_object(duk_json_enc_ctx *js_ctx); DUK_LOCAL_DECL void duk__enc_array(duk_json_enc_ctx *js_ctx); DUK_LOCAL_DECL duk_bool_t duk__enc_value1(duk_json_enc_ctx *js_ctx, duk_idx_t idx_holder); DUK_LOCAL_DECL void duk__enc_value2(duk_json_enc_ctx *js_ctx); DUK_LOCAL_DECL duk_bool_t duk__enc_allow_into_proplist(duk_tval *tv); +DUK_LOCAL_DECL void duk__enc_double(duk_json_enc_ctx *js_ctx); +#if defined(DUK_USE_FASTINT) +DUK_LOCAL_DECL void duk__enc_fastint_tval(duk_json_enc_ctx *js_ctx, duk_tval *tv); +#endif +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) +DUK_LOCAL_DECL void duk__enc_buffer(duk_json_enc_ctx *js_ctx, duk_hbuffer *h); +DUK_LOCAL_DECL void duk__enc_pointer(duk_json_enc_ctx *js_ctx, void *ptr); +#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH) +DUK_LOCAL_DECL void duk__enc_bufferobject(duk_json_enc_ctx *js_ctx, duk_hbufferobject *h_bufobj); +#endif +#endif +DUK_LOCAL_DECL void duk__enc_newline_indent(duk_json_enc_ctx *js_ctx, duk_int_t depth); + +/* + * Helper tables + */ + +#if defined(DUK_USE_JSON_QUOTESTRING_FASTPATH) +DUK_LOCAL const duk_uint8_t duk__json_quotestr_lookup[256] = { + /* 0x00 ... 0x7f: as is + * 0x80: escape generically + * 0x81: slow path + * 0xa0 ... 0xff: backslash + one char + */ + + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xe2, 0xf4, 0xee, 0x80, 0xe6, 0xf2, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x20, 0x21, 0xa2, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0xdc, 0x5d, 0x5e, 0x5f, + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81 +}; +#else /* DUK_USE_JSON_QUOTESTRING_FASTPATH */ +DUK_LOCAL const duk_uint8_t duk__json_quotestr_esc[14] = { + DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL, + DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL, + DUK_ASC_LC_B, DUK_ASC_LC_T, DUK_ASC_LC_N, DUK_ASC_NUL, + DUK_ASC_LC_F, DUK_ASC_LC_R +}; +#endif /* DUK_USE_JSON_QUOTESTRING_FASTPATH */ + +#if defined(DUK_USE_JSON_DECSTRING_FASTPATH) +DUK_LOCAL const duk_uint8_t duk__json_decstr_lookup[256] = { + /* 0x00: slow path + * other: as is + */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x20, 0x21, 0x00, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x00, 0x5d, 0x5e, 0x5f, + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, + 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, + 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, + 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, + 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, + 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, + 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, + 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff +}; +#endif /* DUK_USE_JSON_DECSTRING_FASTPATH */ + +#if defined(DUK_USE_JSON_EATWHITE_FASTPATH) +DUK_LOCAL const duk_uint8_t duk__json_eatwhite_lookup[256] = { + /* 0x00: finish (non-white) + * 0x01: continue + */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; +#endif /* DUK_USE_JSON_EATWHITE_FASTPATH */ + +#if defined(DUK_USE_JSON_DECNUMBER_FASTPATH) +DUK_LOCAL const duk_uint8_t duk__json_decnumber_lookup[256] = { + /* 0x00: finish (not part of number) + * 0x01: continue + */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; +#endif /* DUK_USE_JSON_DECNUMBER_FASTPATH */ /* * Parsing implementation. @@ -24977,39 +32265,46 @@ DUK_LOCAL void duk__dec_syntax_error(duk_json_dec_ctx *js_ctx) { } DUK_LOCAL void duk__dec_eat_white(duk_json_dec_ctx *js_ctx) { - duk_small_uint_t t; + const duk_uint8_t *p; + duk_uint8_t t; + + p = js_ctx->p; for (;;) { - if (js_ctx->p >= js_ctx->p_end) { + DUK_ASSERT(p <= js_ctx->p_end); + t = *p; + +#if defined(DUK_USE_JSON_EATWHITE_FASTPATH) + /* This fast path is pretty marginal in practice. + * XXX: candidate for removal. + */ + DUK_ASSERT(duk__json_eatwhite_lookup[0x00] == 0x00); /* end-of-input breaks */ + if (duk__json_eatwhite_lookup[t] == 0) { break; } - t = (*js_ctx->p); +#else /* DUK_USE_JSON_EATWHITE_FASTPATH */ if (!(t == 0x20 || t == 0x0a || t == 0x0d || t == 0x09)) { + /* NUL also comes here. Comparison order matters, 0x20 + * is most common whitespace. + */ break; } - js_ctx->p++; +#endif /* DUK_USE_JSON_EATWHITE_FASTPATH */ + p++; } + js_ctx->p = p; } -DUK_LOCAL duk_small_int_t duk__dec_peek(duk_json_dec_ctx *js_ctx) { - if (js_ctx->p >= js_ctx->p_end) { - return -1; - } else { - return (duk_small_int_t) (*js_ctx->p); - } +DUK_LOCAL duk_uint8_t duk__dec_peek(duk_json_dec_ctx *js_ctx) { + DUK_ASSERT(js_ctx->p <= js_ctx->p_end); + return *js_ctx->p; } -DUK_LOCAL duk_small_int_t duk__dec_get(duk_json_dec_ctx *js_ctx) { - /* Multiple EOFs will now be supplied to the caller. This could also be - * changed so that reading the second EOF would cause an error automatically. - */ - if (js_ctx->p >= js_ctx->p_end) { - return -1; - } else { - return (duk_small_int_t) (*js_ctx->p++); - } +DUK_LOCAL duk_uint8_t duk__dec_get(duk_json_dec_ctx *js_ctx) { + DUK_ASSERT(js_ctx->p <= js_ctx->p_end); + return *js_ctx->p++; } -DUK_LOCAL duk_small_int_t duk__dec_get_nonwhite(duk_json_dec_ctx *js_ctx) { +DUK_LOCAL duk_uint8_t duk__dec_get_nonwhite(duk_json_dec_ctx *js_ctx) { duk__dec_eat_white(js_ctx); return duk__dec_get(js_ctx); } @@ -25018,21 +32313,21 @@ DUK_LOCAL duk_small_int_t duk__dec_get_nonwhite(duk_json_dec_ctx *js_ctx) { DUK_LOCAL duk_uint_fast32_t duk__dec_decode_hex_escape(duk_json_dec_ctx *js_ctx, duk_small_uint_t n) { duk_small_uint_t i; duk_uint_fast32_t res = 0; - duk_small_int_t x; + duk_uint8_t x; + duk_small_int_t t; for (i = 0; i < n; i++) { /* XXX: share helper from lexer; duk_lexer.c / hexval(). */ x = duk__dec_get(js_ctx); - DUK_ASSERT((x >= 0 && x <= 0xff) || (x == -1)); - DUK_DDD(DUK_DDDPRINT("decode_hex_escape: i=%ld, n=%ld, res=%ld, x=%ld", (long) i, (long) n, (long) res, (long) x)); - /* x == -1 will map to 0xff, dectab returns -1 which causes syntax_error */ - x = duk_hex_dectab[x & 0xff]; - if (DUK_LIKELY(x >= 0)) { - res = (res * 16) + x; + /* x == 0x00 (EOF) causes syntax_error */ + DUK_ASSERT(duk_hex_dectab[0] == -1); + t = duk_hex_dectab[x & 0xff]; + if (DUK_LIKELY(t >= 0)) { + res = (res * 16) + t; } else { /* catches EOF and invalid digits */ goto syntax_error; @@ -25050,28 +32345,30 @@ DUK_LOCAL duk_uint_fast32_t duk__dec_decode_hex_escape(duk_json_dec_ctx *js_ctx, DUK_LOCAL void duk__dec_req_stridx(duk_json_dec_ctx *js_ctx, duk_small_uint_t stridx) { duk_hstring *h; - duk_uint8_t *p; - duk_uint8_t *p_end; - duk_small_int_t x; + const duk_uint8_t *p; + duk_uint8_t x, y; - /* First character has already been eaten and checked by the caller. */ + /* First character has already been eaten and checked by the caller. + * We can scan until a NUL in stridx string because no built-in strings + * have internal NULs. + */ DUK_ASSERT_DISABLE(stridx >= 0); /* unsigned */ DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); h = DUK_HTHREAD_GET_STRING(js_ctx->thr, stridx); DUK_ASSERT(h != NULL); - p = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h); - p_end = ((duk_uint8_t *) DUK_HSTRING_GET_DATA(h)) + - DUK_HSTRING_GET_BYTELEN(h); + p = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h) + 1; + DUK_ASSERT(*(js_ctx->p - 1) == *(p - 1)); /* first character has been matched */ - DUK_ASSERT(*(js_ctx->p - 1) == *p); /* first character has been matched */ - p++; /* first char */ - - while (p < p_end) { - x = duk__dec_get(js_ctx); - if ((duk_small_int_t) (*p) != x) { - /* catches EOF */ + for (;;) { + x = *p; + if (x == 0) { + break; + } + y = duk__dec_get(js_ctx); + if (x != y) { + /* Catches EOF of JSON input. */ goto syntax_error; } p++; @@ -25084,12 +32381,61 @@ DUK_LOCAL void duk__dec_req_stridx(duk_json_dec_ctx *js_ctx, duk_small_uint_t st DUK_UNREACHABLE(); } +DUK_LOCAL duk_small_int_t duk__dec_string_escape(duk_json_dec_ctx *js_ctx, duk_uint8_t **ext_p) { + duk_uint_fast32_t cp; + + /* EOF (-1) will be cast to an unsigned value first + * and then re-cast for the switch. In any case, it + * will match the default case (syntax error). + */ + cp = (duk_uint_fast32_t) duk__dec_get(js_ctx); + switch ((int) cp) { + case DUK_ASC_BACKSLASH: break; + case DUK_ASC_DOUBLEQUOTE: break; + case DUK_ASC_SLASH: break; + case DUK_ASC_LC_T: cp = 0x09; break; + case DUK_ASC_LC_N: cp = 0x0a; break; + case DUK_ASC_LC_R: cp = 0x0d; break; + case DUK_ASC_LC_F: cp = 0x0c; break; + case DUK_ASC_LC_B: cp = 0x08; break; + case DUK_ASC_LC_U: { + cp = duk__dec_decode_hex_escape(js_ctx, 4); + break; + } +#ifdef DUK_USE_JX + case DUK_ASC_UC_U: { + if (js_ctx->flag_ext_custom) { + cp = duk__dec_decode_hex_escape(js_ctx, 8); + } else { + return 1; /* syntax error */ + } + break; + } + case DUK_ASC_LC_X: { + if (js_ctx->flag_ext_custom) { + cp = duk__dec_decode_hex_escape(js_ctx, 2); + } else { + return 1; /* syntax error */ + } + break; + } +#endif /* DUK_USE_JX */ + default: + /* catches EOF (0x00) */ + return 1; /* syntax error */ + } + + DUK_RAW_WRITE_XUTF8(*ext_p, cp); + + return 0; +} + DUK_LOCAL void duk__dec_string(duk_json_dec_ctx *js_ctx) { duk_hthread *thr = js_ctx->thr; duk_context *ctx = (duk_context *) thr; - duk_hbuffer_dynamic *h_buf; - duk_small_int_t x; - duk_uint_fast32_t cp; + duk_bufwriter_ctx bw_alloc; + duk_bufwriter_ctx *bw; + duk_uint8_t *q; /* '"' was eaten by caller */ @@ -25098,65 +32444,87 @@ DUK_LOCAL void duk__dec_string(duk_json_dec_ctx *js_ctx) { * so they'll simply pass through (valid UTF-8 or not). */ - duk_push_dynamic_buffer(ctx, 0); - h_buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1); - DUK_ASSERT(h_buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(h_buf)); + bw = &bw_alloc; + DUK_BW_INIT_PUSHBUF(js_ctx->thr, bw, DUK__JSON_DECSTR_BUFSIZE); + q = DUK_BW_GET_PTR(js_ctx->thr, bw); +#if defined(DUK_USE_JSON_DECSTRING_FASTPATH) for (;;) { + duk_small_uint_t safe; + duk_uint8_t b, x; + const duk_uint8_t *p; + + /* Select a safe loop count where no output checks are + * needed assuming we won't encounter escapes. Input + * bound checks are not necessary as a NUL (guaranteed) + * will cause a SyntaxError before we read out of bounds. + */ + + safe = DUK__JSON_DECSTR_CHUNKSIZE; + + /* Ensure space for 1:1 output plus one escape. */ + q = DUK_BW_ENSURE_RAW(js_ctx->thr, bw, safe + DUK_UNICODE_MAX_XUTF8_LENGTH, q); + + p = js_ctx->p; /* temp copy, write back for next loop */ + for (;;) { + if (safe == 0) { + js_ctx->p = p; + break; + } + safe--; + + /* End of input (NUL) goes through slow path and causes SyntaxError. */ + DUK_ASSERT(duk__json_decstr_lookup[0] == 0x00); + + b = *p++; + x = (duk_small_int_t) duk__json_decstr_lookup[b]; + if (DUK_LIKELY(x != 0)) { + /* Fast path, decode as is. */ + *q++ = b; + } else if (b == DUK_ASC_DOUBLEQUOTE) { + js_ctx->p = p; + goto found_quote; + } else if (b == DUK_ASC_BACKSLASH) { + /* We've ensured space for one escaped input; then + * bail out and recheck (this makes escape handling + * quite slow but it's uncommon). + */ + js_ctx->p = p; + if (duk__dec_string_escape(js_ctx, &q) != 0) { + goto syntax_error; + } + break; + } else { + js_ctx->p = p; + goto syntax_error; + } + } + } + found_quote: +#else /* DUK_USE_JSON_DECSTRING_FASTPATH */ + for (;;) { + duk_uint8_t x; + + q = DUK_BW_ENSURE_RAW(js_ctx->thr, bw, DUK_UNICODE_MAX_XUTF8_LENGTH, q); + x = duk__dec_get(js_ctx); + if (x == DUK_ASC_DOUBLEQUOTE) { break; } else if (x == DUK_ASC_BACKSLASH) { - /* EOF (-1) will be cast to an unsigned value first - * and then re-cast for the switch. In any case, it - * will match the default case (syntax error). - */ - cp = (duk_uint_fast32_t) duk__dec_get(js_ctx); - switch ((int) cp) { - case DUK_ASC_BACKSLASH: break; - case DUK_ASC_DOUBLEQUOTE: break; - case DUK_ASC_SLASH: break; - case DUK_ASC_LC_T: cp = 0x09; break; - case DUK_ASC_LC_N: cp = 0x0a; break; - case DUK_ASC_LC_R: cp = 0x0d; break; - case DUK_ASC_LC_F: cp = 0x0c; break; - case DUK_ASC_LC_B: cp = 0x08; break; - case DUK_ASC_LC_U: { - cp = duk__dec_decode_hex_escape(js_ctx, 4); - break; - } -#ifdef DUK_USE_JX - case DUK_ASC_UC_U: { - if (js_ctx->flag_ext_custom) { - cp = duk__dec_decode_hex_escape(js_ctx, 8); - } else { - goto syntax_error; - } - break; - } - case DUK_ASC_LC_X: { - if (js_ctx->flag_ext_custom) { - cp = duk__dec_decode_hex_escape(js_ctx, 2); - } else { - goto syntax_error; - } - break; - } -#endif /* DUK_USE_JX */ - default: - /* catches EOF (-1) */ + if (duk__dec_string_escape(js_ctx, &q) != 0) { goto syntax_error; } - duk_hbuffer_append_xutf8(thr, h_buf, (duk_uint32_t) cp); } else if (x < 0x20) { - /* catches EOF (-1) */ + /* catches EOF (NUL) */ goto syntax_error; } else { - duk_hbuffer_append_byte(thr, h_buf, (duk_uint8_t) x); + *q++ = (duk_uint8_t) x; } } +#endif /* DUK_USE_JSON_DECSTRING_FASTPATH */ + DUK_BW_SETPTR_AND_COMPACT(js_ctx->thr, bw, q); duk_to_string(ctx, -1); /* [ ... str ] */ @@ -25273,12 +32641,26 @@ DUK_LOCAL void duk__dec_buffer(duk_json_dec_ctx *js_ctx) { duk_hthread *thr = js_ctx->thr; duk_context *ctx = (duk_context *) thr; const duk_uint8_t *p; + duk_uint8_t *buf; + duk_size_t src_len; duk_small_int_t x; /* Caller has already eaten the first character ('|') which we don't need. */ p = js_ctx->p; + /* XXX: Would be nice to share the fast path loop from duk_hex_decode() + * and avoid creating a temporary buffer. However, there are some + * differences which prevent trivial sharing: + * + * - Pipe char detection + * - EOF detection + * - Unknown length of input and output + * + * The best approach here would be a bufwriter and a reasonaly sized + * safe inner loop (e.g. 64 output bytes at a time). + */ + for (;;) { x = *p; @@ -25294,8 +32676,12 @@ DUK_LOCAL void duk__dec_buffer(duk_json_dec_ctx *js_ctx) { p++; } - duk_push_lstring(ctx, (const char *) js_ctx->p, (duk_size_t) (p - js_ctx->p)); + src_len = (duk_size_t) (p - js_ctx->p); + buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, src_len); + DUK_ASSERT(buf != NULL); + DUK_MEMCPY((void *) buf, (const void *) js_ctx->p, src_len); duk_hex_decode(ctx, -1); + js_ctx->p = p + 1; /* skip '|' */ /* [ ... buf ] */ @@ -25312,44 +32698,50 @@ DUK_LOCAL void duk__dec_buffer(duk_json_dec_ctx *js_ctx) { DUK_LOCAL void duk__dec_number(duk_json_dec_ctx *js_ctx) { duk_context *ctx = (duk_context *) js_ctx->thr; const duk_uint8_t *p_start; - duk_small_int_t x; + const duk_uint8_t *p; + duk_uint8_t x; duk_small_uint_t s2n_flags; DUK_DDD(DUK_DDDPRINT("parse_number")); - /* Caller has already eaten the first character so backtrack one - * byte. This is correct because the first character is either - * '-' or a digit (i.e. an ASCII character). - */ - - js_ctx->p--; /* safe */ p_start = js_ctx->p; /* First pass parse is very lenient (e.g. allows '1.2.3') and extracts a * string for strict number parsing. */ + p = js_ctx->p; for (;;) { - x = duk__dec_peek(js_ctx); + x = *p; DUK_DDD(DUK_DDDPRINT("parse_number: p_start=%p, p=%p, p_end=%p, x=%ld", - (void *) p_start, (void *) js_ctx->p, - (void *) js_ctx->p_end, (long) x)); + (const void *) p_start, (const void *) p, + (const void *) js_ctx->p_end, (long) x)); +#if defined(DUK_USE_JSON_DECNUMBER_FASTPATH) + /* This fast path is pretty marginal in practice. + * XXX: candidate for removal. + */ + DUK_ASSERT(duk__json_decnumber_lookup[0x00] == 0x00); /* end-of-input breaks */ + if (duk__json_decnumber_lookup[x] == 0) { + break; + } +#else /* DUK_USE_JSON_DECNUMBER_FASTPATH */ if (!((x >= DUK_ASC_0 && x <= DUK_ASC_9) || (x == DUK_ASC_PERIOD || x == DUK_ASC_LC_E || x == DUK_ASC_UC_E || x == DUK_ASC_MINUS || x == DUK_ASC_PLUS))) { /* Plus sign must be accepted for positive exponents - * (e.g. '1.5e+2'). + * (e.g. '1.5e+2'). This clause catches NULs. */ break; } - - js_ctx->p++; /* safe, because matched char */ +#endif /* DUK_USE_JSON_DECNUMBER_FASTPATH */ + p++; /* safe, because matched (NUL causes a break) */ } + js_ctx->p = p; DUK_ASSERT(js_ctx->p > p_start); - duk_push_lstring(ctx, (const char *) p_start, (duk_size_t) (js_ctx->p - p_start)); + duk_push_lstring(ctx, (const char *) p_start, (duk_size_t) (p - p_start)); s2n_flags = DUK_S2N_FLAG_ALLOW_EXP | DUK_S2N_FLAG_ALLOW_MINUS | /* but don't allow leading plus */ @@ -25393,7 +32785,7 @@ DUK_LOCAL void duk__dec_objarr_exit(duk_json_dec_ctx *js_ctx) { DUK_LOCAL void duk__dec_object(duk_json_dec_ctx *js_ctx) { duk_context *ctx = (duk_context *) js_ctx->thr; duk_int_t key_count; /* XXX: a "first" flag would suffice */ - duk_small_int_t x; + duk_uint8_t x; DUK_DDD(DUK_DDDPRINT("parse_object")); @@ -25425,7 +32817,7 @@ DUK_LOCAL void duk__dec_object(duk_json_dec_ctx *js_ctx) { */ ; } else { - /* catches EOF (and initial comma) */ + /* catches EOF (NUL) and initial comma */ goto syntax_error; } @@ -25476,7 +32868,7 @@ DUK_LOCAL void duk__dec_object(duk_json_dec_ctx *js_ctx) { DUK_LOCAL void duk__dec_array(duk_json_dec_ctx *js_ctx) { duk_context *ctx = (duk_context *) js_ctx->thr; duk_uarridx_t arr_idx; - duk_small_int_t x; + duk_uint8_t x; DUK_DDD(DUK_DDDPRINT("parse_array")); @@ -25508,7 +32900,7 @@ DUK_LOCAL void duk__dec_array(duk_json_dec_ctx *js_ctx) { */ js_ctx->p--; /* backtrack (safe) */ } else { - /* catches EOF (and initial comma) */ + /* catches EOF (NUL) and initial comma */ goto syntax_error; } @@ -25543,7 +32935,7 @@ DUK_LOCAL void duk__dec_array(duk_json_dec_ctx *js_ctx) { DUK_LOCAL void duk__dec_value(duk_json_dec_ctx *js_ctx) { duk_context *ctx = (duk_context *) js_ctx->thr; - duk_small_int_t x; + duk_uint8_t x; x = duk__dec_get_nonwhite(js_ctx); @@ -25555,14 +32947,15 @@ DUK_LOCAL void duk__dec_value(duk_json_dec_ctx *js_ctx) { duk__dec_string(js_ctx); } else if ((x >= DUK_ASC_0 && x <= DUK_ASC_9) || (x == DUK_ASC_MINUS)) { #ifdef DUK_USE_JX - if (js_ctx->flag_ext_custom && duk__dec_peek(js_ctx) == DUK_ASC_UC_I) { - duk__dec_req_stridx(js_ctx, DUK_STRIDX_MINUS_INFINITY); /* "-Infinity" */ + if (js_ctx->flag_ext_custom && x == DUK_ASC_MINUS && duk__dec_peek(js_ctx) == DUK_ASC_UC_I) { + duk__dec_req_stridx(js_ctx, DUK_STRIDX_MINUS_INFINITY); /* "-Infinity", '-' has been eaten */ duk_push_number(ctx, -DUK_DOUBLE_INFINITY); } else { #else { /* unconditional block */ #endif - /* We already ate 'x', so duk__dec_number() will back up one byte. */ + /* We already ate 'x', so backup one byte. */ + js_ctx->p--; /* safe */ duk__dec_number(js_ctx); } } else if (x == DUK_ASC_LC_T) { @@ -25594,7 +32987,7 @@ DUK_LOCAL void duk__dec_value(duk_json_dec_ctx *js_ctx) { } else if (x == DUK_ASC_LBRACKET) { duk__dec_array(js_ctx); } else { - /* catches EOF */ + /* catches EOF (NUL) */ goto syntax_error; } @@ -25706,36 +33099,65 @@ DUK_LOCAL void duk__dec_reviver_walk(duk_json_dec_ctx *js_ctx) { */ #define DUK__EMIT_1(js_ctx,ch) duk__emit_1((js_ctx), (duk_uint_fast8_t) (ch)) -#define DUK__EMIT_2(js_ctx,ch1,ch2) duk__emit_2((js_ctx), (((duk_uint_fast16_t)(ch1)) << 8) + (duk_uint_fast16_t)(ch2)) -#define DUK__EMIT_ESC_AUTO(js_ctx,cp) duk__emit_esc_auto((js_ctx), (cp)) -#define DUK__EMIT_XUTF8(js_ctx,cp) duk__emit_xutf8((js_ctx), (cp)) +#define DUK__EMIT_2(js_ctx,ch1,ch2) duk__emit_2((js_ctx), (duk_uint_fast8_t) (ch1), (duk_uint_fast8_t) (ch2)) #define DUK__EMIT_HSTR(js_ctx,h) duk__emit_hstring((js_ctx), (h)) -#if defined(DUK_USE_JX) || defined(DUK_USE_JC) +#if defined(DUK_USE_FASTINT) || defined(DUK_USE_JX) || defined(DUK_USE_JC) #define DUK__EMIT_CSTR(js_ctx,p) duk__emit_cstring((js_ctx), (p)) #endif #define DUK__EMIT_STRIDX(js_ctx,i) duk__emit_stridx((js_ctx), (i)) +#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH) +#define DUK__UNEMIT_1(js_ctx) duk__unemit_1((js_ctx)) +#endif DUK_LOCAL void duk__emit_1(duk_json_enc_ctx *js_ctx, duk_uint_fast8_t ch) { - duk_hbuffer_append_byte(js_ctx->thr, js_ctx->h_buf, (duk_uint8_t) ch); + DUK_BW_WRITE_ENSURE_U8(js_ctx->thr, &js_ctx->bw, ch); } -DUK_LOCAL void duk__emit_2(duk_json_enc_ctx *js_ctx, duk_uint_fast16_t packed_chars) { - duk_uint8_t buf[2]; - buf[0] = (duk_uint8_t) (packed_chars >> 8); - buf[1] = (duk_uint8_t) (packed_chars & 0xff); - duk_hbuffer_append_bytes(js_ctx->thr, js_ctx->h_buf, (duk_uint8_t *) buf, 2); +DUK_LOCAL void duk__emit_2(duk_json_enc_ctx *js_ctx, duk_uint_fast8_t ch1, duk_uint_fast8_t ch2) { + DUK_BW_WRITE_ENSURE_U8_2(js_ctx->thr, &js_ctx->bw, ch1, ch2); } +DUK_LOCAL void duk__emit_hstring(duk_json_enc_ctx *js_ctx, duk_hstring *h) { + DUK_BW_WRITE_ENSURE_HSTRING(js_ctx->thr, &js_ctx->bw, h); +} + +#if defined(DUK_USE_FASTINT) || defined(DUK_USE_JX) || defined(DUK_USE_JC) +DUK_LOCAL void duk__emit_cstring(duk_json_enc_ctx *js_ctx, const char *str) { + DUK_BW_WRITE_ENSURE_CSTRING(js_ctx->thr, &js_ctx->bw, str); +} +#endif + +DUK_LOCAL void duk__emit_stridx(duk_json_enc_ctx *js_ctx, duk_small_uint_t stridx) { + duk_hstring *h; + + DUK_ASSERT_DISABLE(stridx >= 0); /* unsigned */ + DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); + h = DUK_HTHREAD_GET_STRING(js_ctx->thr, stridx); + DUK_ASSERT(h != NULL); + + DUK_BW_WRITE_ENSURE_HSTRING(js_ctx->thr, &js_ctx->bw, h); +} + +#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH) +DUK_LOCAL void duk__unemit_1(duk_json_enc_ctx *js_ctx) { + DUK_ASSERT(DUK_BW_GET_SIZE(js_ctx->thr, &js_ctx->bw) >= 1); + DUK_BW_ADD_PTR(js_ctx->thr, &js_ctx->bw, -1); +} +#endif /* DUK_USE_JSON_STRINGIFY_FASTPATH */ + #define DUK__MKESC(nybbles,esc1,esc2) \ (((duk_uint_fast32_t) (nybbles)) << 16) | \ (((duk_uint_fast32_t) (esc1)) << 8) | \ ((duk_uint_fast32_t) (esc2)) -DUK_LOCAL void duk__emit_esc_auto(duk_json_enc_ctx *js_ctx, duk_uint_fast32_t cp) { - duk_uint8_t buf[2]; +DUK_LOCAL duk_uint8_t *duk__emit_esc_auto_fast(duk_json_enc_ctx *js_ctx, duk_uint_fast32_t cp, duk_uint8_t *q) { duk_uint_fast32_t tmp; duk_small_uint_t dig; + DUK_UNREF(js_ctx); + + /* Caller ensures space for at least DUK__JSON_MAX_ESC_LEN. */ + /* Select appropriate escape format automatically, and set 'tmp' to a * value encoding both the escape format character and the nybble count: * @@ -25769,41 +33191,17 @@ DUK_LOCAL void duk__emit_esc_auto(duk_json_enc_ctx *js_ctx, duk_uint_fast32_t cp } } - buf[0] = (duk_uint8_t) ((tmp >> 8) & 0xff); - buf[1] = (duk_uint8_t) (tmp & 0xff); - duk_hbuffer_append_bytes(js_ctx->thr, js_ctx->h_buf, buf, 2); + *q++ = (duk_uint8_t) ((tmp >> 8) & 0xff); + *q++ = (duk_uint8_t) (tmp & 0xff); tmp = tmp >> 16; while (tmp > 0) { tmp--; dig = (duk_small_uint_t) ((cp >> (4 * tmp)) & 0x0f); - duk_hbuffer_append_byte(js_ctx->thr, js_ctx->h_buf, duk_lc_digits[dig]); + *q++ = duk_lc_digits[dig]; } -} -DUK_LOCAL void duk__emit_xutf8(duk_json_enc_ctx *js_ctx, duk_uint_fast32_t cp) { - (void) duk_hbuffer_append_xutf8(js_ctx->thr, js_ctx->h_buf, cp); -} - -DUK_LOCAL void duk__emit_hstring(duk_json_enc_ctx *js_ctx, duk_hstring *h) { - DUK_ASSERT(h != NULL); - duk_hbuffer_append_bytes(js_ctx->thr, - js_ctx->h_buf, - (duk_uint8_t *) DUK_HSTRING_GET_DATA(h), - (duk_size_t) DUK_HSTRING_GET_BYTELEN(h)); -} - -#if defined(DUK_USE_JX) || defined(DUK_USE_JC) -DUK_LOCAL void duk__emit_cstring(duk_json_enc_ctx *js_ctx, const char *p) { - DUK_ASSERT(p != NULL); - (void) duk_hbuffer_append_cstring(js_ctx->thr, js_ctx->h_buf, p); -} -#endif - -DUK_LOCAL void duk__emit_stridx(duk_json_enc_ctx *js_ctx, duk_small_uint_t stridx) { - DUK_ASSERT_DISABLE(stridx >= 0); /* unsigned */ - DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); - duk__emit_hstring(js_ctx, DUK_HTHREAD_GET_STRING(js_ctx->thr, stridx)); + return q; } /* Check whether key quotes would be needed (custom encoding). */ @@ -25817,7 +33215,8 @@ DUK_LOCAL duk_bool_t duk__enc_key_quotes_needed(duk_hstring *h_key) { p = p_start; DUK_DDD(DUK_DDDPRINT("duk__enc_key_quotes_needed: h_key=%!O, p_start=%p, p_end=%p, p=%p", - (duk_heaphdr *) h_key, (void *) p_start, (void *) p_end, (void *) p)); + (duk_heaphdr *) h_key, (const void *) p_start, + (const void *) p_end, (const void *) p)); /* Since we only accept ASCII characters, there is no need for * actual decoding. A non-ASCII character will be >= 0x80 which @@ -25848,21 +33247,26 @@ DUK_LOCAL duk_bool_t duk__enc_key_quotes_needed(duk_hstring *h_key) { return 0; } +DUK_LOCAL void duk__enc_key_autoquote(duk_json_enc_ctx *js_ctx, duk_hstring *k) { + /* XXX: could reimplement so that we start emitting the key without + * quotes and backtrack if we hit a problem character. + */ + if (js_ctx->flag_avoid_key_quotes && !duk__enc_key_quotes_needed(k)) { + DUK__EMIT_HSTR(js_ctx, k); + } else { + duk__enc_quote_string(js_ctx, k); + } +} + /* The Quote(value) operation: quote a string. * * Stack policy: [ ] -> [ ]. */ -DUK_LOCAL duk_uint8_t duk__quote_esc[14] = { - DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL, - DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL, - DUK_ASC_LC_B, DUK_ASC_LC_T, DUK_ASC_LC_N, DUK_ASC_NUL, - DUK_ASC_LC_F, DUK_ASC_LC_R -}; - DUK_LOCAL void duk__enc_quote_string(duk_json_enc_ctx *js_ctx, duk_hstring *h_str) { duk_hthread *thr = js_ctx->thr; - const duk_uint8_t *p, *p_start, *p_end, *p_tmp; + const duk_uint8_t *p, *p_start, *p_end, *p_now, *p_tmp; + duk_uint8_t *q; duk_ucodepoint_t cp; /* typed for duk_unicode_decode_xutf8() */ DUK_DDD(DUK_DDDPRINT("duk__enc_quote_string: h_str=%!O", (duk_heaphdr *) h_str)); @@ -25874,97 +33278,517 @@ DUK_LOCAL void duk__enc_quote_string(duk_json_enc_ctx *js_ctx, duk_hstring *h_st DUK__EMIT_1(js_ctx, DUK_ASC_DOUBLEQUOTE); + /* Encode string in small chunks, estimating the maximum expansion so that + * there's no need to ensure space while processing the chunk. + */ + while (p < p_end) { - cp = *p; + duk_size_t left, now, space; - if (DUK_LIKELY(cp <= 0x7f)) { - /* ascii fast path: avoid decoding utf-8 */ - p++; - if (cp == 0x22 || cp == 0x5c) { - /* double quote or backslash */ - DUK__EMIT_2(js_ctx, DUK_ASC_BACKSLASH, cp); - } else if (cp < 0x20) { - duk_uint_fast8_t esc_char; + left = (duk_size_t) (p_end - p); + now = (left > DUK__JSON_ENCSTR_CHUNKSIZE ? + DUK__JSON_ENCSTR_CHUNKSIZE : left); - /* This approach is a bit shorter than a straight - * if-else-ladder and also a bit faster. - */ - if (cp < (sizeof(duk__quote_esc) / sizeof(duk_uint8_t)) && - (esc_char = duk__quote_esc[cp]) != 0) { - DUK__EMIT_2(js_ctx, DUK_ASC_BACKSLASH, esc_char); - } else { - DUK__EMIT_ESC_AUTO(js_ctx, cp); - } - } else if (cp == 0x7f && js_ctx->flag_ascii_only) { - DUK__EMIT_ESC_AUTO(js_ctx, cp); + /* Maximum expansion per input byte is 6: + * - invalid UTF-8 byte causes "\uXXXX" to be emitted (6/1 = 6). + * - 2-byte UTF-8 encodes as "\uXXXX" (6/2 = 3). + * - 4-byte UTF-8 encodes as "\Uxxxxxxxx" (10/4 = 2.5). + */ + space = now * 6; + q = DUK_BW_ENSURE_GETPTR(thr, &js_ctx->bw, space); + + p_now = p + now; + + while (p < p_now) { +#if defined(DUK_USE_JSON_QUOTESTRING_FASTPATH) + duk_uint8_t b; + + b = duk__json_quotestr_lookup[*p++]; + if (DUK_LIKELY(b < 0x80)) { + /* Most input bytes go through here. */ + *q++ = b; + } else if (b >= 0xa0) { + *q++ = DUK_ASC_BACKSLASH; + *q++ = (duk_uint8_t) (b - 0x80); + } else if (b == 0x80) { + cp = (duk_ucodepoint_t) (*(p - 1)); + q = duk__emit_esc_auto_fast(js_ctx, cp, q); + } else if (b == 0x7f && js_ctx->flag_ascii_only) { + /* 0x7F is special */ + DUK_ASSERT(b == 0x81); + cp = (duk_ucodepoint_t) 0x7f; + q = duk__emit_esc_auto_fast(js_ctx, cp, q); } else { - /* any other printable -> as is */ - DUK__EMIT_1(js_ctx, cp); - } - } else { - /* slow path decode */ + DUK_ASSERT(b == 0x81); + p--; - /* If XUTF-8 decoding fails, treat the offending byte as a codepoint directly - * and go forward one byte. This is of course very lossy, but allows some kind - * of output to be produced even for internal strings which don't conform to - * XUTF-8. All standard Ecmascript strings are always CESU-8, so this behavior - * does not violate the Ecmascript specification. The behavior is applied to - * all modes, including Ecmascript standard JSON. Because the current XUTF-8 - * decoding is not very strict, this behavior only really affects initial bytes - * and truncated codepoints. - * - * XXX: another alternative would be to scan forwards to start of next codepoint - * (or end of input) and emit just one replacement codepoint. - */ + /* slow path is shared */ +#else /* DUK_USE_JSON_QUOTESTRING_FASTPATH */ + cp = *p; - p_tmp = p; - if (!duk_unicode_decode_xutf8(thr, &p, p_start, p_end, &cp)) { - /* Decode failed. */ - cp = *p_tmp; - p = p_tmp + 1; - } + if (DUK_LIKELY(cp <= 0x7f)) { + /* ascii fast path: avoid decoding utf-8 */ + p++; + if (cp == 0x22 || cp == 0x5c) { + /* double quote or backslash */ + *q++ = DUK_ASC_BACKSLASH; + *q++ = (duk_uint8_t) cp; + } else if (cp < 0x20) { + duk_uint_fast8_t esc_char; + + /* This approach is a bit shorter than a straight + * if-else-ladder and also a bit faster. + */ + if (cp < (sizeof(duk__json_quotestr_esc) / sizeof(duk_uint8_t)) && + (esc_char = duk__json_quotestr_esc[cp]) != 0) { + *q++ = DUK_ASC_BACKSLASH; + *q++ = (duk_uint8_t) esc_char; + } else { + q = duk__emit_esc_auto_fast(js_ctx, cp, q); + } + } else if (cp == 0x7f && js_ctx->flag_ascii_only) { + q = duk__emit_esc_auto_fast(js_ctx, cp, q); + } else { + /* any other printable -> as is */ + *q++ = (duk_uint8_t) cp; + } + } else { + /* slow path is shared */ +#endif /* DUK_USE_JSON_QUOTESTRING_FASTPATH */ + + /* slow path decode */ + + /* If XUTF-8 decoding fails, treat the offending byte as a codepoint directly + * and go forward one byte. This is of course very lossy, but allows some kind + * of output to be produced even for internal strings which don't conform to + * XUTF-8. All standard Ecmascript strings are always CESU-8, so this behavior + * does not violate the Ecmascript specification. The behavior is applied to + * all modes, including Ecmascript standard JSON. Because the current XUTF-8 + * decoding is not very strict, this behavior only really affects initial bytes + * and truncated codepoints. + * + * Another alternative would be to scan forwards to start of next codepoint + * (or end of input) and emit just one replacement codepoint. + */ + + p_tmp = p; + if (!duk_unicode_decode_xutf8(thr, &p, p_start, p_end, &cp)) { + /* Decode failed. */ + cp = *p_tmp; + p = p_tmp + 1; + } #ifdef DUK_USE_NONSTD_JSON_ESC_U2028_U2029 - if (js_ctx->flag_ascii_only || cp == 0x2028 || cp == 0x2029) { + if (js_ctx->flag_ascii_only || cp == 0x2028 || cp == 0x2029) { #else - if (js_ctx->flag_ascii_only) { + if (js_ctx->flag_ascii_only) { #endif - DUK__EMIT_ESC_AUTO(js_ctx, cp); - } else { - /* as is */ - DUK__EMIT_XUTF8(js_ctx, cp); + q = duk__emit_esc_auto_fast(js_ctx, cp, q); + } else { + /* as is */ + DUK_RAW_WRITE_XUTF8(q, cp); + } } } + + DUK_BW_SET_PTR(thr, &js_ctx->bw, q); } DUK__EMIT_1(js_ctx, DUK_ASC_DOUBLEQUOTE); } -/* Shared entry handling for object/array serialization: indent/stepback, - * loop detection. +/* Encode a double (checked by caller) from stack top. Stack top may be + * replaced by serialized string but is not popped (caller does that). */ -DUK_LOCAL void duk__enc_objarr_entry(duk_json_enc_ctx *js_ctx, duk_hstring **h_stepback, duk_hstring **h_indent, duk_idx_t *entry_top) { +DUK_LOCAL void duk__enc_double(duk_json_enc_ctx *js_ctx) { + duk_context *ctx; + duk_tval *tv; + duk_double_t d; + duk_small_int_t c; + duk_small_int_t s; + duk_small_uint_t stridx; + duk_small_uint_t n2s_flags; + duk_hstring *h_str; + + DUK_ASSERT(js_ctx != NULL); + ctx = (duk_context *) js_ctx->thr; + DUK_ASSERT(ctx != NULL); + + /* Caller must ensure 'tv' is indeed a double and not a fastint! */ + tv = duk_get_tval(ctx, -1); + DUK_ASSERT(tv != NULL); + DUK_ASSERT(DUK_TVAL_IS_DOUBLE(tv)); + d = DUK_TVAL_GET_DOUBLE(tv); + + c = (duk_small_int_t) DUK_FPCLASSIFY(d); + s = (duk_small_int_t) DUK_SIGNBIT(d); + DUK_UNREF(s); + + if (DUK_LIKELY(!(c == DUK_FP_INFINITE || c == DUK_FP_NAN))) { + DUK_ASSERT(DUK_ISFINITE(d)); + +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + /* Negative zero needs special handling in JX/JC because + * it would otherwise serialize to '0', not '-0'. + */ + if (DUK_UNLIKELY(c == DUK_FP_ZERO && s != 0 && + (js_ctx->flag_ext_custom_or_compatible))) { + duk_push_hstring_stridx(ctx, DUK_STRIDX_MINUS_ZERO); /* '-0' */ + } else +#endif /* DUK_USE_JX || DUK_USE_JC */ + { + n2s_flags = 0; + /* [ ... number ] -> [ ... string ] */ + duk_numconv_stringify(ctx, 10 /*radix*/, 0 /*digits*/, n2s_flags); + } + h_str = duk_to_hstring(ctx, -1); + DUK_ASSERT(h_str != NULL); + DUK__EMIT_HSTR(js_ctx, h_str); + return; + } + +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + if (!(js_ctx->flags & (DUK_JSON_FLAG_EXT_CUSTOM | + DUK_JSON_FLAG_EXT_COMPATIBLE))) { + stridx = DUK_STRIDX_LC_NULL; + } else if (c == DUK_FP_NAN) { + stridx = js_ctx->stridx_custom_nan; + } else if (s == 0) { + stridx = js_ctx->stridx_custom_posinf; + } else { + stridx = js_ctx->stridx_custom_neginf; + } +#else + stridx = DUK_STRIDX_LC_NULL; +#endif + DUK__EMIT_STRIDX(js_ctx, stridx); +} + +#if defined(DUK_USE_FASTINT) +/* Encode a fastint from duk_tval ptr, no value stack effects. */ +DUK_LOCAL void duk__enc_fastint_tval(duk_json_enc_ctx *js_ctx, duk_tval *tv) { + duk_int64_t v; + + /* Fastint range is signed 48-bit so longest value is -2^47 = -140737488355328 + * (16 chars long), longest signed 64-bit value is -2^63 = -9223372036854775808 + * (20 chars long). Alloc space for 64-bit range to be safe. + */ + duk_uint8_t buf[20 + 1]; + + /* Caller must ensure 'tv' is indeed a fastint! */ + DUK_ASSERT(DUK_TVAL_IS_FASTINT(tv)); + v = DUK_TVAL_GET_FASTINT(tv); + + /* XXX: There are no format strings in duk_config.h yet, could add + * one for formatting duk_int64_t. For now, assumes "%lld" and that + * "long long" type exists. Could also rely on C99 directly but that + * won't work for older MSVC. + */ + DUK_SPRINTF((char *) buf, "%lld", (long long) v); + DUK__EMIT_CSTR(js_ctx, (const char *) buf); +} +#endif + +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) +#if defined(DUK_USE_HEX_FASTPATH) +DUK_LOCAL duk_uint8_t *duk__enc_buffer_data_hex(const duk_uint8_t *src, duk_size_t src_len, duk_uint8_t *dst) { + duk_uint8_t *q; + duk_uint16_t *q16; + duk_small_uint_t x; + duk_size_t i, len_safe; +#if !defined(DUK_USE_UNALIGNED_ACCESSES_POSSIBLE) + duk_bool_t shift_dst; +#endif + + /* Unlike in duk_hex_encode() 'dst' is not necessarily aligned by 2. + * For platforms where unaligned accesses are not allowed, shift 'dst' + * ahead by 1 byte to get alignment and then DUK_MEMMOVE() the result + * in place. The faster encoding loop makes up the difference. + * There's always space for one extra byte because a terminator always + * follows the hex data and that's been accounted for by the caller. + */ + +#if defined(DUK_USE_UNALIGNED_ACCESSES_POSSIBLE) + q16 = (duk_uint16_t *) (void *) dst; +#else + shift_dst = (duk_bool_t) (((duk_uintptr_t) dst) & 0x01U); + if (shift_dst) { + DUK_DD(DUK_DDPRINT("unaligned accesses not possible, dst not aligned -> step to dst + 1")); + q16 = (duk_uint16_t *) (void *) (dst + 1); + } else { + DUK_DD(DUK_DDPRINT("unaligned accesses not possible, dst is aligned")); + q16 = (duk_uint16_t *) (void *) dst; + } + DUK_ASSERT((((duk_uintptr_t) q16) & 0x01U) == 0); +#endif + + len_safe = src_len & ~0x03U; + for (i = 0; i < len_safe; i += 4) { + q16[0] = duk_hex_enctab[src[i]]; + q16[1] = duk_hex_enctab[src[i + 1]]; + q16[2] = duk_hex_enctab[src[i + 2]]; + q16[3] = duk_hex_enctab[src[i + 3]]; + q16 += 4; + } + q = (duk_uint8_t *) q16; + +#if !defined(DUK_USE_UNALIGNED_ACCESSES_POSSIBLE) + if (shift_dst) { + q--; + DUK_MEMMOVE((void *) dst, (const void *) (dst + 1), 2 * len_safe); + DUK_ASSERT(dst + 2 * len_safe == q); + } +#endif + + for (; i < src_len; i++) { + x = src[i]; + *q++ = duk_lc_digits[x >> 4]; + *q++ = duk_lc_digits[x & 0x0f]; + } + + return q; +} +#else /* DUK_USE_HEX_FASTPATH */ +DUK_LOCAL duk_uint8_t *duk__enc_buffer_data_hex(const duk_uint8_t *src, duk_size_t src_len, duk_uint8_t *dst) { + const duk_uint8_t *p; + const duk_uint8_t *p_end; + duk_uint8_t *q; + duk_small_uint_t x; + + p = src; + p_end = src + src_len; + q = dst; + while (p != p_end) { + x = *p++; + *q++ = duk_lc_digits[x >> 4]; + *q++ = duk_lc_digits[x & 0x0f]; + } + + return q; +} +#endif /* DUK_USE_HEX_FASTPATH */ + +DUK_LOCAL void duk__enc_buffer_data(duk_json_enc_ctx *js_ctx, duk_uint8_t *buf_data, duk_size_t buf_len) { + duk_hthread *thr; + duk_uint8_t *q; + duk_size_t space; + + thr = js_ctx->thr; + + DUK_ASSERT(js_ctx->flag_ext_custom || js_ctx->flag_ext_compatible); /* caller checks */ + DUK_ASSERT(js_ctx->flag_ext_custom_or_compatible); + + /* Buffer values are encoded in (lowercase) hex to make the + * binary data readable. Base64 or similar would be more + * compact but less readable, and the point of JX/JC + * variants is to be as useful to a programmer as possible. + */ + + /* The #ifdef clutter here needs to handle the three cases: + * (1) JX+JC, (2) JX only, (3) JC only. + */ + + /* Note: space must cater for both JX and JC. */ + space = 9 + buf_len * 2 + 2; + DUK_ASSERT(DUK_HBUFFER_MAX_BYTELEN <= 0x7ffffffeUL); + DUK_ASSERT((space - 2) / 2 >= buf_len); /* overflow not possible, buffer limits */ + q = DUK_BW_ENSURE_GETPTR(thr, &js_ctx->bw, space); + +#if defined(DUK_USE_JX) && defined(DUK_USE_JC) + if (js_ctx->flag_ext_custom) +#endif +#if defined(DUK_USE_JX) + { + *q++ = DUK_ASC_PIPE; + q = duk__enc_buffer_data_hex(buf_data, buf_len, q); + *q++ = DUK_ASC_PIPE; + + } +#endif +#if defined(DUK_USE_JX) && defined(DUK_USE_JC) + else +#endif +#if defined(DUK_USE_JC) + { + DUK_ASSERT(js_ctx->flag_ext_compatible); + DUK_MEMCPY((void *) q, (const void *) "{\"_buf\":\"", 9); /* len: 9 */ + q += 9; + q = duk__enc_buffer_data_hex(buf_data, buf_len, q); + *q++ = DUK_ASC_DOUBLEQUOTE; + *q++ = DUK_ASC_RCURLY; + } +#endif + + DUK_BW_SET_PTR(thr, &js_ctx->bw, q); +} + +DUK_LOCAL void duk__enc_buffer(duk_json_enc_ctx *js_ctx, duk_hbuffer *h) { + duk__enc_buffer_data(js_ctx, + (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(js_ctx->thr->heap, h), + (duk_size_t) DUK_HBUFFER_GET_SIZE(h)); +} +#endif /* DUK_USE_JX || DUK_USE_JC */ + +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) +DUK_LOCAL void duk__enc_pointer(duk_json_enc_ctx *js_ctx, void *ptr) { + char buf[64]; /* XXX: how to figure correct size? */ + const char *fmt; + + DUK_ASSERT(js_ctx->flag_ext_custom || js_ctx->flag_ext_compatible); /* caller checks */ + DUK_ASSERT(js_ctx->flag_ext_custom_or_compatible); + + DUK_MEMZERO(buf, sizeof(buf)); + + /* The #ifdef clutter here needs to handle the three cases: + * (1) JX+JC, (2) JX only, (3) JC only. + */ +#if defined(DUK_USE_JX) && defined(DUK_USE_JC) + if (js_ctx->flag_ext_custom) +#endif +#if defined(DUK_USE_JX) + { + fmt = ptr ? "(%p)" : "(null)"; + } +#endif +#if defined(DUK_USE_JX) && defined(DUK_USE_JC) + else +#endif +#if defined(DUK_USE_JC) + { + DUK_ASSERT(js_ctx->flag_ext_compatible); + fmt = ptr ? "{\"_ptr\":\"%p\"}" : "{\"_ptr\":\"null\"}"; + } +#endif + + /* When ptr == NULL, the format argument is unused. */ + DUK_SNPRINTF(buf, sizeof(buf) - 1, fmt, ptr); /* must not truncate */ + DUK__EMIT_CSTR(js_ctx, buf); +} +#endif /* DUK_USE_JX || DUK_USE_JC */ + +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) +#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH) +DUK_LOCAL void duk__enc_bufferobject(duk_json_enc_ctx *js_ctx, duk_hbufferobject *h_bufobj) { + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + + if (h_bufobj->buf == NULL || !DUK_HBUFFEROBJECT_VALID_SLICE(h_bufobj)) { + DUK__EMIT_STRIDX(js_ctx, DUK_STRIDX_LC_NULL); + } else { + /* Handle both full and partial slice (as long as covered). */ + duk__enc_buffer_data(js_ctx, + (duk_uint8_t *) DUK_HBUFFEROBJECT_GET_SLICE_BASE(js_ctx->thr->heap, h_bufobj), + (duk_size_t) h_bufobj->length); + } +} +#endif /* DUK_USE_JSON_STRINGIFY_FASTPATH */ +#endif /* DUK_USE_JX || DUK_USE_JC */ + +/* Indent helper. Calling code relies on js_ctx->recursion_depth also being + * directly related to indent depth. + */ +#if defined(DUK_USE_PREFER_SIZE) +DUK_LOCAL void duk__enc_newline_indent(duk_json_enc_ctx *js_ctx, duk_int_t depth) { + DUK_ASSERT(js_ctx->h_gap != NULL); + DUK_ASSERT(DUK_HSTRING_GET_BYTELEN(js_ctx->h_gap) > 0); /* caller guarantees */ + + DUK__EMIT_1(js_ctx, 0x0a); + while (depth-- > 0) { + DUK__EMIT_HSTR(js_ctx, js_ctx->h_gap); + } +} +#else /* DUK_USE_PREFER_SIZE */ +DUK_LOCAL void duk__enc_newline_indent(duk_json_enc_ctx *js_ctx, duk_int_t depth) { + const duk_uint8_t *gap_data; + duk_size_t gap_len; + duk_size_t avail_bytes; /* bytes of indent available for copying */ + duk_size_t need_bytes; /* bytes of indent still needed */ + duk_uint8_t *p_start; + duk_uint8_t *p; + + DUK_ASSERT(js_ctx->h_gap != NULL); + DUK_ASSERT(DUK_HSTRING_GET_BYTELEN(js_ctx->h_gap) > 0); /* caller guarantees */ + + DUK__EMIT_1(js_ctx, 0x0a); + if (DUK_UNLIKELY(depth == 0)) { + return; + } + + /* To handle deeper indents efficiently, make use of copies we've + * already emitted. In effect we can emit a sequence of 1, 2, 4, + * 8, etc copies, and then finish the last run. Byte counters + * avoid multiply with gap_len on every loop. + */ + + gap_data = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(js_ctx->h_gap); + gap_len = (duk_size_t) DUK_HSTRING_GET_BYTELEN(js_ctx->h_gap); + DUK_ASSERT(gap_len > 0); + + need_bytes = gap_len * depth; + p = DUK_BW_ENSURE_GETPTR(js_ctx->thr, &js_ctx->bw, need_bytes); + p_start = p; + + DUK_MEMCPY((void *) p, (const void *) gap_data, (size_t) gap_len); + p += gap_len; + avail_bytes = gap_len; + DUK_ASSERT(need_bytes >= gap_len); + need_bytes -= gap_len; + + while (need_bytes >= avail_bytes) { + DUK_MEMCPY((void *) p, (const void *) p_start, (size_t) avail_bytes); + p += avail_bytes; + need_bytes -= avail_bytes; + avail_bytes <<= 1; + } + + DUK_ASSERT(need_bytes < avail_bytes); /* need_bytes may be zero */ + DUK_MEMCPY((void *) p, (const void *) p_start, (size_t) need_bytes); + p += need_bytes; + /*avail_bytes += need_bytes*/ + + DUK_BW_SET_PTR(js_ctx->thr, &js_ctx->bw, p); +} +#endif /* DUK_USE_PREFER_SIZE */ + +/* Shared entry handling for object/array serialization. */ +DUK_LOCAL void duk__enc_objarr_entry(duk_json_enc_ctx *js_ctx, duk_idx_t *entry_top) { duk_context *ctx = (duk_context *) js_ctx->thr; duk_hobject *h_target; + duk_uint_fast32_t i, n; *entry_top = duk_get_top(ctx); duk_require_stack(ctx, DUK_JSON_ENC_REQSTACK); - /* loop check */ + /* Loop check using a hybrid approach: a fixed-size visited[] array + * with overflow in a loop check object. + */ h_target = duk_get_hobject(ctx, -1); /* object or array */ DUK_ASSERT(h_target != NULL); - duk_push_sprintf(ctx, DUK_STR_FMT_PTR, (void *) h_target); - duk_dup_top(ctx); /* -> [ ... voidp voidp ] */ - if (duk_has_prop(ctx, js_ctx->idx_loop)) { - DUK_ERROR((duk_hthread *) ctx, DUK_ERR_TYPE_ERROR, DUK_STR_CYCLIC_INPUT); + n = js_ctx->recursion_depth; + if (DUK_UNLIKELY(n > DUK_JSON_ENC_LOOPARRAY)) { + n = DUK_JSON_ENC_LOOPARRAY; + } + for (i = 0; i < n; i++) { + if (DUK_UNLIKELY(js_ctx->visiting[i] == h_target)) { + DUK_DD(DUK_DDPRINT("slow path loop detect")); + DUK_ERROR(js_ctx->thr, DUK_ERR_TYPE_ERROR, DUK_STR_CYCLIC_INPUT); + } + } + if (js_ctx->recursion_depth < DUK_JSON_ENC_LOOPARRAY) { + js_ctx->visiting[js_ctx->recursion_depth] = h_target; + } else { + duk_push_sprintf(ctx, DUK_STR_FMT_PTR, (void *) h_target); + duk_dup_top(ctx); /* -> [ ... voidp voidp ] */ + if (duk_has_prop(ctx, js_ctx->idx_loop)) { + DUK_ERROR((duk_hthread *) ctx, DUK_ERR_TYPE_ERROR, DUK_STR_CYCLIC_INPUT); + } + duk_push_true(ctx); /* -> [ ... voidp true ] */ + duk_put_prop(ctx, js_ctx->idx_loop); /* -> [ ... ] */ } - duk_push_true(ctx); /* -> [ ... voidp true ] */ - duk_put_prop(ctx, js_ctx->idx_loop); /* -> [ ... ] */ - /* c recursion check */ + /* C recursion check. */ DUK_ASSERT(js_ctx->recursion_depth >= 0); DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit); @@ -25973,70 +33797,34 @@ DUK_LOCAL void duk__enc_objarr_entry(duk_json_enc_ctx *js_ctx, duk_hstring **h_s } js_ctx->recursion_depth++; - /* figure out indent and stepback */ - - *h_indent = NULL; - *h_stepback = NULL; - if (js_ctx->h_gap != NULL) { - DUK_ASSERT(js_ctx->h_indent != NULL); - - *h_stepback = js_ctx->h_indent; - duk_push_hstring(ctx, js_ctx->h_indent); - duk_push_hstring(ctx, js_ctx->h_gap); - duk_concat(ctx, 2); - js_ctx->h_indent = duk_get_hstring(ctx, -1); - *h_indent = js_ctx->h_indent; - DUK_ASSERT(js_ctx->h_indent != NULL); - - /* The new indent string is left at value stack top, and will - * be popped by the shared exit handler. - */ - } else { - DUK_ASSERT(js_ctx->h_indent == NULL); - } - DUK_DDD(DUK_DDDPRINT("shared entry finished: top=%ld, loop=%!T", (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop))); } /* Shared exit handling for object/array serialization. */ -DUK_LOCAL void duk__enc_objarr_exit(duk_json_enc_ctx *js_ctx, duk_hstring **h_stepback, duk_hstring **h_indent, duk_idx_t *entry_top) { +DUK_LOCAL void duk__enc_objarr_exit(duk_json_enc_ctx *js_ctx, duk_idx_t *entry_top) { duk_context *ctx = (duk_context *) js_ctx->thr; duk_hobject *h_target; - DUK_UNREF(h_indent); - - if (js_ctx->h_gap != NULL) { - DUK_ASSERT(js_ctx->h_indent != NULL); - DUK_ASSERT(*h_stepback != NULL); - DUK_ASSERT(*h_indent != NULL); - - js_ctx->h_indent = *h_stepback; /* previous js_ctx->h_indent */ - - /* Note: we don't need to pop anything because the duk_set_top() - * at the end will take care of it. - */ - } else { - DUK_ASSERT(js_ctx->h_indent == NULL); - DUK_ASSERT(*h_stepback == NULL); - DUK_ASSERT(*h_indent == NULL); - } - - /* c recursion check */ + /* C recursion check. */ DUK_ASSERT(js_ctx->recursion_depth > 0); DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit); js_ctx->recursion_depth--; - /* loop check */ + /* Loop check. */ h_target = duk_get_hobject(ctx, *entry_top - 1); /* original target at entry_top - 1 */ DUK_ASSERT(h_target != NULL); - duk_push_sprintf(ctx, DUK_STR_FMT_PTR, (void *) h_target); - duk_del_prop(ctx, js_ctx->idx_loop); /* -> [ ... ] */ + if (js_ctx->recursion_depth < DUK_JSON_ENC_LOOPARRAY) { + /* Previous entry was inside visited[], nothing to do. */ + } else { + duk_push_sprintf(ctx, DUK_STR_FMT_PTR, (void *) h_target); + duk_del_prop(ctx, js_ctx->idx_loop); /* -> [ ... ] */ + } - /* restore stack top after unbalanced code paths */ + /* Restore stack top after unbalanced code paths. */ duk_set_top(ctx, *entry_top); DUK_DDD(DUK_DDDPRINT("shared entry finished: top=%ld, loop=%!T", @@ -26049,8 +33837,6 @@ DUK_LOCAL void duk__enc_objarr_exit(duk_json_enc_ctx *js_ctx, duk_hstring **h_st */ DUK_LOCAL void duk__enc_object(duk_json_enc_ctx *js_ctx) { duk_context *ctx = (duk_context *) js_ctx->thr; - duk_hstring *h_stepback; - duk_hstring *h_indent; duk_hstring *h_key; duk_idx_t entry_top; duk_idx_t idx_obj; @@ -26061,7 +33847,7 @@ DUK_LOCAL void duk__enc_object(duk_json_enc_ctx *js_ctx) { DUK_DDD(DUK_DDDPRINT("duk__enc_object: obj=%!T", (duk_tval *) duk_get_tval(ctx, -1))); - duk__enc_objarr_entry(js_ctx, &h_stepback, &h_indent, &entry_top); + duk__enc_objarr_entry(js_ctx, &entry_top); idx_obj = entry_top - 1; @@ -26112,21 +33898,16 @@ DUK_LOCAL void duk__enc_object(duk_json_enc_ctx *js_ctx) { } else { DUK__EMIT_1(js_ctx, DUK_ASC_COMMA); } - if (h_indent != NULL) { - DUK__EMIT_1(js_ctx, 0x0a); - DUK__EMIT_HSTR(js_ctx, h_indent); + if (js_ctx->h_gap != NULL) { + DUK_ASSERT(js_ctx->recursion_depth >= 1); + duk__enc_newline_indent(js_ctx, js_ctx->recursion_depth); } h_key = duk_get_hstring(ctx, -2); DUK_ASSERT(h_key != NULL); - if (js_ctx->flag_avoid_key_quotes && !duk__enc_key_quotes_needed(h_key)) { - /* emit key as is */ - DUK__EMIT_HSTR(js_ctx, h_key); - } else { - duk__enc_quote_string(js_ctx, h_key); - } + duk__enc_key_autoquote(js_ctx, h_key); - if (h_indent != NULL) { + if (js_ctx->h_gap != NULL) { DUK__EMIT_2(js_ctx, DUK_ASC_COLON, DUK_ASC_SPACE); } else { DUK__EMIT_1(js_ctx, DUK_ASC_COLON); @@ -26138,15 +33919,14 @@ DUK_LOCAL void duk__enc_object(duk_json_enc_ctx *js_ctx) { } if (!first) { - if (h_stepback != NULL) { - DUK_ASSERT(h_indent != NULL); - DUK__EMIT_1(js_ctx, 0x0a); - DUK__EMIT_HSTR(js_ctx, h_stepback); + if (js_ctx->h_gap != NULL) { + DUK_ASSERT(js_ctx->recursion_depth >= 1); + duk__enc_newline_indent(js_ctx, js_ctx->recursion_depth - 1); } } DUK__EMIT_1(js_ctx, DUK_ASC_RCURLY); - duk__enc_objarr_exit(js_ctx, &h_stepback, &h_indent, &entry_top); + duk__enc_objarr_exit(js_ctx, &entry_top); DUK_ASSERT_TOP(ctx, entry_top); } @@ -26157,8 +33937,6 @@ DUK_LOCAL void duk__enc_object(duk_json_enc_ctx *js_ctx) { */ DUK_LOCAL void duk__enc_array(duk_json_enc_ctx *js_ctx) { duk_context *ctx = (duk_context *) js_ctx->thr; - duk_hstring *h_stepback; - duk_hstring *h_indent; duk_idx_t entry_top; duk_idx_t idx_arr; duk_bool_t undef; @@ -26167,7 +33945,7 @@ DUK_LOCAL void duk__enc_array(duk_json_enc_ctx *js_ctx) { DUK_DDD(DUK_DDDPRINT("duk__enc_array: array=%!T", (duk_tval *) duk_get_tval(ctx, -1))); - duk__enc_objarr_entry(js_ctx, &h_stepback, &h_indent, &entry_top); + duk__enc_objarr_entry(js_ctx, &entry_top); idx_arr = entry_top - 1; @@ -26177,16 +33955,16 @@ DUK_LOCAL void duk__enc_array(duk_json_enc_ctx *js_ctx) { arr_len = (duk_uarridx_t) duk_get_length(ctx, idx_arr); for (i = 0; i < arr_len; i++) { - DUK_DDD(DUK_DDDPRINT("array entry loop: array=%!T, h_indent=%!O, h_stepback=%!O, index=%ld, arr_len=%ld", - (duk_tval *) duk_get_tval(ctx, idx_arr), (duk_heaphdr *) h_indent, - (duk_heaphdr *) h_stepback, (long) i, (long) arr_len)); + DUK_DDD(DUK_DDDPRINT("array entry loop: array=%!T, index=%ld, arr_len=%ld", + (duk_tval *) duk_get_tval(ctx, idx_arr), + (long) i, (long) arr_len)); if (i > 0) { DUK__EMIT_1(js_ctx, DUK_ASC_COMMA); } - if (h_indent != NULL) { - DUK__EMIT_1(js_ctx, 0x0a); - DUK__EMIT_HSTR(js_ctx, h_indent); + if (js_ctx->h_gap != NULL) { + DUK_ASSERT(js_ctx->recursion_depth >= 1); + duk__enc_newline_indent(js_ctx, js_ctx->recursion_depth); } /* XXX: duk_push_uint_string() */ @@ -26203,15 +33981,14 @@ DUK_LOCAL void duk__enc_array(duk_json_enc_ctx *js_ctx) { } if (arr_len > 0) { - if (h_stepback != NULL) { - DUK_ASSERT(h_indent != NULL); - DUK__EMIT_1(js_ctx, 0x0a); - DUK__EMIT_HSTR(js_ctx, h_stepback); + if (js_ctx->h_gap != NULL) { + DUK_ASSERT(js_ctx->recursion_depth >= 1); + duk__enc_newline_indent(js_ctx, js_ctx->recursion_depth - 1); } } DUK__EMIT_1(js_ctx, DUK_ASC_RBRACKET); - duk__enc_objarr_exit(js_ctx, &h_stepback, &h_indent, &entry_top); + duk__enc_objarr_exit(js_ctx, &entry_top); DUK_ASSERT_TOP(ctx, entry_top); } @@ -26228,6 +34005,7 @@ DUK_LOCAL void duk__enc_array(duk_json_enc_ctx *js_ctx) { */ DUK_LOCAL duk_bool_t duk__enc_value1(duk_json_enc_ctx *js_ctx, duk_idx_t idx_holder) { duk_context *ctx = (duk_context *) js_ctx->thr; + duk_hthread *thr = (duk_hthread *) ctx; duk_hobject *h; duk_tval *tv; duk_small_int_t c; @@ -26236,6 +34014,8 @@ DUK_LOCAL duk_bool_t duk__enc_value1(duk_json_enc_ctx *js_ctx, duk_idx_t idx_hol (long) idx_holder, (duk_tval *) duk_get_tval(ctx, idx_holder), (duk_tval *) duk_get_tval(ctx, -1))); + DUK_UNREF(thr); + duk_dup_top(ctx); /* -> [ ... key key ] */ duk_get_prop(ctx, idx_holder); /* -> [ ... key val ] */ @@ -26282,25 +34062,52 @@ DUK_LOCAL duk_bool_t duk__enc_value1(duk_json_enc_ctx *js_ctx, duk_idx_t idx_hol h = DUK_TVAL_GET_OBJECT(tv); DUK_ASSERT(h != NULL); - c = (duk_small_int_t) DUK_HOBJECT_GET_CLASS_NUMBER(h); - switch ((int) c) { - case DUK_HOBJECT_CLASS_NUMBER: - DUK_DDD(DUK_DDDPRINT("value is a Number object -> coerce with ToNumber()")); - duk_to_number(ctx, -1); - break; - case DUK_HOBJECT_CLASS_STRING: - DUK_DDD(DUK_DDDPRINT("value is a String object -> coerce with ToString()")); - duk_to_string(ctx, -1); - break; -#if defined(DUK_USE_JX) || defined(DUK_USE_JC) - case DUK_HOBJECT_CLASS_BUFFER: - case DUK_HOBJECT_CLASS_POINTER: -#endif - case DUK_HOBJECT_CLASS_BOOLEAN: - DUK_DDD(DUK_DDDPRINT("value is a Boolean/Buffer/Pointer object -> get internal value")); - duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE); + if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) { + duk_hbufferobject *h_bufobj; + h_bufobj = (duk_hbufferobject *) h; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + if (h_bufobj->buf == NULL || !DUK_HBUFFEROBJECT_VALID_SLICE(h_bufobj)) { + duk_push_null(ctx); + } else if (DUK_HBUFFEROBJECT_FULL_SLICE(h_bufobj)) { + duk_push_hbuffer(ctx, h_bufobj->buf); + } else { + /* This is not very good because we're making a copy + * for serialization, but only for proper views. + * Better support would be to serialize slices + * directly but since we only push a raw buffer + * here we can't convey the slice offset/length. + */ + duk_uint8_t *p_buf; + + p_buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, h_bufobj->length); + DUK_MEMCPY((void *) p_buf, + (const void *) (DUK_HBUFFEROBJECT_GET_SLICE_BASE(thr->heap, h_bufobj)), + h_bufobj->length); + } duk_remove(ctx, -2); - break; + } else { + c = (duk_small_int_t) DUK_HOBJECT_GET_CLASS_NUMBER(h); + switch ((int) c) { + case DUK_HOBJECT_CLASS_NUMBER: { + DUK_DDD(DUK_DDDPRINT("value is a Number object -> coerce with ToNumber()")); + duk_to_number(ctx, -1); + break; + } + case DUK_HOBJECT_CLASS_STRING: { + DUK_DDD(DUK_DDDPRINT("value is a String object -> coerce with ToString()")); + duk_to_string(ctx, -1); + break; + } +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + case DUK_HOBJECT_CLASS_POINTER: +#endif + case DUK_HOBJECT_CLASS_BOOLEAN: { + DUK_DDD(DUK_DDDPRINT("value is a Boolean/Buffer/Pointer object -> get internal value")); + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE); + duk_remove(ctx, -2); + break; + } + } /* end switch */ } } @@ -26381,35 +34188,7 @@ DUK_LOCAL void duk__enc_value2(duk_json_enc_ctx *js_ctx) { #if defined(DUK_USE_JX) || defined(DUK_USE_JC) /* When JX/JC not in use, duk__enc_value1 will block pointer values. */ case DUK_TAG_POINTER: { - char buf[64]; /* XXX: how to figure correct size? */ - const char *fmt; - void *ptr = DUK_TVAL_GET_POINTER(tv); - - DUK_MEMZERO(buf, sizeof(buf)); - - /* The #ifdef clutter here needs to handle the three cases: - * (1) JX+JC, (2) JX only, (3) JC only. - */ -#if defined(DUK_USE_JX) && defined(DUK_USE_JC) - if (js_ctx->flag_ext_custom) -#endif -#if defined(DUK_USE_JX) - { - fmt = ptr ? "(%p)" : "(null)"; - } -#endif -#if defined(DUK_USE_JX) && defined(DUK_USE_JC) - else -#endif -#if defined(DUK_USE_JC) - { - fmt = ptr ? "{\"_ptr\":\"%p\"}" : "{\"_ptr\":\"null\"}"; - } -#endif - - /* When ptr == NULL, the format argument is unused. */ - DUK_SNPRINTF(buf, sizeof(buf) - 1, fmt, ptr); /* must not truncate */ - DUK__EMIT_CSTR(js_ctx, buf); + duk__enc_pointer(js_ctx, DUK_TVAL_GET_POINTER(tv)); break; } #endif /* DUK_USE_JX || DUK_USE_JC */ @@ -26441,49 +34220,7 @@ DUK_LOCAL void duk__enc_value2(duk_json_enc_ctx *js_ctx) { #if defined(DUK_USE_JX) || defined(DUK_USE_JC) /* When JX/JC not in use, duk__enc_value1 will block buffer values. */ case DUK_TAG_BUFFER: { - /* Buffer values are encoded in (lowercase) hex to make the - * binary data readable. Base64 or similar would be more - * compact but less readable, and the point of JX/JC - * variants is to be as useful to a programmer as possible. - */ - - /* The #ifdef clutter here needs to handle the three cases: - * (1) JX+JC, (2) JX only, (3) JC only. - */ -#if defined(DUK_USE_JX) && defined(DUK_USE_JC) - if (js_ctx->flag_ext_custom) -#endif -#if defined(DUK_USE_JX) - { - duk_uint8_t *p, *p_end; - duk_small_uint_t x; - duk_hbuffer *h; - - h = DUK_TVAL_GET_BUFFER(tv); - DUK_ASSERT(h != NULL); - p = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h); - p_end = p + DUK_HBUFFER_GET_SIZE(h); - DUK__EMIT_1(js_ctx, DUK_ASC_PIPE); - while (p < p_end) { - x = *p++; - duk_hbuffer_append_byte(js_ctx->thr, js_ctx->h_buf, duk_lc_digits[(x >> 4) & 0x0f]); - duk_hbuffer_append_byte(js_ctx->thr, js_ctx->h_buf, duk_lc_digits[x & 0x0f]); - } - DUK__EMIT_1(js_ctx, DUK_ASC_PIPE); - } -#endif -#if defined(DUK_USE_JX) && defined(DUK_USE_JC) - else -#endif -#if defined(DUK_USE_JC) - { - DUK_ASSERT(js_ctx->flag_ext_compatible); - duk_hex_encode(ctx, -1); - DUK__EMIT_CSTR(js_ctx, "{\"_buf\":"); - duk__enc_quote_string(js_ctx, duk_require_hstring(ctx, -1)); - DUK__EMIT_1(js_ctx, DUK_ASC_RCURLY); - } -#endif + duk__enc_buffer(js_ctx, DUK_TVAL_GET_BUFFER(tv)); break; } #endif /* DUK_USE_JX || DUK_USE_JC */ @@ -26500,60 +34237,20 @@ DUK_LOCAL void duk__enc_value2(duk_json_enc_ctx *js_ctx) { } #if defined(DUK_USE_FASTINT) case DUK_TAG_FASTINT: + /* Number serialization has a significant impact relative to + * other fast path code, so careful fast path for fastints. + */ + duk__enc_fastint_tval(js_ctx, tv); + break; #endif default: { /* number */ - duk_double_t d; - duk_small_int_t c; - duk_small_int_t s; - duk_small_uint_t stridx; - duk_small_uint_t n2s_flags; - duk_hstring *h_str; - + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv)); DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); - d = DUK_TVAL_GET_NUMBER(tv); - c = (duk_small_int_t) DUK_FPCLASSIFY(d); - s = (duk_small_int_t) DUK_SIGNBIT(d); - DUK_UNREF(s); - - if (DUK_LIKELY(!(c == DUK_FP_INFINITE || c == DUK_FP_NAN))) { - DUK_ASSERT(DUK_ISFINITE(d)); - -#if defined(DUK_USE_JX) || defined(DUK_USE_JC) - /* Negative zero needs special handling in JX/JC because - * it would otherwise serialize to '0', not '-0'. - */ - if (DUK_UNLIKELY(c == DUK_FP_ZERO && s != 0 && - (js_ctx->flag_ext_custom || js_ctx->flag_ext_compatible))) { - duk_push_hstring_stridx(ctx, DUK_STRIDX_MINUS_ZERO); /* '-0' */ - } else -#endif /* DUK_USE_JX || DUK_USE_JC */ - { - n2s_flags = 0; - /* [ ... number ] -> [ ... string ] */ - duk_numconv_stringify(ctx, 10 /*radix*/, 0 /*digits*/, n2s_flags); - } - h_str = duk_to_hstring(ctx, -1); - DUK_ASSERT(h_str != NULL); - DUK__EMIT_HSTR(js_ctx, h_str); - break; - } - -#if defined(DUK_USE_JX) || defined(DUK_USE_JC) - if (!(js_ctx->flags & (DUK_JSON_FLAG_EXT_CUSTOM | - DUK_JSON_FLAG_EXT_COMPATIBLE))) { - stridx = DUK_STRIDX_LC_NULL; - } else if (c == DUK_FP_NAN) { - stridx = js_ctx->stridx_custom_nan; - } else if (s == 0) { - stridx = js_ctx->stridx_custom_posinf; - } else { - stridx = js_ctx->stridx_custom_neginf; - } -#else - stridx = DUK_STRIDX_LC_NULL; -#endif - DUK__EMIT_STRIDX(js_ctx, stridx); + /* XXX: A fast path for usual integers would be useful when + * fastint support is not enabled. + */ + duk__enc_double(js_ctx); break; } } @@ -26583,6 +34280,455 @@ DUK_LOCAL duk_bool_t duk__enc_allow_into_proplist(duk_tval *tv) { return 0; } +/* + * JSON.stringify() fast path + * + * Otherwise supports full JSON, JX, and JC features, but bails out on any + * possible side effect which might change the value being serialized. The + * fast path can take advantage of the fact that the value being serialized + * is unchanged so that we can walk directly through property tables etc. + */ + +#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH) +DUK_LOCAL duk_bool_t duk__json_stringify_fast_value(duk_json_enc_ctx *js_ctx, duk_tval *tv) { + duk_uint_fast32_t i, n; + + DUK_DDD(DUK_DDDPRINT("stringify fast: %!T", tv)); + + DUK_ASSERT(js_ctx != NULL); + DUK_ASSERT(js_ctx->thr != NULL); + + restart_match: + DUK_ASSERT(tv != NULL); + + switch (DUK_TVAL_GET_TAG(tv)) { + case DUK_TAG_UNDEFINED: { +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + if (js_ctx->flag_ext_custom || js_ctx->flag_ext_compatible) { + DUK__EMIT_STRIDX(js_ctx, js_ctx->stridx_custom_undefined); + break; + } else { + goto emit_undefined; + } +#else + goto emit_undefined; +#endif + } + case DUK_TAG_NULL: { + DUK__EMIT_STRIDX(js_ctx, DUK_STRIDX_LC_NULL); + break; + } + case DUK_TAG_BOOLEAN: { + DUK__EMIT_STRIDX(js_ctx, DUK_TVAL_GET_BOOLEAN(tv) ? + DUK_STRIDX_TRUE : DUK_STRIDX_FALSE); + break; + } + case DUK_TAG_STRING: { + duk_hstring *h; + + h = DUK_TVAL_GET_STRING(tv); + DUK_ASSERT(h != NULL); + duk__enc_quote_string(js_ctx, h); + break; + } + case DUK_TAG_OBJECT: { + duk_hobject *obj; + duk_tval *tv_val; + duk_bool_t emitted = 0; + duk_uint32_t c_bit, c_all, c_array, c_unbox, c_undef, + c_func, c_bufobj, c_object; + + /* For objects JSON.stringify() only looks for own, enumerable + * properties which is nice for the fast path here. + * + * For arrays JSON.stringify() uses [[Get]] so it will actually + * inherit properties during serialization! This fast path + * supports gappy arrays as long as there's no actual inherited + * property (which might be a getter etc). + * + * Since recursion only happens for objects, we can have both + * recursion and loop checks here. We use a simple, depth-limited + * loop check in the fast path because the object-based tracking + * is very slow (when tested, it accounted for 50% of fast path + * execution time for input data with a lot of small objects!). + */ + + /* XXX: for real world code, could just ignore array inheritance + * and only look at array own properties. + */ + + /* We rely on a few object flag / class number relationships here, + * assert for them. + */ + + obj = DUK_TVAL_GET_OBJECT(tv); + DUK_ASSERT(obj != NULL); + DUK_ASSERT_HOBJECT_VALID(obj); + + /* Once recursion depth is increased, exit path must decrease + * it (though it's OK to abort the fast path). + */ + + DUK_ASSERT(js_ctx->recursion_depth >= 0); + DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit); + if (js_ctx->recursion_depth >= js_ctx->recursion_limit) { + DUK_DD(DUK_DDPRINT("fast path recursion limit")); + DUK_ERROR(js_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_JSONDEC_RECLIMIT); + } + + for (i = 0, n = (duk_uint_fast32_t) js_ctx->recursion_depth; i < n; i++) { + if (DUK_UNLIKELY(js_ctx->visiting[i] == obj)) { + DUK_DD(DUK_DDPRINT("fast path loop detect")); + DUK_ERROR(js_ctx->thr, DUK_ERR_TYPE_ERROR, DUK_STR_CYCLIC_INPUT); + } + } + + /* Guaranteed by recursion_limit setup so we don't have to + * check twice. + */ + DUK_ASSERT(js_ctx->recursion_depth < DUK_JSON_ENC_LOOPARRAY); + js_ctx->visiting[js_ctx->recursion_depth] = obj; + js_ctx->recursion_depth++; + + /* If object has a .toJSON() property, we can't be certain + * that it wouldn't mutate any value arbitrarily, so bail + * out of the fast path. + * + * If an object is a Proxy we also can't avoid side effects + * so abandon. + */ + /* XXX: non-callable .toJSON() doesn't need to cause an abort + * but does at the moment, probably not worth fixing. + */ + if (duk_hobject_hasprop_raw(js_ctx->thr, obj, DUK_HTHREAD_STRING_TO_JSON(js_ctx->thr)) || + DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj)) { + DUK_DD(DUK_DDPRINT("object has a .toJSON property or object is a Proxy, abort fast path")); + goto abort_fastpath; + } + + /* We could use a switch-case for the class number but it turns out + * a small if-else ladder on class masks is better. The if-ladder + * should be in order of relevancy. + */ + + /* XXX: move masks to js_ctx? they don't change during one + * fast path invocation. + */ + DUK_ASSERT(DUK_HOBJECT_CLASS_MAX <= 31); +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + if (js_ctx->flag_ext_custom_or_compatible) { + c_all = DUK_HOBJECT_CMASK_ALL; + c_array = DUK_HOBJECT_CMASK_ARRAY; + c_unbox = DUK_HOBJECT_CMASK_NUMBER | + DUK_HOBJECT_CMASK_STRING | + DUK_HOBJECT_CMASK_BOOLEAN | + DUK_HOBJECT_CMASK_POINTER; + c_func = DUK_HOBJECT_CMASK_FUNCTION; + c_bufobj = DUK_HOBJECT_CMASK_ALL_BUFFEROBJECTS; + c_undef = 0; + c_object = c_all & ~(c_array | c_unbox | c_func | c_bufobj | c_undef); + } + else +#endif + { + c_all = DUK_HOBJECT_CMASK_ALL; + c_array = DUK_HOBJECT_CMASK_ARRAY; + c_unbox = DUK_HOBJECT_CMASK_NUMBER | + DUK_HOBJECT_CMASK_STRING | + DUK_HOBJECT_CMASK_BOOLEAN; + c_func = 0; + c_bufobj = 0; + c_undef = DUK_HOBJECT_CMASK_FUNCTION | + DUK_HOBJECT_CMASK_POINTER | + DUK_HOBJECT_CMASK_ALL_BUFFEROBJECTS; + c_object = c_all & ~(c_array | c_unbox | c_func | c_bufobj | c_undef); + } + + c_bit = DUK_HOBJECT_GET_CLASS_MASK(obj); + if (c_bit & c_object) { + /* All other object types. */ + DUK__EMIT_1(js_ctx, DUK_ASC_LCURLY); + + /* A non-Array object should not have an array part in practice. + * But since it is supported internally (and perhaps used at some + * point), check and abandon if that's the case. + */ + if (DUK_HOBJECT_HAS_ARRAY_PART(obj)) { + DUK_DD(DUK_DDPRINT("non-Array object has array part, abort fast path")); + goto abort_fastpath; + } + + for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(obj); i++) { + duk_hstring *k; + duk_size_t prev_size; + + k = DUK_HOBJECT_E_GET_KEY(js_ctx->thr->heap, obj, i); + if (!k) { + continue; + } + if (!DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(js_ctx->thr->heap, obj, i)) { + continue; + } + if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(js_ctx->thr->heap, obj, i)) { + /* Getter might have arbitrary side effects, + * so bail out. + */ + DUK_DD(DUK_DDPRINT("property is an accessor, abort fast path")); + goto abort_fastpath; + } + if (DUK_HSTRING_HAS_INTERNAL(k)) { + continue; + } + + tv_val = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(js_ctx->thr->heap, obj, i); + + prev_size = DUK_BW_GET_SIZE(js_ctx->thr, &js_ctx->bw); + if (DUK_UNLIKELY(js_ctx->h_gap != NULL)) { + + duk__enc_newline_indent(js_ctx, js_ctx->recursion_depth); + duk__enc_key_autoquote(js_ctx, k); + DUK__EMIT_2(js_ctx, DUK_ASC_COLON, DUK_ASC_SPACE); + } else { + duk__enc_key_autoquote(js_ctx, k); + DUK__EMIT_1(js_ctx, DUK_ASC_COLON); + } + + if (duk__json_stringify_fast_value(js_ctx, tv_val) == 0) { + DUK_DD(DUK_DDPRINT("prop value not supported, rewind key and colon")); + DUK_BW_SET_SIZE(js_ctx->thr, &js_ctx->bw, prev_size); + } else { + DUK__EMIT_1(js_ctx, DUK_ASC_COMMA); + emitted = 1; + } + } + + /* If any non-Array value had enumerable virtual own + * properties, they should be serialized here. Standard + * types don't. + */ + + if (emitted) { + DUK_ASSERT(*((duk_uint8_t *) DUK_BW_GET_PTR(js_ctx->thr, &js_ctx->bw) - 1) == DUK_ASC_COMMA); + DUK__UNEMIT_1(js_ctx); /* eat trailing comma */ + if (DUK_UNLIKELY(js_ctx->h_gap != NULL)) { + DUK_ASSERT(js_ctx->recursion_depth >= 1); + duk__enc_newline_indent(js_ctx, js_ctx->recursion_depth - 1); + } + } + DUK__EMIT_1(js_ctx, DUK_ASC_RCURLY); + } else if (c_bit & c_array) { + duk_uint_fast32_t arr_len; + duk_uint_fast32_t asize; + + DUK__EMIT_1(js_ctx, DUK_ASC_LBRACKET); + + /* Assume arrays are dense in the fast path. */ + if (!DUK_HOBJECT_HAS_ARRAY_PART(obj)) { + DUK_DD(DUK_DDPRINT("Array object is sparse, abort fast path")); + goto abort_fastpath; + } + + arr_len = (duk_uint_fast32_t) duk_hobject_get_length(js_ctx->thr, obj); + asize = (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(obj); + if (arr_len > asize) { + /* Array length is larger than 'asize'. This shouldn't + * happen in practice. Bail out just in case. + */ + DUK_DD(DUK_DDPRINT("arr_len > asize, abort fast path")); + goto abort_fastpath; + } + /* Array part may be larger than 'length'; if so, iterate + * only up to array 'length'. + */ + for (i = 0; i < arr_len; i++) { + DUK_ASSERT(i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(obj)); + + tv_val = DUK_HOBJECT_A_GET_VALUE_PTR(js_ctx->thr->heap, obj, i); + + if (DUK_UNLIKELY(js_ctx->h_gap != NULL)) { + duk__enc_newline_indent(js_ctx, js_ctx->recursion_depth); + } + + if (DUK_UNLIKELY(DUK_TVAL_IS_UNUSED(tv_val))) { + /* Gap in array; check for inherited property, + * bail out if one exists. This should be enough + * to support gappy arrays for all practical code. + */ + duk_hstring *h_tmp; + duk_bool_t has_inherited; + + /* XXX: refactor into an internal helper, pretty awkward */ + duk_push_uint((duk_context *) js_ctx->thr, (duk_uint_t) i); + h_tmp = duk_to_hstring((duk_context *) js_ctx->thr, -1); + DUK_ASSERT(h_tmp != NULL); + has_inherited = duk_hobject_hasprop_raw(js_ctx->thr, obj, h_tmp); + duk_pop((duk_context *) js_ctx->thr); + + if (has_inherited) { + DUK_D(DUK_DPRINT("gap in array, conflicting inherited property, abort fast path")); + goto abort_fastpath; + } + + /* Ordinary gap, undefined encodes to 'null' in + * standard JSON (and no JX/JC support here now). + */ + DUK_D(DUK_DPRINT("gap in array, no conflicting inherited property, remain on fast path")); + DUK__EMIT_STRIDX(js_ctx, DUK_STRIDX_LC_NULL); + } else { + if (duk__json_stringify_fast_value(js_ctx, tv_val) == 0) { + DUK__EMIT_STRIDX(js_ctx, DUK_STRIDX_LC_NULL); + } + } + DUK__EMIT_1(js_ctx, DUK_ASC_COMMA); + emitted = 1; + } + + if (emitted) { + DUK_ASSERT(*((duk_uint8_t *) DUK_BW_GET_PTR(js_ctx->thr, &js_ctx->bw) - 1) == DUK_ASC_COMMA); + DUK__UNEMIT_1(js_ctx); /* eat trailing comma */ + if (DUK_UNLIKELY(js_ctx->h_gap != NULL)) { + DUK_ASSERT(js_ctx->recursion_depth >= 1); + duk__enc_newline_indent(js_ctx, js_ctx->recursion_depth - 1); + } + } + DUK__EMIT_1(js_ctx, DUK_ASC_RBRACKET); + } else if (c_bit & c_unbox) { + /* Certain boxed types are required to go through + * automatic unboxing. Rely on internal value being + * sane (to avoid infinite recursion). + */ + duk_tval *tv_internal; + + DUK_DD(DUK_DDPRINT("auto unboxing in fast path")); + + tv_internal = duk_hobject_get_internal_value_tval_ptr(js_ctx->thr->heap, obj); + DUK_ASSERT(tv_internal != NULL); + DUK_ASSERT(DUK_TVAL_IS_STRING(tv_internal) || + DUK_TVAL_IS_NUMBER(tv_internal) || + DUK_TVAL_IS_BOOLEAN(tv_internal) || + DUK_TVAL_IS_POINTER(tv_internal)); + + tv = tv_internal; + DUK_ASSERT(js_ctx->recursion_depth > 0); + js_ctx->recursion_depth--; /* required to keep recursion depth correct */ + goto restart_match; +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + } else if (c_bit & c_func) { + DUK__EMIT_STRIDX(js_ctx, js_ctx->stridx_custom_function); + } else if (c_bit & c_bufobj) { + duk__enc_bufferobject(js_ctx, (duk_hbufferobject *) obj); +#endif + } else { + DUK_ASSERT((c_bit & c_undef) != 0); + + /* Must decrease recursion depth before returning. */ + DUK_ASSERT(js_ctx->recursion_depth > 0); + DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit); + js_ctx->recursion_depth--; + goto emit_undefined; + } + + DUK_ASSERT(js_ctx->recursion_depth > 0); + DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit); + js_ctx->recursion_depth--; + break; + } + case DUK_TAG_BUFFER: { +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + if (js_ctx->flag_ext_custom_or_compatible) { + duk__enc_buffer(js_ctx, DUK_TVAL_GET_BUFFER(tv)); + break; + } else { + goto emit_undefined; + } +#else + goto emit_undefined; +#endif + } + case DUK_TAG_POINTER: { +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + if (js_ctx->flag_ext_custom_or_compatible) { + duk__enc_pointer(js_ctx, DUK_TVAL_GET_POINTER(tv)); + break; + } else { + goto emit_undefined; + } +#else + goto emit_undefined; +#endif + } + case DUK_TAG_LIGHTFUNC: { + /* A lightfunc might also inherit a .toJSON() so just bail out. */ + /* XXX: Could just lookup .toJSON() and continue in fast path, + * as it would almost never be defined. + */ + DUK_DD(DUK_DDPRINT("value is a lightfunc, abort fast path")); + goto abort_fastpath; + } +#if defined(DUK_USE_FASTINT) + case DUK_TAG_FASTINT: { + /* Number serialization has a significant impact relative to + * other fast path code, so careful fast path for fastints. + */ + duk__enc_fastint_tval(js_ctx, tv); + break; + } +#endif + default: { + /* XXX: A fast path for usual integers would be useful when + * fastint support is not enabled. + */ + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv)); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); + + /* XXX: Stack discipline is annoying, could be changed in numconv. */ + duk_push_tval((duk_context *) js_ctx->thr, tv); + duk__enc_double(js_ctx); + duk_pop((duk_context *) js_ctx->thr); + +#if 0 + /* Could also rely on native sprintf(), but it will handle + * values like NaN, Infinity, -0, exponent notation etc in + * a JSON-incompatible way. + */ + duk_double_t d; + char buf[64]; + + DUK_ASSERT(DUK_TVAL_IS_DOUBLE(tv)); + d = DUK_TVAL_GET_DOUBLE(tv); + DUK_SPRINTF(buf, "%lg", d); + DUK__EMIT_CSTR(js_ctx, buf); +#endif + } + } + return 1; /* not undefined */ + + emit_undefined: + return 0; /* value was undefined/unsupported */ + + abort_fastpath: + /* Error message doesn't matter: the error is ignored anyway. */ + DUK_DD(DUK_DDPRINT("aborting fast path")); + DUK_ERROR(js_ctx->thr, DUK_ERR_ERROR, DUK_STR_INTERNAL_ERROR); + return 0; /* unreachable */ +} + +DUK_LOCAL duk_ret_t duk__json_stringify_fast(duk_context *ctx) { + duk_json_enc_ctx *js_ctx; + + DUK_ASSERT(ctx != NULL); + js_ctx = (duk_json_enc_ctx *) duk_get_pointer(ctx, -2); + DUK_ASSERT(js_ctx != NULL); + + if (duk__json_stringify_fast_value(js_ctx, duk_get_tval((duk_context *) (js_ctx->thr), -1)) == 0) { + DUK_DD(DUK_DDPRINT("top level value not supported, fail fast path")); + return DUK_RET_ERROR; /* error message doesn't matter, ignored anyway */ + } + + return 0; +} +#endif /* DUK_USE_JSON_STRINGIFY_FASTPATH */ + /* * Top level wrappers */ @@ -26615,27 +34761,36 @@ void duk_bi_json_parse_helper(duk_context *ctx, #ifdef DUK_USE_EXPLICIT_NULL_INIT /* nothing now */ #endif - js_ctx->recursion_limit = DUK_JSON_DEC_RECURSION_LIMIT; + js_ctx->recursion_limit = DUK_USE_JSON_DEC_RECLIMIT; + DUK_ASSERT(js_ctx->recursion_depth == 0); /* Flag handling currently assumes that flags are consistent. This is OK * because the call sites are now strictly controlled. */ js_ctx->flags = flags; -#ifdef DUK_USE_JX +#if defined(DUK_USE_JX) js_ctx->flag_ext_custom = flags & DUK_JSON_FLAG_EXT_CUSTOM; #endif -#ifdef DUK_USE_JC +#if defined(DUK_USE_JC) js_ctx->flag_ext_compatible = flags & DUK_JSON_FLAG_EXT_COMPATIBLE; #endif +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + js_ctx->flag_ext_custom_or_compatible = flags & (DUK_JSON_FLAG_EXT_CUSTOM | DUK_JSON_FLAG_EXT_COMPATIBLE); +#endif h_text = duk_to_hstring(ctx, idx_value); /* coerce in-place */ DUK_ASSERT(h_text != NULL); - js_ctx->p_start = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h_text); + /* JSON parsing code is allowed to read [p_start,p_end]: p_end is + * valid and points to the string NUL terminator (which is always + * guaranteed for duk_hstrings. + */ + js_ctx->p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_text); js_ctx->p = js_ctx->p_start; - js_ctx->p_end = ((duk_uint8_t *) DUK_HSTRING_GET_DATA(h_text)) + + js_ctx->p_end = ((const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_text)) + DUK_HSTRING_GET_BYTELEN(h_text); + DUK_ASSERT(*(js_ctx->p_end) == 0x00); duk__dec_value(js_ctx); /* -> [ ... value ] */ @@ -26718,10 +34873,8 @@ void duk_bi_json_stringify_helper(duk_context *ctx, #ifdef DUK_USE_EXPLICIT_NULL_INIT js_ctx->h_replacer = NULL; js_ctx->h_gap = NULL; - js_ctx->h_indent = NULL; #endif js_ctx->idx_proplist = -1; - js_ctx->recursion_limit = DUK_JSON_ENC_RECURSION_LIMIT; /* Flag handling currently assumes that flags are consistent. This is OK * because the call sites are now strictly controlled. @@ -26736,6 +34889,9 @@ void duk_bi_json_stringify_helper(duk_context *ctx, #ifdef DUK_USE_JC js_ctx->flag_ext_compatible = flags & DUK_JSON_FLAG_EXT_COMPATIBLE; #endif +#if defined(DUK_USE_JX) || defined(DUK_USE_JC) + js_ctx->flag_ext_custom_or_compatible = flags & (DUK_JSON_FLAG_EXT_CUSTOM | DUK_JSON_FLAG_EXT_COMPATIBLE); +#endif /* The #ifdef clutter here handles the JX/JC enable/disable * combinations properly. @@ -26781,10 +34937,7 @@ void duk_bi_json_stringify_helper(duk_context *ctx, DUK_TYPE_MASK_LIGHTFUNC; } - (void) duk_push_dynamic_buffer(ctx, 0); - js_ctx->h_buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1); - DUK_ASSERT(js_ctx->h_buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(js_ctx->h_buf)); + DUK_BW_INIT_PUSHBUF(thr, &js_ctx->bw, DUK__JSON_STRINGIFY_BUFSIZE); js_ctx->idx_loop = duk_push_object_internal(ctx); DUK_ASSERT(js_ctx->idx_loop >= 0); @@ -26884,17 +35037,74 @@ void duk_bi_json_stringify_helper(duk_context *ctx, /* if gap is empty, behave as if not given at all */ if (DUK_HSTRING_GET_CHARLEN(js_ctx->h_gap) == 0) { js_ctx->h_gap = NULL; - } else { - /* set 'indent' only if it will actually increase */ - js_ctx->h_indent = DUK_HTHREAD_STRING_EMPTY_STRING(thr); } } - DUK_ASSERT((js_ctx->h_gap == NULL && js_ctx->h_indent == NULL) || - (js_ctx->h_gap != NULL && js_ctx->h_indent != NULL)); - /* [ ... buf loop (proplist) (gap) ] */ + /* + * Fast path: assume no mutation, iterate object property tables + * directly; bail out if that assumption doesn't hold. + */ + +#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH) + if (js_ctx->h_replacer == NULL && /* replacer is a mutation risk */ + js_ctx->idx_proplist == -1) { /* proplist is very rare */ + duk_int_t pcall_rc; +#ifdef DUK_USE_MARK_AND_SWEEP + duk_small_uint_t prev_mark_and_sweep_base_flags; +#endif + + DUK_DD(DUK_DDPRINT("try JSON.stringify() fast path")); + + /* Use recursion_limit to ensure we don't overwrite js_ctx->visiting[] + * array so we don't need two counter checks in the fast path. The + * slow path has a much larger recursion limit which we'll use if + * necessary. + */ + DUK_ASSERT(DUK_USE_JSON_ENC_RECLIMIT >= DUK_JSON_ENC_LOOPARRAY); + js_ctx->recursion_limit = DUK_JSON_ENC_LOOPARRAY; + DUK_ASSERT(js_ctx->recursion_depth == 0); + + /* Execute the fast path in a protected call. If any error is thrown, + * fall back to the slow path. This includes e.g. recursion limit + * because the fast path has a smaller recursion limit (and simpler, + * limited loop detection). + */ + + duk_push_pointer(ctx, (void *) js_ctx); + duk_dup(ctx, idx_value); + +#if defined(DUK_USE_MARK_AND_SWEEP) + /* Must prevent finalizers which may have arbitrary side effects. */ + prev_mark_and_sweep_base_flags = thr->heap->mark_and_sweep_base_flags; + thr->heap->mark_and_sweep_base_flags |= + DUK_MS_FLAG_NO_FINALIZERS | /* avoid attempts to add/remove object keys */ + DUK_MS_FLAG_NO_OBJECT_COMPACTION; /* avoid attempt to compact any objects */ +#endif + + pcall_rc = duk_safe_call(ctx, duk__json_stringify_fast, 2 /*nargs*/, 0 /*nret*/); + +#if defined(DUK_USE_MARK_AND_SWEEP) + thr->heap->mark_and_sweep_base_flags = prev_mark_and_sweep_base_flags; +#endif + if (pcall_rc == DUK_EXEC_SUCCESS) { + DUK_DD(DUK_DDPRINT("fast path successful")); + DUK_BW_PUSH_AS_STRING(thr, &js_ctx->bw); + goto replace_finished; + } + + /* We come here for actual aborts (like encountering .toJSON()) + * but also for recursion/loop errors. Bufwriter size can be + * kept because we'll probably need at least as much as we've + * allocated so far. + */ + DUK_D(DUK_DPRINT("fast path failed, serialize using slow path instead")); + DUK_BW_RESET_SIZE(thr, &js_ctx->bw); + js_ctx->recursion_depth = 0; + } +#endif + /* * Create wrapper object and serialize */ @@ -26903,15 +35113,13 @@ void duk_bi_json_stringify_helper(duk_context *ctx, duk_dup(ctx, idx_value); duk_put_prop_stridx(ctx, -2, DUK_STRIDX_EMPTY_STRING); - DUK_DDD(DUK_DDDPRINT("before: flags=0x%08lx, buf=%!O, loop=%!T, replacer=%!O, " - "proplist=%!T, gap=%!O, indent=%!O, holder=%!T", + DUK_DDD(DUK_DDDPRINT("before: flags=0x%08lx, loop=%!T, replacer=%!O, " + "proplist=%!T, gap=%!O, holder=%!T", (unsigned long) js_ctx->flags, - (duk_heaphdr *) js_ctx->h_buf, (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop), (duk_heaphdr *) js_ctx->h_replacer, (duk_tval *) (js_ctx->idx_proplist >= 0 ? duk_get_tval(ctx, js_ctx->idx_proplist) : NULL), (duk_heaphdr *) js_ctx->h_gap, - (duk_heaphdr *) js_ctx->h_indent, (duk_tval *) duk_get_tval(ctx, -1))); /* serialize the wrapper with empty string key */ @@ -26920,40 +35128,35 @@ void duk_bi_json_stringify_helper(duk_context *ctx, /* [ ... buf loop (proplist) (gap) holder "" ] */ + js_ctx->recursion_limit = DUK_USE_JSON_ENC_RECLIMIT; + DUK_ASSERT(js_ctx->recursion_depth == 0); undef = duk__enc_value1(js_ctx, idx_holder); /* [ ... holder key ] -> [ ... holder key val ] */ - DUK_DDD(DUK_DDDPRINT("after: flags=0x%08lx, buf=%!O, loop=%!T, replacer=%!O, " - "proplist=%!T, gap=%!O, indent=%!O, holder=%!T", + DUK_DDD(DUK_DDDPRINT("after: flags=0x%08lx, loop=%!T, replacer=%!O, " + "proplist=%!T, gap=%!O, holder=%!T", (unsigned long) js_ctx->flags, - (duk_heaphdr *) js_ctx->h_buf, (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop), (duk_heaphdr *) js_ctx->h_replacer, (duk_tval *) (js_ctx->idx_proplist >= 0 ? duk_get_tval(ctx, js_ctx->idx_proplist) : NULL), (duk_heaphdr *) js_ctx->h_gap, - (duk_heaphdr *) js_ctx->h_indent, (duk_tval *) duk_get_tval(ctx, -3))); if (undef) { - /* - * Result is undefined - */ - + /* Result is undefined. */ duk_push_undefined(ctx); } else { - /* - * Finish and convert buffer to result string - */ - + /* Finish and convert buffer to result string. */ duk__enc_value2(js_ctx); /* [ ... key val ] -> [ ... ] */ - DUK_ASSERT(js_ctx->h_buf != NULL); - duk_push_hbuffer(ctx, (duk_hbuffer *) js_ctx->h_buf); - duk_to_string(ctx, -1); + DUK_BW_PUSH_AS_STRING(thr, &js_ctx->bw); } /* The stack has a variable shape here, so force it to the * desired one explicitly. */ +#if defined(DUK_USE_JSON_STRINGIFY_FASTPATH) + replace_finished: +#endif duk_replace(ctx, entry_top); duk_set_top(ctx, entry_top + 1); @@ -26989,6 +35192,12 @@ DUK_INTERNAL duk_ret_t duk_bi_json_object_stringify(duk_context *ctx) { 0 /*flags*/); return 1; } + +#undef DUK__JSON_DECSTR_BUFSIZE +#undef DUK__JSON_DECSTR_CHUNKSIZE +#undef DUK__JSON_ENCSTR_CHUNKSIZE +#undef DUK__JSON_STRINGIFY_BUFSIZE +#undef DUK__JSON_MAX_ESC_LEN #line 1 "duk_bi_logger.c" /* * Logging support @@ -27129,6 +35338,7 @@ DUK_INTERNAL duk_ret_t duk_bi_logger_prototype_log_shared(duk_context *ctx) { duk_small_int_t rc; DUK_ASSERT(entry_lev >= 0 && entry_lev <= 5); + DUK_UNREF(thr); /* XXX: sanitize to printable (and maybe ASCII) */ /* XXX: better multiline */ @@ -27166,7 +35376,7 @@ DUK_INTERNAL duk_ret_t duk_bi_logger_prototype_log_shared(duk_context *ctx) { } /* log level could be popped but that's not necessary */ - now = duk_bi_date_get_now(ctx); + now = DUK_USE_DATE_GET_NOW(ctx); duk_bi_date_format_timeval(now, date_buf); date_len = DUK_STRLEN((const char *) date_buf); @@ -27222,48 +35432,30 @@ DUK_INTERNAL duk_ret_t duk_bi_logger_prototype_log_shared(duk_context *ctx) { * Pass 2 */ - if (tot_len <= DUK_BI_LOGGER_SHORT_MSG_LIMIT) { - duk_hbuffer_dynamic *h_buf; + /* XXX: There used to be a shared log buffer here, but it was removed + * when dynamic buffer spare was removed. The problem with using + * bufwriter is that, without the spare, the buffer gets passed on + * as an argument to the raw() call so it'd need to be resized + * (reallocated) anyway. If raw() call convention is changed, this + * could be made more efficient. + */ - DUK_DDD(DUK_DDDPRINT("reuse existing small log message buffer, tot_len %ld", (long) tot_len)); - - /* We can assert for all buffer properties because user code - * never has access to heap->log_buffer. - */ - - DUK_ASSERT(thr != NULL); - DUK_ASSERT(thr->heap != NULL); - h_buf = thr->heap->log_buffer; - DUK_ASSERT(h_buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC((duk_hbuffer *) h_buf)); - DUK_ASSERT(DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(h_buf) == DUK_BI_LOGGER_SHORT_MSG_LIMIT); - - /* Set buffer 'visible size' to actual message length and - * push it to the stack. - */ - - DUK_HBUFFER_SET_SIZE((duk_hbuffer *) h_buf, tot_len); - duk_push_hbuffer(ctx, (duk_hbuffer *) h_buf); - buf = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h_buf); - } else { - DUK_DDD(DUK_DDDPRINT("use a one-off large log message buffer, tot_len %ld", (long) tot_len)); - buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, tot_len); - } + buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, tot_len); DUK_ASSERT(buf != NULL); p = buf; - DUK_MEMCPY((void *) p, (void *) date_buf, date_len); + DUK_MEMCPY((void *) p, (const void *) date_buf, (size_t) date_len); p += date_len; *p++ = (duk_uint8_t) DUK_ASC_SPACE; q = duk__log_level_strings + (entry_lev * 3); - DUK_MEMCPY((void *) p, (void *) q, (duk_size_t) 3); + DUK_MEMCPY((void *) p, (const void *) q, (size_t) 3); p += 3; *p++ = (duk_uint8_t) DUK_ASC_SPACE; arg_str = (const duk_uint8_t *) duk_get_lstring(ctx, -2, &arg_len); - DUK_MEMCPY((void *) p, (const void *) arg_str, arg_len); + DUK_MEMCPY((void *) p, (const void *) arg_str, (size_t) arg_len); p += arg_len; *p++ = (duk_uint8_t) DUK_ASC_COLON; @@ -27273,7 +35465,7 @@ DUK_INTERNAL duk_ret_t duk_bi_logger_prototype_log_shared(duk_context *ctx) { arg_str = (const duk_uint8_t *) duk_get_lstring(ctx, i, &arg_len); DUK_ASSERT(arg_str != NULL); - DUK_MEMCPY((void *) p, (const void *) arg_str, arg_len); + DUK_MEMCPY((void *) p, (const void *) arg_str, (size_t) arg_len); p += arg_len; } DUK_ASSERT(buf + tot_len == p); @@ -27940,7 +36132,7 @@ DUK_INTERNAL duk_ret_t duk_bi_object_constructor(duk_context *ctx) { /* Shared helper to implement Object.getPrototypeOf and the ES6 * Object.prototype.__proto__ getter. * - * https://people.mozilla.org/~jorendorff/es6-draft.html#sec-get-object.prototype.__proto__ + * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-get-object.prototype.__proto__ */ DUK_INTERNAL duk_ret_t duk_bi_object_getprototype_shared(duk_context *ctx) { duk_hthread *thr = (duk_hthread *) ctx; @@ -27980,8 +36172,8 @@ DUK_INTERNAL duk_ret_t duk_bi_object_getprototype_shared(duk_context *ctx) { /* Shared helper to implement ES6 Object.setPrototypeOf and * Object.prototype.__proto__ setter. * - * https://people.mozilla.org/~jorendorff/es6-draft.html#sec-get-object.prototype.__proto__ - * https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.setprototypeof + * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-get-object.prototype.__proto__ + * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-object.setprototypeof */ DUK_INTERNAL duk_ret_t duk_bi_object_setprototype_shared(duk_context *ctx) { duk_hthread *thr = (duk_hthread *) ctx; @@ -28024,7 +36216,6 @@ DUK_INTERNAL duk_ret_t duk_bi_object_setprototype_shared(duk_context *ctx) { DUK_ASSERT(h_obj != NULL); /* [[SetPrototypeOf]] standard behavior, E6 9.1.2 */ - /* NOTE: steps 7-8 seem to be a cut-paste bug in the E6 draft */ /* TODO: implement Proxy object support here */ if (h_new_proto == DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_obj)) { @@ -28385,6 +36576,12 @@ DUK_INTERNAL duk_ret_t duk_bi_object_constructor_keys_shared(duk_context *ctx) { } } + /* XXX: missing trap result validation for non-configurable target keys + * (must be present), for non-extensible target all target keys must be + * present and no extra keys can be present. + * http://www.ecma-international.org/ecma-262/6.0/#sec-proxy-object-internal-methods-and-internal-slots-ownpropertykeys + */ + /* XXX: for Object.keys() the [[OwnPropertyKeys]] result (trap result) * should be filtered so that only enumerable keys remain. Enumerability * should be checked with [[GetOwnProperty]] on the original object @@ -28418,31 +36615,8 @@ DUK_INTERNAL duk_ret_t duk_bi_object_constructor_keys_shared(duk_context *ctx) { } DUK_INTERNAL duk_ret_t duk_bi_object_prototype_to_string(duk_context *ctx) { - duk_hthread *thr = (duk_hthread *) ctx; - duk_push_this(ctx); - duk_push_string(ctx, "[object "); - - if (duk_is_undefined(ctx, -2)) { - duk_push_hstring_stridx(ctx, DUK_STRIDX_UC_UNDEFINED); - } else if (duk_is_null(ctx, -2)) { - duk_push_hstring_stridx(ctx, DUK_STRIDX_UC_NULL); - } else { - duk_hobject *h_this; - duk_hstring *h_classname; - - duk_to_object(ctx, -2); - h_this = duk_get_hobject(ctx, -2); - DUK_ASSERT(h_this != NULL); - - h_classname = DUK_HOBJECT_GET_CLASS_STRING(thr->heap, h_this); - DUK_ASSERT(h_classname != NULL); - - duk_push_hstring(ctx, h_classname); - } - - duk_push_string(ctx, "]"); - duk_concat(ctx, 3); + duk_to_object_class_string_top(ctx); return 1; } @@ -28454,7 +36628,7 @@ DUK_INTERNAL duk_ret_t duk_bi_object_prototype_to_locale_string(duk_context *ctx return DUK_RET_TYPE_ERROR; } duk_dup(ctx, 0); /* -> [ O toString O ] */ - duk_call_method(ctx, 0); /* XXX: call method tailcall? */ + duk_call_method(ctx, 0); /* XXX: call method tail call? */ return 1; } @@ -28570,7 +36744,7 @@ DUK_INTERNAL duk_ret_t duk_bi_pointer_prototype_tostring_shared(duk_context *ctx } #line 1 "duk_bi_proxy.c" /* - * Proxy built-in (ES6 draft) + * Proxy built-in (ES6) */ /* include removed: duk_internal.h */ @@ -28602,7 +36776,7 @@ DUK_INTERNAL duk_ret_t duk_bi_proxy_constructor(duk_context *ctx) { return DUK_RET_TYPE_ERROR; } - /* XXX: the returned value is exotic in ES6 (draft), but we use a + /* XXX: the returned value is exotic in ES6, but we use a * simple object here with no prototype. Without a prototype, * [[DefaultValue]] coercion fails which is abit confusing. * No callable check/handling in the current Proxy subset. @@ -28614,13 +36788,18 @@ DUK_INTERNAL duk_ret_t duk_bi_proxy_constructor(duk_context *ctx) { NULL); DUK_ASSERT_TOP(ctx, 3); + /* Make _Target and _Handler non-configurable and non-writable. + * They can still be forcibly changed by C code (both user and + * Duktape internal), but not by Ecmascript code. + */ + /* Proxy target */ duk_dup(ctx, 0); - duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_TARGET, DUK_PROPDESC_FLAGS_WC); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_TARGET, DUK_PROPDESC_FLAGS_NONE); /* Proxy handler */ duk_dup(ctx, 1); - duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_HANDLER, DUK_PROPDESC_FLAGS_WC); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_HANDLER, DUK_PROPDESC_FLAGS_NONE); return 1; /* replacement handler */ } @@ -28891,7 +37070,8 @@ DUK_INTERNAL duk_ret_t duk_bi_string_constructor(duk_context *ctx) { DUK_INTERNAL duk_ret_t duk_bi_string_constructor_from_char_code(duk_context *ctx) { duk_hthread *thr = (duk_hthread *) ctx; - duk_hbuffer_dynamic *h; + duk_bufwriter_ctx bw_alloc; + duk_bufwriter_ctx *bw; duk_idx_t i, n; duk_ucodepoint_t cp; @@ -28902,24 +37082,31 @@ DUK_INTERNAL duk_ret_t duk_bi_string_constructor_from_char_code(duk_context *ctx */ n = duk_get_top(ctx); - duk_push_dynamic_buffer(ctx, 0); /* XXX: initial spare size estimate from 'n' */ - h = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1); + + bw = &bw_alloc; + DUK_BW_INIT_PUSHBUF(thr, bw, n); /* initial estimate for ASCII only codepoints */ for (i = 0; i < n; i++) { + /* XXX: could improve bufwriter handling to write multiple codepoints + * with one ensure call but the relative benefit would be quite small. + */ + #if defined(DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT) /* ToUint16() coercion is mandatory in the E5.1 specification, but * this non-compliant behavior makes more sense because we support * non-BMP codepoints. Don't use CESU-8 because that'd create * surrogate pairs. */ + cp = (duk_ucodepoint_t) duk_to_uint32(ctx, i); - duk_hbuffer_append_xutf8(thr, h, cp); + DUK_BW_WRITE_ENSURE_XUTF8(thr, bw, cp); #else - cp = (duk_ucodepoint_t) duk_to_uint16(ctx, i); - duk_hbuffer_append_cesu8(thr, h, cp); + cp = (duk_ucodepoint_t) duk_to_uint32(ctx, i); + DUK_BW_WRITE_ENSURE_CESU8(thr, bw, cp); #endif } + DUK_BW_COMPACT(thr, bw); duk_to_string(ctx, -1); return 1; } @@ -29214,7 +37401,7 @@ DUK_INTERNAL duk_ret_t duk_bi_string_prototype_indexof_shared(duk_context *ctx) if ((t == firstbyte) && ((duk_size_t) (p_end - p) >= (duk_size_t) q_blen)) { DUK_ASSERT(q_blen > 0); /* no issues with memcmp() zero size, even if broken */ - if (DUK_MEMCMP(p, q_start, (duk_size_t) q_blen) == 0) { + if (DUK_MEMCMP((const void *) p, (const void *) q_start, (size_t) q_blen) == 0) { duk_push_int(ctx, cpos); return 1; } @@ -29265,7 +37452,8 @@ DUK_INTERNAL duk_ret_t duk_bi_string_prototype_replace(duk_context *ctx) { duk_hstring *h_match; duk_hstring *h_search; duk_hobject *h_re; - duk_hbuffer_dynamic *h_buf; + duk_bufwriter_ctx bw_alloc; + duk_bufwriter_ctx *bw; #ifdef DUK_USE_REGEXP_SUPPORT duk_bool_t is_regexp; duk_bool_t is_global; @@ -29277,13 +37465,15 @@ DUK_INTERNAL duk_ret_t duk_bi_string_prototype_replace(duk_context *ctx) { #endif duk_uint32_t prev_match_end_boff; const duk_uint8_t *r_start, *r_end, *r; /* repl string scan */ + duk_size_t tmp_sz; DUK_ASSERT_TOP(ctx, 2); h_input = duk_push_this_coercible_to_string(ctx); DUK_ASSERT(h_input != NULL); - duk_push_dynamic_buffer(ctx, 0); - h_buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1); - DUK_ASSERT(h_buf != NULL); + + bw = &bw_alloc; + DUK_BW_INIT_PUSHBUF(thr, bw, DUK_HSTRING_GET_BYTELEN(h_input)); /* input size is good output starting point */ + DUK_ASSERT_TOP(ctx, 4); /* stack[0] = search value @@ -29421,7 +37611,7 @@ DUK_INTERNAL duk_ret_t duk_bi_string_prototype_replace(duk_context *ctx) { while (p <= p_end) { DUK_ASSERT(p + q_blen <= DUK_HSTRING_GET_DATA(h_input) + DUK_HSTRING_GET_BYTELEN(h_input)); - if (DUK_MEMCMP((void *) p, (void *) q_start, (size_t) q_blen) == 0) { + if (DUK_MEMCMP((const void *) p, (const void *) q_start, (size_t) q_blen) == 0) { duk_dup(ctx, 0); h_match = duk_get_hstring(ctx, -1); DUK_ASSERT(h_match != NULL); @@ -29452,10 +37642,8 @@ DUK_INTERNAL duk_ret_t duk_bi_string_prototype_replace(duk_context *ctx) { match_start_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_start_coff); - duk_hbuffer_append_bytes(thr, - h_buf, - DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff, - (duk_size_t) (match_start_boff - prev_match_end_boff)); + tmp_sz = (duk_size_t) (match_start_boff - prev_match_end_boff); + DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff, tmp_sz); prev_match_end_boff = match_start_boff + DUK_HSTRING_GET_BYTELEN(h_match); @@ -29491,7 +37679,9 @@ DUK_INTERNAL duk_ret_t duk_bi_string_prototype_replace(duk_context *ctx) { duk_call(ctx, duk_get_top(ctx) - idx_args); h_repl = duk_to_hstring(ctx, -1); /* -> [ ... repl_value ] */ DUK_ASSERT(h_repl != NULL); - duk_hbuffer_append_hstring(thr, h_buf, h_repl); + + DUK_BW_WRITE_ENSURE_HSTRING(thr, bw, h_repl); + duk_pop(ctx); /* repl_value */ } else { r = r_start; @@ -29521,15 +37711,13 @@ DUK_INTERNAL duk_ret_t duk_bi_string_prototype_replace(duk_context *ctx) { goto repl_write; } case DUK_ASC_AMP: { - duk_hbuffer_append_hstring(thr, h_buf, h_match); + DUK_BW_WRITE_ENSURE_HSTRING(thr, bw, h_match); r++; continue; } case DUK_ASC_GRAVE: { - duk_hbuffer_append_bytes(thr, - h_buf, - DUK_HSTRING_GET_DATA(h_input), - match_start_boff); + tmp_sz = (duk_size_t) match_start_boff; + DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input), tmp_sz); r++; continue; } @@ -29543,10 +37731,8 @@ DUK_INTERNAL duk_ret_t duk_bi_string_prototype_replace(duk_context *ctx) { h_input, match_start_coff + DUK_HSTRING_GET_CHARLEN(h_match)); - duk_hbuffer_append_bytes(thr, - h_buf, - DUK_HSTRING_GET_DATA(h_input) + match_end_boff, - DUK_HSTRING_GET_BYTELEN(h_input) - match_end_boff); + tmp_sz = (duk_size_t) (DUK_HSTRING_GET_BYTELEN(h_input) - match_end_boff); + DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input) + match_end_boff, tmp_sz); r++; continue; } @@ -29584,8 +37770,12 @@ DUK_INTERNAL duk_ret_t duk_bi_string_prototype_replace(duk_context *ctx) { /* regexp res_obj is at offset 4 */ duk_get_prop_index(ctx, 4, (duk_uarridx_t) capnum); if (duk_is_string(ctx, -1)) { - DUK_ASSERT(duk_get_hstring(ctx, -1) != NULL); - duk_hbuffer_append_hstring(thr, h_buf, duk_get_hstring(ctx, -1)); + duk_hstring *h_tmp_str; + + h_tmp_str = duk_get_hstring(ctx, -1); + DUK_ASSERT(h_tmp_str != NULL); + + DUK_BW_WRITE_ENSURE_HSTRING(thr, bw, h_tmp_str); } else { /* undefined -> skip (replaced with empty) */ } @@ -29603,7 +37793,8 @@ DUK_INTERNAL duk_ret_t duk_bi_string_prototype_replace(duk_context *ctx) { repl_write: /* ch1 = (r_increment << 8) + byte */ - duk_hbuffer_append_byte(thr, h_buf, (duk_uint8_t) (ch1 & 0xff)); + + DUK_BW_WRITE_ENSURE_U8(thr, bw, (duk_uint8_t) (ch1 & 0xff)); r += ch1 >> 8; } /* while repl */ } /* if (is_repl_func) */ @@ -29620,12 +37811,11 @@ DUK_INTERNAL duk_ret_t duk_bi_string_prototype_replace(duk_context *ctx) { } /* trailer */ - duk_hbuffer_append_bytes(thr, - h_buf, - DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff, - (duk_size_t) (DUK_HSTRING_GET_BYTELEN(h_input) - prev_match_end_boff)); + tmp_sz = (duk_size_t) (DUK_HSTRING_GET_BYTELEN(h_input) - prev_match_end_boff); + DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff, tmp_sz); DUK_ASSERT_TOP(ctx, 4); + DUK_BW_COMPACT(thr, bw); duk_to_string(ctx, -1); return 1; } @@ -29806,7 +37996,7 @@ DUK_INTERNAL duk_ret_t duk_bi_string_prototype_split(duk_context *ctx) { while (p <= p_end) { DUK_ASSERT(p + q_blen <= DUK_HSTRING_GET_DATA(h_input) + DUK_HSTRING_GET_BYTELEN(h_input)); DUK_ASSERT(q_blen > 0); /* no issues with empty memcmp() */ - if (DUK_MEMCMP((void *) p, (void *) q_start, (duk_size_t) q_blen) == 0) { + if (DUK_MEMCMP((const void *) p, (const void *) q_start, (size_t) q_blen) == 0) { /* never an empty match, so step 13.c.iii can't be triggered */ goto found; } @@ -30117,9 +38307,9 @@ DUK_INTERNAL duk_ret_t duk_bi_string_prototype_locale_compare(duk_context *ctx) prefix_len = (h1_len <= h2_len ? h1_len : h2_len); /* Zero size compare not an issue with DUK_MEMCMP. */ - rc = (duk_small_int_t) DUK_MEMCMP((const char *) DUK_HSTRING_GET_DATA(h1), - (const char *) DUK_HSTRING_GET_DATA(h2), - prefix_len); + rc = (duk_small_int_t) DUK_MEMCMP((const void *) DUK_HSTRING_GET_DATA(h1), + (const void *) DUK_HSTRING_GET_DATA(h2), + (size_t) prefix_len); if (rc < 0) { ret = -1; @@ -30197,7 +38387,6 @@ DUK_INTERNAL duk_ret_t duk_bi_thread_constructor(duk_context *ctx) { DUK_INTERNAL duk_ret_t duk_bi_thread_resume(duk_context *ctx) { duk_hthread *thr = (duk_hthread *) ctx; duk_hthread *thr_resume; - duk_tval tv_tmp; duk_tval *tv; duk_hobject *func; duk_hobject *caller_func; @@ -30312,21 +38501,18 @@ DUK_INTERNAL duk_ret_t duk_bi_thread_resume(duk_context *ctx) { /* lj value2: thread */ DUK_ASSERT(thr->valstack_bottom < thr->valstack_top); - DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value2); - DUK_TVAL_SET_TVAL(&thr->heap->lj.value2, &thr->valstack_bottom[0]); - DUK_TVAL_INCREF(thr, &thr->heap->lj.value2); - DUK_TVAL_DECREF(thr, &tv_tmp); + DUK_TVAL_SET_TVAL_UPDREF(thr, &thr->heap->lj.value2, &thr->valstack_bottom[0]); /* side effects */ /* lj value1: value */ DUK_ASSERT(thr->valstack_bottom + 1 < thr->valstack_top); - DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1); - DUK_TVAL_SET_TVAL(&thr->heap->lj.value1, &thr->valstack_bottom[1]); - DUK_TVAL_INCREF(thr, &thr->heap->lj.value1); - DUK_TVAL_DECREF(thr, &tv_tmp); + DUK_TVAL_SET_TVAL_UPDREF(thr, &thr->heap->lj.value1, &thr->valstack_bottom[1]); /* side effects */ + DUK_TVAL_CHKFAST_INPLACE(&thr->heap->lj.value1); thr->heap->lj.iserror = is_error; +#if !defined(DUK_USE_CPP_EXCEPTIONS) DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); /* call is from executor, so we know we have a jmpbuf */ +#endif duk_err_longjmp(thr); /* execution resumes in bytecode executor */ return 0; /* never here */ @@ -30356,7 +38542,6 @@ DUK_INTERNAL duk_ret_t duk_bi_thread_resume(duk_context *ctx) { DUK_INTERNAL duk_ret_t duk_bi_thread_yield(duk_context *ctx) { duk_hthread *thr = (duk_hthread *) ctx; - duk_tval tv_tmp; duk_hobject *caller_func; duk_small_int_t is_error; @@ -30439,14 +38624,14 @@ DUK_INTERNAL duk_ret_t duk_bi_thread_yield(duk_context *ctx) { /* lj value1: value */ DUK_ASSERT(thr->valstack_bottom < thr->valstack_top); - DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1); - DUK_TVAL_SET_TVAL(&thr->heap->lj.value1, &thr->valstack_bottom[0]); - DUK_TVAL_INCREF(thr, &thr->heap->lj.value1); - DUK_TVAL_DECREF(thr, &tv_tmp); + DUK_TVAL_SET_TVAL_UPDREF(thr, &thr->heap->lj.value1, &thr->valstack_bottom[0]); /* side effects */ + DUK_TVAL_CHKFAST_INPLACE(&thr->heap->lj.value1); thr->heap->lj.iserror = is_error; +#if !defined(DUK_USE_CPP_EXCEPTIONS) DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); /* call is from executor, so we know we have a jmpbuf */ +#endif duk_err_longjmp(thr); /* execution resumes in bytecode executor */ return 0; /* never here */ @@ -30480,7 +38665,7 @@ DUK_INTERNAL duk_ret_t duk_bi_type_error_thrower(duk_context *ctx) { #ifdef DUK_USE_DEBUG -DUK_INTERNAL void duk_fb_put_bytes(duk_fixedbuffer *fb, duk_uint8_t *buffer, duk_size_t length) { +DUK_INTERNAL void duk_fb_put_bytes(duk_fixedbuffer *fb, const duk_uint8_t *buffer, duk_size_t length) { duk_size_t avail; duk_size_t copylen; @@ -30496,11 +38681,11 @@ DUK_INTERNAL void duk_fb_put_bytes(duk_fixedbuffer *fb, duk_uint8_t *buffer, duk } DUK_INTERNAL void duk_fb_put_byte(duk_fixedbuffer *fb, duk_uint8_t x) { - duk_fb_put_bytes(fb, &x, 1); + duk_fb_put_bytes(fb, (const duk_uint8_t *) &x, 1); } DUK_INTERNAL void duk_fb_put_cstring(duk_fixedbuffer *fb, const char *x) { - duk_fb_put_bytes(fb, (duk_uint8_t *) x, (duk_size_t) DUK_STRLEN(x)); + duk_fb_put_bytes(fb, (const duk_uint8_t *) x, (duk_size_t) DUK_STRLEN(x)); } DUK_INTERNAL void duk_fb_sprintf(duk_fixedbuffer *fb, const char *fmt, ...) { @@ -31179,7 +39364,7 @@ DUK_LOCAL void duk__print_hobject(duk__dprint_state *st, duk_hobject *h) { /* leave out trailing 'unused' elements */ while (a_limit > 0) { tv = DUK_HOBJECT_A_GET_VALUE_PTR(NULL, h, a_limit - 1); - if (!DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) { + if (!DUK_TVAL_IS_UNUSED(tv)) { break; } a_limit--; @@ -31299,7 +39484,7 @@ DUK_LOCAL void duk__print_hobject(duk__dprint_state *st, duk_hobject *h) { } else { ; } - if (DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(h)) { + if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) { DUK__COMMA(); duk_fb_sprintf(fb, "__special_bufferobj:true"); } else { ; @@ -31327,6 +39512,14 @@ DUK_LOCAL void duk__print_hobject(duk__dprint_state *st, duk_hobject *h) { DUK__COMMA(); duk_fb_sprintf(fb, "__func:"); duk_fb_put_funcptr(fb, (duk_uint8_t *) &f->func, sizeof(f->func)); DUK__COMMA(); duk_fb_sprintf(fb, "__nargs:%ld", (long) f->nargs); + } else if (st->internal && DUK_HOBJECT_IS_BUFFEROBJECT(h)) { + duk_hbufferobject *b = (duk_hbufferobject *) h; + DUK__COMMA(); duk_fb_sprintf(fb, "__buf:"); + duk__print_hbuffer(st, (duk_hbuffer *) b->buf); + DUK__COMMA(); duk_fb_sprintf(fb, "__offset:%ld", (long) b->offset); + DUK__COMMA(); duk_fb_sprintf(fb, "__length:%ld", (long) b->length); + DUK__COMMA(); duk_fb_sprintf(fb, "__shift:%ld", (long) b->shift); + DUK__COMMA(); duk_fb_sprintf(fb, "__elemtype:%ld", (long) b->elem_type); } else if (st->internal && DUK_HOBJECT_IS_THREAD(h)) { duk_hthread *t = (duk_hthread *) h; DUK__COMMA(); duk_fb_sprintf(fb, "__strict:%ld", (long) t->strict); @@ -31410,11 +39603,17 @@ DUK_LOCAL void duk__print_hbuffer(duk__dprint_state *st, duk_hbuffer *h) { } if (DUK_HBUFFER_HAS_DYNAMIC(h)) { - duk_hbuffer_dynamic *g = (duk_hbuffer_dynamic *) h; - duk_fb_sprintf(fb, "buffer:dynamic:%p:%ld:%ld", - (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(NULL, g), - (long) DUK_HBUFFER_DYNAMIC_GET_SIZE(g), - (long) DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(g)); + if (DUK_HBUFFER_HAS_EXTERNAL(h)) { + duk_hbuffer_external *g = (duk_hbuffer_external *) h; + duk_fb_sprintf(fb, "buffer:external:%p:%ld", + (void *) DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(NULL, g), + (long) DUK_HBUFFER_EXTERNAL_GET_SIZE(g)); + } else { + duk_hbuffer_dynamic *g = (duk_hbuffer_dynamic *) h; + duk_fb_sprintf(fb, "buffer:dynamic:%p:%ld", + (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(NULL, g), + (long) DUK_HBUFFER_DYNAMIC_GET_SIZE(g)); + } } else { duk_fb_sprintf(fb, "buffer:fixed:%ld", (long) DUK_HBUFFER_GET_SIZE(h)); } @@ -31494,11 +39693,11 @@ DUK_LOCAL void duk__print_tval(duk__dprint_state *st, duk_tval *tv) { } switch (DUK_TVAL_GET_TAG(tv)) { case DUK_TAG_UNDEFINED: { - if (DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) { - duk_fb_put_cstring(fb, "unused"); - } else { - duk_fb_put_cstring(fb, "undefined"); - } + duk_fb_put_cstring(fb, "undefined"); + break; + } + case DUK_TAG_UNUSED: { + duk_fb_put_cstring(fb, "unused"); break; } case DUK_TAG_NULL: { @@ -31541,6 +39740,7 @@ DUK_LOCAL void duk__print_tval(duk__dprint_state *st, duk_tval *tv) { #endif default: { /* IEEE double is approximately 16 decimal digits; print a couple extra */ + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv)); DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); duk_fb_sprintf(fb, "%.18g", (double) DUK_TVAL_GET_NUMBER(tv)); break; @@ -31842,31 +40042,55 @@ typedef union { * Detach handling */ -#define DUK__SET_CONN_BROKEN(thr) do { \ +#define DUK__SET_CONN_BROKEN(thr,reason) do { \ /* For now shared handler is fine. */ \ - duk_debug_do_detach((thr)->heap); \ + duk__debug_do_detach1((thr)->heap, (reason)); \ } while (0) -DUK_INTERNAL void duk_debug_do_detach(duk_heap *heap) { - /* Can be called muliple times with no harm. */ +DUK_LOCAL void duk__debug_do_detach1(duk_heap *heap, duk_int_t reason) { + /* Can be called multiple times with no harm. Mark the transport + * bad (dbg_read_cb == NULL) and clear state except for the detached + * callback and the udata field. The detached callback is delayed + * to the message loop so that it can be called between messages; + * this avoids corner cases related to immediate debugger reattach + * inside the detached callback. + */ + + if (heap->dbg_detaching) { + return; + } + + DUK_D(DUK_DPRINT("debugger transport detaching, marking transport broken")); + + heap->dbg_detaching = 1; /* prevent multiple in-progress detaches */ + + if (heap->dbg_write_cb != NULL) { + duk_hthread *thr; + + thr = heap->heap_thread; + DUK_ASSERT(thr != NULL); + + duk_debug_write_notify(thr, DUK_DBG_CMD_DETACHING); + duk_debug_write_int(thr, reason); + duk_debug_write_eom(thr); + } heap->dbg_read_cb = NULL; heap->dbg_write_cb = NULL; heap->dbg_peek_cb = NULL; heap->dbg_read_flush_cb = NULL; heap->dbg_write_flush_cb = NULL; - if (heap->dbg_detached_cb) { - heap->dbg_detached_cb(heap->dbg_udata); - } - heap->dbg_detached_cb = NULL; - heap->dbg_udata = NULL; + /* heap->dbg_detached_cb: keep */ + /* heap->dbg_udata: keep */ heap->dbg_processing = 0; heap->dbg_paused = 0; heap->dbg_state_dirty = 0; + heap->dbg_force_restart = 0; heap->dbg_step_type = 0; heap->dbg_step_thread = NULL; heap->dbg_step_csindex = 0; heap->dbg_step_startline = 0; + heap->dbg_have_next_byte = 0; /* Ensure there are no stale active breakpoint pointers. * Breakpoint list is currently kept - we could empty it @@ -31878,6 +40102,34 @@ DUK_INTERNAL void duk_debug_do_detach(duk_heap *heap) { heap->dbg_breakpoints_active[0] = (duk_breakpoint *) NULL; } +DUK_LOCAL void duk__debug_do_detach2(duk_heap *heap) { + duk_debug_detached_function detached_cb; + void *detached_udata; + + /* Safe to call multiple times. */ + + detached_cb = heap->dbg_detached_cb; + detached_udata = heap->dbg_udata; + heap->dbg_detached_cb = NULL; + heap->dbg_udata = NULL; + + if (detached_cb) { + /* Careful here: state must be wiped before the call + * so that we can cleanly handle a re-attach from + * inside the callback. + */ + DUK_D(DUK_DPRINT("detached during message loop, delayed call to detached_cb")); + detached_cb(detached_udata); + } + + heap->dbg_detaching = 0; +} + +DUK_INTERNAL void duk_debug_do_detach(duk_heap *heap) { + duk__debug_do_detach1(heap, 0); + duk__debug_do_detach2(heap); +} + /* * Debug connection peek and flush primitives */ @@ -31967,6 +40219,21 @@ DUK_INTERNAL void duk_debug_skip_byte(duk_hthread *thr) { * Debug connection read primitives */ +/* Peek ahead in the stream one byte. */ +DUK_INTERNAL uint8_t duk_debug_peek_byte(duk_hthread *thr) { + /* It is important not to call this if the last byte read was an EOM. + * Reading ahead in this scenario would cause unnecessary blocking if + * another message is not available. + */ + + duk_uint8_t x; + + x = duk_debug_read_byte(thr); + thr->heap->dbg_have_next_byte = 1; + thr->heap->dbg_next_byte = x; + return x; +} + /* Read fully. */ DUK_INTERNAL void duk_debug_read_bytes(duk_hthread *thr, duk_uint8_t *data, duk_size_t length) { duk_heap *heap; @@ -31983,7 +40250,12 @@ DUK_INTERNAL void duk_debug_read_bytes(duk_hthread *thr, duk_uint8_t *data, duk_ goto fail; } + /* NOTE: length may be zero */ p = data; + if (length >= 1 && heap->dbg_have_next_byte) { + heap->dbg_have_next_byte = 0; + *p++ = heap->dbg_next_byte; + } for (;;) { left = (duk_size_t) ((data + length) - p); if (left == 0) { @@ -31996,8 +40268,9 @@ DUK_INTERNAL void duk_debug_read_bytes(duk_hthread *thr, duk_uint8_t *data, duk_ #endif got = heap->dbg_read_cb(heap->dbg_udata, (char *) p, left); if (got == 0 || got > left) { + heap->dbg_write_cb = NULL; /* squelch further writes */ DUK_D(DUK_DPRINT("connection error during read, return zero data")); - DUK__SET_CONN_BROKEN(thr); + DUK__SET_CONN_BROKEN(thr, 1); goto fail; } p += got; @@ -32009,28 +40282,10 @@ DUK_INTERNAL void duk_debug_read_bytes(duk_hthread *thr, duk_uint8_t *data, duk_ } DUK_INTERNAL duk_uint8_t duk_debug_read_byte(duk_hthread *thr) { - duk_heap *heap; - duk_size_t got; duk_uint8_t x; - DUK_ASSERT(thr != NULL); - heap = thr->heap; - DUK_ASSERT(heap != NULL); - - if (heap->dbg_read_cb == NULL) { - DUK_D(DUK_DPRINT("attempt to read 1 bytes in detached state, return zero data")); - return 0; - } - x = 0; /* just in case callback is broken and won't write 'x' */ - DUK_ASSERT(heap->dbg_read_cb != NULL); - got = heap->dbg_read_cb(heap->dbg_udata, (char *) (&x), 1); - if (got != 1) { - DUK_D(DUK_DPRINT("connection error during read, return zero data")); - DUK__SET_CONN_BROKEN(thr); - return 0; - } - + duk_debug_read_bytes(thr, &x, 1); return x; } @@ -32077,7 +40332,7 @@ DUK_INTERNAL duk_int32_t duk_debug_read_int(duk_hthread *thr) { } DUK_D(DUK_DPRINT("debug connection error: failed to decode int")); - DUK__SET_CONN_BROKEN(thr); + DUK__SET_CONN_BROKEN(thr, 1); return 0; } @@ -32122,7 +40377,7 @@ DUK_INTERNAL duk_hstring *duk_debug_read_hstring(duk_hthread *thr) { fail: DUK_D(DUK_DPRINT("debug connection error: failed to decode int")); - DUK__SET_CONN_BROKEN(thr); + DUK__SET_CONN_BROKEN(thr, 1); duk_push_hstring_stridx(thr, DUK_STRIDX_EMPTY_STRING); /* always push some string */ return duk_require_hstring(ctx, -1); } @@ -32138,9 +40393,9 @@ DUK_LOCAL duk_hbuffer *duk__debug_read_hbuffer_raw(duk_hthread *thr, duk_uint32_ return duk_require_hbuffer(ctx, -1); } -DUK_LOCAL const void *duk__debug_read_pointer_raw(duk_hthread *thr) { +DUK_LOCAL void *duk__debug_read_pointer_raw(duk_hthread *thr) { duk_small_uint_t x; - volatile duk__ptr_union pu; + duk__ptr_union pu; DUK_ASSERT(thr != NULL); @@ -32152,12 +40407,12 @@ DUK_LOCAL const void *duk__debug_read_pointer_raw(duk_hthread *thr) { #if defined(DUK_USE_INTEGER_LE) duk_byteswap_bytes((duk_uint8_t *) pu.b, sizeof(pu)); #endif - return (const void *) pu.p; + return (void *) pu.p; fail: DUK_D(DUK_DPRINT("debug connection error: failed to decode pointer")); - DUK__SET_CONN_BROKEN(thr); - return (const void *) NULL; + DUK__SET_CONN_BROKEN(thr, 1); + return (void *) NULL; } DUK_LOCAL duk_double_t duk__debug_read_double_raw(duk_hthread *thr) { @@ -32165,7 +40420,7 @@ DUK_LOCAL duk_double_t duk__debug_read_double_raw(duk_hthread *thr) { DUK_ASSERT(sizeof(du.uc) == 8); duk_debug_read_bytes(thr, (duk_uint8_t *) du.uc, sizeof(du.uc)); - DUK_DBLUNION_BSWAP(&du); + DUK_DBLUNION_DOUBLE_NTOH(&du); return du.d; } @@ -32217,9 +40472,6 @@ DUK_INTERNAL void duk_debug_read_tval(duk_hthread *thr) { len = duk__debug_read_uint16_raw(thr); duk__debug_read_hbuffer_raw(thr, len); break; - case 0x15: - duk_push_unused(ctx); - break; case 0x16: duk_push_undefined(ctx); break; @@ -32243,9 +40495,9 @@ DUK_INTERNAL void duk_debug_read_tval(duk_hthread *thr) { DUK_D(DUK_DPRINT("reading object values unimplemented")); goto fail; case 0x1c: { - const void *ptr; + void *ptr; ptr = duk__debug_read_pointer_raw(thr); - duk_push_pointer(thr, (void *) ptr); + duk_push_pointer(thr, ptr); break; } case 0x1d: @@ -32258,6 +40510,7 @@ DUK_INTERNAL void duk_debug_read_tval(duk_hthread *thr) { duk_push_heapptr(thr, (void *) h); break; } + case 0x15: /* unused: not accepted in inbound messages */ default: goto fail; } @@ -32266,7 +40519,7 @@ DUK_INTERNAL void duk_debug_read_tval(duk_hthread *thr) { fail: DUK_D(DUK_DPRINT("debug connection error: failed to decode tval")); - DUK__SET_CONN_BROKEN(thr); + DUK__SET_CONN_BROKEN(thr, 1); } /* @@ -32310,8 +40563,9 @@ DUK_INTERNAL void duk_debug_write_bytes(duk_hthread *thr, const duk_uint8_t *dat #endif got = heap->dbg_write_cb(heap->dbg_udata, (const char *) p, left); if (got == 0 || got > left) { + heap->dbg_write_cb = NULL; /* squelch further writes */ DUK_D(DUK_DPRINT("connection error during write")); - DUK__SET_CONN_BROKEN(thr); + DUK__SET_CONN_BROKEN(thr, 1); return; } p += got; @@ -32335,7 +40589,7 @@ DUK_INTERNAL void duk_debug_write_byte(duk_hthread *thr, duk_uint8_t x) { got = heap->dbg_write_cb(heap->dbg_udata, (const char *) (&x), 1); if (got != 1) { DUK_D(DUK_DPRINT("connection error during write")); - DUK__SET_CONN_BROKEN(thr); + DUK__SET_CONN_BROKEN(thr, 1); } } @@ -32432,6 +40686,11 @@ DUK_INTERNAL void duk_debug_write_hstring(duk_hthread *thr, duk_hstring *h) { (h != NULL ? (duk_size_t) DUK_HSTRING_GET_BYTELEN(h) : 0)); } +DUK_LOCAL void duk__debug_write_hstring_safe_top(duk_hthread *thr) { + duk_context *ctx = (duk_context *) thr; + duk_debug_write_hstring(thr, duk_safe_to_hstring(ctx, -1)); +} + DUK_INTERNAL void duk_debug_write_buffer(duk_hthread *thr, const char *data, duk_size_t length) { duk_debug_write_strbuf(thr, data, length, 0x13); } @@ -32444,9 +40703,9 @@ DUK_INTERNAL void duk_debug_write_hbuffer(duk_hthread *thr, duk_hbuffer *h) { (h != NULL ? (duk_size_t) DUK_HBUFFER_GET_SIZE(h) : 0)); } -DUK_LOCAL void duk__debug_write_pointer_raw(duk_hthread *thr, const void *ptr, duk_uint8_t ibyte) { +DUK_LOCAL void duk__debug_write_pointer_raw(duk_hthread *thr, void *ptr, duk_uint8_t ibyte) { duk_uint8_t buf[2]; - volatile duk__ptr_union pu; + duk__ptr_union pu; DUK_ASSERT(thr != NULL); DUK_ASSERT(sizeof(ptr) >= 1 && sizeof(ptr) <= 16); @@ -32462,19 +40721,19 @@ DUK_LOCAL void duk__debug_write_pointer_raw(duk_hthread *thr, const void *ptr, d duk_debug_write_bytes(thr, (const duk_uint8_t *) &pu.p, (duk_size_t) sizeof(pu)); } -DUK_INTERNAL void duk_debug_write_pointer(duk_hthread *thr, const void *ptr) { +DUK_INTERNAL void duk_debug_write_pointer(duk_hthread *thr, void *ptr) { duk__debug_write_pointer_raw(thr, ptr, 0x1c); } #if defined(DUK_USE_DEBUGGER_DUMPHEAP) DUK_INTERNAL void duk_debug_write_heapptr(duk_hthread *thr, duk_heaphdr *h) { - duk__debug_write_pointer_raw(thr, (const void *) h, 0x1e); + duk__debug_write_pointer_raw(thr, (void *) h, 0x1e); } #endif /* DUK_USE_DEBUGGER_DUMPHEAP */ DUK_INTERNAL void duk_debug_write_hobject(duk_hthread *thr, duk_hobject *obj) { duk_uint8_t buf[3]; - volatile duk__ptr_union pu; + duk__ptr_union pu; DUK_ASSERT(thr != NULL); DUK_ASSERT(sizeof(obj) >= 1 && sizeof(obj) <= 16); @@ -32502,8 +40761,10 @@ DUK_INTERNAL void duk_debug_write_tval(duk_hthread *thr, duk_tval *tv) { switch (DUK_TVAL_GET_TAG(tv)) { case DUK_TAG_UNDEFINED: - duk_debug_write_byte(thr, - DUK_TVAL_IS_UNDEFINED_UNUSED(tv) ? 0x15 : 0x16); + duk_debug_write_byte(thr, 0x16); + break; + case DUK_TAG_UNUSED: + duk_debug_write_byte(thr, 0x15); break; case DUK_TAG_NULL: duk_debug_write_byte(thr, 0x17); @@ -32514,7 +40775,7 @@ DUK_INTERNAL void duk_debug_write_tval(duk_hthread *thr, duk_tval *tv) { duk_debug_write_byte(thr, DUK_TVAL_GET_BOOLEAN(tv) ? 0x18 : 0x19); break; case DUK_TAG_POINTER: - duk_debug_write_pointer(thr, (const void *) DUK_TVAL_GET_POINTER(tv)); + duk_debug_write_pointer(thr, (void *) DUK_TVAL_GET_POINTER(tv)); break; case DUK_TAG_LIGHTFUNC: DUK_TVAL_GET_LIGHTFUNC(tv, lf_func, lf_flags); @@ -32539,9 +40800,10 @@ DUK_INTERNAL void duk_debug_write_tval(duk_hthread *thr, duk_tval *tv) { #endif default: /* Numbers are normalized to big (network) endian. */ + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv)); DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); du.d = DUK_TVAL_GET_NUMBER(tv); - DUK_DBLUNION_BSWAP(&du); + DUK_DBLUNION_DOUBLE_HTON(&du); duk_debug_write_byte(thr, 0x1a); duk_debug_write_bytes(thr, (const duk_uint8_t *) du.uc, sizeof(du.uc)); @@ -32611,22 +40873,24 @@ DUK_INTERNAL duk_uint_fast32_t duk_debug_curr_line(duk_hthread *thr) { duk_uint_fast32_t line; duk_uint_fast32_t pc; - if (thr->callstack_top == 0) { + act = duk_hthread_get_current_activation(thr); /* may be NULL */ + if (act == NULL) { return 0; } - act = thr->callstack + thr->callstack_top - 1; - /* act->pc indicates the next instruction about to be executed. This - * is usually correct, but for the 'debugger' statement it will be the - * instruction after that. + /* We're conceptually between two opcodes; act->pc indicates the next + * instruction to be executed. This is usually the correct pc/line to + * indicate in Status. (For the 'debugger' statement this now reports + * the pc/line after the debugger statement because the debugger opcode + * has already been executed.) */ - pc = (duk_uint_fast32_t) act->pc; + pc = duk_hthread_get_act_curr_pc(thr, act); /* XXX: this should be optimized to be a raw query and avoid valstack * operations if possible. */ - duk_push_hobject(ctx, act->func); + duk_push_tval(ctx, &act->tv_func); line = duk_hobject_pc2line_query(ctx, -1, pc); duk_pop(ctx); return line; @@ -32647,21 +40911,63 @@ DUK_INTERNAL void duk_debug_send_status(duk_hthread *thr) { duk_debug_write_int(thr, 0); } else { act = thr->callstack + thr->callstack_top - 1; - duk_push_hobject(ctx, act->func); + duk_push_tval(ctx, &act->tv_func); duk_get_prop_string(ctx, -1, "fileName"); - duk_safe_to_string(ctx, -1); - duk_debug_write_hstring(thr, duk_require_hstring(ctx, -1)); + duk__debug_write_hstring_safe_top(thr); duk_get_prop_string(ctx, -2, "name"); - duk_safe_to_string(ctx, -1); - duk_debug_write_hstring(thr, duk_require_hstring(ctx, -1)); + duk__debug_write_hstring_safe_top(thr); duk_pop_3(ctx); + /* Report next pc/line to be executed. */ duk_debug_write_uint(thr, (duk_uint32_t) duk_debug_curr_line(thr)); - duk_debug_write_uint(thr, (duk_uint32_t) act->pc); + duk_debug_write_uint(thr, (duk_uint32_t) duk_hthread_get_act_curr_pc(thr, act)); } duk_debug_write_eom(thr); } +#if defined(DUK_USE_DEBUGGER_THROW_NOTIFY) +DUK_INTERNAL void duk_debug_send_throw(duk_hthread *thr, duk_bool_t fatal) { + /* + * NFY EOM + */ + + duk_context *ctx = (duk_context *) thr; + duk_activation *act; + duk_uint32_t pc; + + DUK_ASSERT(thr->valstack_top > thr->valstack); /* At least: ... [err] */ + + duk_debug_write_notify(thr, DUK_DBG_CMD_THROW); + duk_debug_write_int(thr, fatal); + + /* Report thrown value to client coerced to string */ + duk_dup(ctx, -1); + duk__debug_write_hstring_safe_top(thr); + duk_pop(ctx); + + if (duk_is_error(ctx, -1)) { + /* Error instance, use augmented error data directly */ + duk_get_prop_stridx(ctx, -1, DUK_STRIDX_FILE_NAME); + duk__debug_write_hstring_safe_top(thr); + duk_get_prop_stridx(ctx, -2, DUK_STRIDX_LINE_NUMBER); + duk_debug_write_uint(thr, duk_get_uint(ctx, -1)); + } else { + /* For anything other than an Error instance, we calculate the error + * location directly from the current activation. + */ + act = thr->callstack + thr->callstack_top - 1; + duk_push_tval(ctx, &act->tv_func); + duk_get_prop_string(ctx, -1, "fileName"); + duk__debug_write_hstring_safe_top(thr); + pc = duk_hthread_get_act_prev_pc(thr, act); + duk_debug_write_uint(thr, (duk_uint32_t) duk_hobject_pc2line_query(ctx, -2, pc)); + } + duk_pop_2(ctx); /* shared pop */ + + duk_debug_write_eom(thr); +} +#endif /* DUK_USE_DEBUGGER_THROW_NOTIFY */ + /* * Debug message processing */ @@ -32735,7 +41041,7 @@ DUK_LOCAL duk_bool_t duk__debug_skip_dvalue(duk_hthread *thr) { return 0; fail: - DUK__SET_CONN_BROKEN(thr); + DUK__SET_CONN_BROKEN(thr, 1); return 1; /* Pretend like we got EOM */ } @@ -32750,11 +41056,15 @@ DUK_LOCAL void duk__debug_skip_to_eom(duk_hthread *thr) { /* * Process incoming debug requests + * + * Individual request handlers can push temporaries on the value stack and + * rely on duk__debug_process_message() to restore the value stack top + * automatically. */ DUK_LOCAL void duk__debug_handle_basic_info(duk_hthread *thr, duk_heap *heap) { DUK_UNREF(heap); - DUK_D(DUK_DPRINT("debug command version")); + DUK_D(DUK_DPRINT("debug command Version")); duk_debug_write_reply(thr); duk_debug_write_int(thr, DUK_VERSION); @@ -32774,7 +41084,7 @@ DUK_LOCAL void duk__debug_handle_basic_info(duk_hthread *thr, duk_heap *heap) { DUK_LOCAL void duk__debug_handle_trigger_status(duk_hthread *thr, duk_heap *heap) { DUK_UNREF(heap); - DUK_D(DUK_DPRINT("debug command triggerstatus")); + DUK_D(DUK_DPRINT("debug command TriggerStatus")); duk_debug_write_reply(thr); duk_debug_write_eom(thr); @@ -32782,7 +41092,7 @@ DUK_LOCAL void duk__debug_handle_trigger_status(duk_hthread *thr, duk_heap *heap } DUK_LOCAL void duk__debug_handle_pause(duk_hthread *thr, duk_heap *heap) { - DUK_D(DUK_DPRINT("debug command pause")); + DUK_D(DUK_DPRINT("debug command Pause")); DUK_HEAP_SET_PAUSED(heap); duk_debug_write_reply(thr); @@ -32790,7 +41100,7 @@ DUK_LOCAL void duk__debug_handle_pause(duk_hthread *thr, duk_heap *heap) { } DUK_LOCAL void duk__debug_handle_resume(duk_hthread *thr, duk_heap *heap) { - DUK_D(DUK_DPRINT("debug command resume")); + DUK_D(DUK_DPRINT("debug command Resume")); DUK_HEAP_CLEAR_PAUSED(heap); duk_debug_write_reply(thr); @@ -32810,7 +41120,7 @@ DUK_LOCAL void duk__debug_handle_step(duk_hthread *thr, duk_heap *heap, duk_int3 step_type = DUK_STEP_TYPE_OUT; } - DUK_D(DUK_DPRINT("debug command stepinto/stepover/stepout: %d", (int) cmd)); + DUK_D(DUK_DPRINT("debug command StepInto/StepOver/StepOut: %d", (int) cmd)); line = duk_debug_curr_line(thr); if (line > 0) { heap->dbg_paused = 0; @@ -32829,7 +41139,7 @@ DUK_LOCAL void duk__debug_handle_step(duk_hthread *thr, duk_heap *heap, duk_int3 DUK_LOCAL void duk__debug_handle_list_break(duk_hthread *thr, duk_heap *heap) { duk_small_int_t i; - DUK_D(DUK_DPRINT("debug command listbreak")); + DUK_D(DUK_DPRINT("debug command ListBreak")); duk_debug_write_reply(thr); for (i = 0; i < (duk_small_int_t) heap->dbg_breakpoint_count; i++) { duk_debug_write_hstring(thr, heap->dbg_breakpoints[i].filename); @@ -32839,7 +41149,6 @@ DUK_LOCAL void duk__debug_handle_list_break(duk_hthread *thr, duk_heap *heap) { } DUK_LOCAL void duk__debug_handle_add_break(duk_hthread *thr, duk_heap *heap) { - duk_context *ctx = (duk_context *) thr; duk_hstring *filename; duk_uint32_t linenumber; duk_small_int_t idx; @@ -32848,7 +41157,7 @@ DUK_LOCAL void duk__debug_handle_add_break(duk_hthread *thr, duk_heap *heap) { filename = duk_debug_read_hstring(thr); linenumber = (duk_uint32_t) duk_debug_read_int(thr); - DUK_D(DUK_DPRINT("debug command addbreak: %!O:%ld", (duk_hobject *) filename, (long) linenumber)); + DUK_D(DUK_DPRINT("debug command AddBreak: %!O:%ld", (duk_hobject *) filename, (long) linenumber)); idx = duk_debug_add_breakpoint(thr, filename, linenumber); if (idx >= 0) { duk_debug_write_reply(thr); @@ -32857,7 +41166,6 @@ DUK_LOCAL void duk__debug_handle_add_break(duk_hthread *thr, duk_heap *heap) { } else { duk_debug_write_error_eom(thr, DUK_DBG_ERR_TOOMANY, "no space for breakpoint"); } - duk_pop(ctx); } DUK_LOCAL void duk__debug_handle_del_break(duk_hthread *thr, duk_heap *heap) { @@ -32865,7 +41173,7 @@ DUK_LOCAL void duk__debug_handle_del_break(duk_hthread *thr, duk_heap *heap) { DUK_UNREF(heap); - DUK_D(DUK_DPRINT("debug command delbreak")); + DUK_D(DUK_DPRINT("debug command DelBreak")); idx = (duk_small_uint_t) duk_debug_read_int(thr); if (duk_debug_remove_breakpoint(thr, idx)) { duk_debug_write_reply(thr); @@ -32879,16 +41187,27 @@ DUK_LOCAL void duk__debug_handle_get_var(duk_hthread *thr, duk_heap *heap) { duk_context *ctx = (duk_context *) thr; duk_hstring *str; duk_bool_t rc; + duk_int32_t level; DUK_UNREF(heap); - DUK_D(DUK_DPRINT("debug command getvar")); + DUK_D(DUK_DPRINT("debug command GetVar")); str = duk_debug_read_hstring(thr); /* push to stack */ DUK_ASSERT(str != NULL); + if (duk_debug_peek_byte(thr) != DUK_DBG_MARKER_EOM) { + level = duk_debug_read_int(thr); /* optional callstack level */ + if (level >= 0 || -level > (duk_int32_t) thr->callstack_top) { + DUK_D(DUK_DPRINT("invalid callstack level for GetVar")); + duk_debug_write_error_eom(thr, DUK_DBG_ERR_NOTFOUND, "invalid callstack level"); + return; + } + } else { + level = -1; + } if (thr->callstack_top > 0) { rc = duk_js_getvar_activation(thr, - thr->callstack + thr->callstack_top - 1, + thr->callstack + thr->callstack_top + level, str, 0); } else { @@ -32903,13 +41222,12 @@ DUK_LOCAL void duk__debug_handle_get_var(duk_hthread *thr, duk_heap *heap) { duk_debug_write_reply(thr); if (rc) { duk_debug_write_int(thr, 1); - duk_debug_write_tval(thr, duk_require_tval(ctx, -2)); - duk_pop_2(ctx); + DUK_ASSERT(duk_get_tval(ctx, -2) != NULL); + duk_debug_write_tval(thr, duk_get_tval(ctx, -2)); } else { duk_debug_write_int(thr, 0); duk_debug_write_unused(thr); } - duk_pop(ctx); duk_debug_write_eom(thr); } @@ -32917,25 +41235,36 @@ DUK_LOCAL void duk__debug_handle_put_var(duk_hthread *thr, duk_heap *heap) { duk_context *ctx = (duk_context *) thr; duk_hstring *str; duk_tval *tv; + duk_int32_t level; DUK_UNREF(heap); - DUK_D(DUK_DPRINT("debug command putvar")); + DUK_D(DUK_DPRINT("debug command PutVar")); str = duk_debug_read_hstring(thr); /* push to stack */ DUK_ASSERT(str != NULL); duk_debug_read_tval(thr); /* push to stack */ - tv = duk_require_tval(ctx, -1); + tv = duk_get_tval(ctx, -1); + DUK_ASSERT(tv != NULL); + if (duk_debug_peek_byte(thr) != DUK_DBG_MARKER_EOM) { + level = duk_debug_read_int(thr); /* optional callstack level */ + if (level >= 0 || -level > (duk_int32_t) thr->callstack_top) { + DUK_D(DUK_DPRINT("invalid callstack level for PutVar")); + duk_debug_write_error_eom(thr, DUK_DBG_ERR_NOTFOUND, "invalid callstack level"); + return; + } + } else { + level = -1; + } if (thr->callstack_top > 0) { duk_js_putvar_activation(thr, - thr->callstack + thr->callstack_top - 1, + thr->callstack + thr->callstack_top + level, str, tv, 0); } else { DUK_D(DUK_DPRINT("callstack empty, no activation -> ignore putvar")); } - duk_pop_2(ctx); /* XXX: Current putvar implementation doesn't have a success flag, * add one and send to debug client? @@ -32948,6 +41277,7 @@ DUK_LOCAL void duk__debug_handle_get_call_stack(duk_hthread *thr, duk_heap *heap duk_context *ctx = (duk_context *) thr; duk_hthread *curr_thr = thr; duk_activation *curr_act; + duk_uint_fast32_t pc; duk_uint_fast32_t line; duk_size_t i; @@ -32960,19 +41290,31 @@ DUK_LOCAL void duk__debug_handle_get_call_stack(duk_hthread *thr, duk_heap *heap i--; curr_act = curr_thr->callstack + i; - /* XXX: optimize to use direct reads, - * i.e. avoid value stack operations. + /* PC/line semantics here are: + * - For callstack top we're conceptually between two + * opcodes and current PC indicates next line to + * execute, so report that (matches Status). + * - For other activations we're conceptually still + * executing the instruction at PC-1, so report that + * (matches error stacktrace behavior). + * - See: https://github.com/svaarala/duktape/issues/281 + */ + + /* XXX: optimize to use direct reads, i.e. avoid + * value stack operations. */ duk_push_tval(ctx, &curr_act->tv_func); duk_get_prop_stridx(ctx, -1, DUK_STRIDX_FILE_NAME); - duk_safe_to_string(ctx, -1); - duk_debug_write_hstring(thr, duk_get_hstring(ctx, -1)); + duk__debug_write_hstring_safe_top(thr); duk_get_prop_stridx(ctx, -2, DUK_STRIDX_NAME); - duk_safe_to_string(ctx, -1); - duk_debug_write_hstring(thr, duk_get_hstring(ctx, -1)); - line = duk_hobject_pc2line_query(ctx, -3, curr_act->pc); + duk__debug_write_hstring_safe_top(thr); + pc = duk_hthread_get_act_curr_pc(thr, curr_act); + if (i != curr_thr->callstack_top - 1 && pc > 0) { + pc--; + } + line = duk_hobject_pc2line_query(ctx, -3, pc); duk_debug_write_uint(thr, (duk_uint32_t) line); - duk_debug_write_uint(thr, (duk_uint32_t) curr_act->pc); + duk_debug_write_uint(thr, (duk_uint32_t) pc); duk_pop_3(ctx); } curr_thr = curr_thr->resumer; @@ -32983,15 +41325,28 @@ DUK_LOCAL void duk__debug_handle_get_call_stack(duk_hthread *thr, duk_heap *heap DUK_LOCAL void duk__debug_handle_get_locals(duk_hthread *thr, duk_heap *heap) { duk_context *ctx = (duk_context *) thr; duk_activation *curr_act; + duk_int32_t level; duk_hstring *varname; DUK_UNREF(heap); - duk_debug_write_reply(thr); - if (thr->callstack_top == 0) { - goto callstack_empty; + if (duk_debug_peek_byte(thr) != DUK_DBG_MARKER_EOM) { + level = duk_debug_read_int(thr); /* optional callstack level */ + if (level >= 0 || -level > (duk_int32_t) thr->callstack_top) { + DUK_D(DUK_DPRINT("invalid callstack level for GetLocals")); + duk_debug_write_error_eom(thr, DUK_DBG_ERR_NOTFOUND, "invalid callstack level"); + return; + } + duk_debug_write_reply(thr); + } else { + duk_debug_write_reply(thr); + if (thr->callstack_top == 0) { + goto callstack_empty; + } + level = -1; } - curr_act = thr->callstack + thr->callstack_top - 1; + + curr_act = thr->callstack + thr->callstack_top + level; /* XXX: several nice-to-have improvements here: * - Use direct reads avoiding value stack operations @@ -33013,11 +41368,9 @@ DUK_LOCAL void duk__debug_handle_get_locals(duk_hthread *thr, duk_heap *heap) { duk_debug_write_tval(thr, duk_get_tval(ctx, -2)); duk_pop_3(ctx); /* -> [ ... func varmap enum ] */ } - duk_pop(ctx); } else { DUK_D(DUK_DPRINT("varmap is not an object in GetLocals, ignore")); } - duk_pop_2(ctx); callstack_empty: duk_debug_write_eom(thr); @@ -33025,51 +41378,62 @@ DUK_LOCAL void duk__debug_handle_get_locals(duk_hthread *thr, duk_heap *heap) { DUK_LOCAL void duk__debug_handle_eval(duk_hthread *thr, duk_heap *heap) { duk_context *ctx = (duk_context *) thr; - duk_small_uint_t call_flags; duk_int_t call_ret; duk_small_int_t eval_err; -#if defined(DUK_USE_ASSERTIONS) - duk_idx_t entry_top; -#endif + duk_int32_t level; DUK_UNREF(heap); - DUK_D(DUK_DPRINT("debug command eval")); + DUK_D(DUK_DPRINT("debug command Eval")); - /* The eval code must be executed within the current (topmost) - * activation. For now, use global object eval() function, with - * the eval considered a 'direct call to eval'. + /* The eval code is executed within the lexical environment of a specified + * activation. For now, use global object eval() function, with the eval + * considered a 'direct call to eval'. + * + * Callstack level for debug commands only affects scope -- the callstack + * as seen by, e.g. Duktape.act() will be the same regardless. */ -#if defined(DUK_USE_ASSERTIONS) - entry_top = duk_get_top(ctx); -#endif - - duk_push_c_function(ctx, duk_bi_global_object_eval, 1 /*nargs*/); + /* nargs == 2 so we can pass a callstack level to eval(). */ + duk_push_c_function(ctx, duk_bi_global_object_eval, 2 /*nargs*/); duk_push_undefined(ctx); /* 'this' binding shouldn't matter here */ + (void) duk_debug_read_hstring(thr); + if (duk_debug_peek_byte(thr) != DUK_DBG_MARKER_EOM) { + level = duk_debug_read_int(thr); /* optional callstack level */ + if (level >= 0 || -level > (duk_int32_t) thr->callstack_top) { + DUK_D(DUK_DPRINT("invalid callstack level for Eval")); + duk_debug_write_error_eom(thr, DUK_DBG_ERR_NOTFOUND, "invalid callstack level"); + return; + } + } + else { + level = -1; + } + DUK_ASSERT(level < 0 && -level <= (duk_int32_t) thr->callstack_top); + duk_push_int(ctx, level - 1); /* compensate for eval() call */ - /* [ ... eval "eval" eval_input ] */ + /* [ ... eval "eval" eval_input level ] */ - call_flags = DUK_CALL_FLAG_PROTECTED; - if (thr->callstack_top >= 1) { + call_flags = 0; + if (thr->callstack_top >= (duk_size_t) -level) { duk_activation *act; duk_hobject *fun; - act = thr->callstack + thr->callstack_top - 1; + act = thr->callstack + thr->callstack_top + level; fun = DUK_ACT_GET_FUNC(act); - if (fun && DUK_HOBJECT_IS_COMPILEDFUNCTION(fun)) { + if (fun != NULL && DUK_HOBJECT_IS_COMPILEDFUNCTION(fun)) { /* Direct eval requires that there's a current * activation and it is an Ecmascript function. * When Eval is executed from e.g. cooperate API - * call we'll need to an indirect eval instead. + * call we'll need to do an indirect eval instead. */ call_flags |= DUK_CALL_FLAG_DIRECT_EVAL; } } - call_ret = duk_handle_call(thr, 1 /*num_stack_args*/, call_flags); + call_ret = duk_handle_call_protected(thr, 2 /*num_stack_args*/, call_flags); if (call_ret == DUK_EXEC_SUCCESS) { eval_err = 0; @@ -33087,22 +41451,20 @@ DUK_LOCAL void duk__debug_handle_eval(duk_hthread *thr, duk_heap *heap) { duk_debug_write_reply(thr); duk_debug_write_int(thr, (duk_int32_t) eval_err); - duk_debug_write_tval(thr, duk_require_tval(ctx, -1)); + DUK_ASSERT(duk_get_tval(ctx, -1) != NULL); + duk_debug_write_tval(thr, duk_get_tval(ctx, -1)); duk_debug_write_eom(thr); - duk_pop(ctx); - - DUK_ASSERT(duk_get_top(ctx) == entry_top); } DUK_LOCAL void duk__debug_handle_detach(duk_hthread *thr, duk_heap *heap) { DUK_UNREF(heap); - DUK_D(DUK_DPRINT("debug command detach")); + DUK_D(DUK_DPRINT("debug command Detach")); duk_debug_write_reply(thr); duk_debug_write_eom(thr); DUK_D(DUK_DPRINT("debug connection detached, mark broken")); - DUK__SET_CONN_BROKEN(thr); + DUK__SET_CONN_BROKEN(thr, 0); /* not an error */ } #if defined(DUK_USE_DEBUGGER_DUMPHEAP) @@ -33172,11 +41534,6 @@ DUK_LOCAL void duk__debug_dump_heaphdr(duk_hthread *thr, duk_heap *heap, duk_hea duk_hbuffer *h = (duk_hbuffer *) hdr; duk_debug_write_uint(thr, (duk_uint32_t) DUK_HBUFFER_GET_SIZE(h)); - if (DUK_HBUFFER_HAS_DYNAMIC(h)) { - duk_debug_write_uint(thr, (duk_uint32_t) DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE((duk_hbuffer_dynamic *) h)); - } else { - duk_debug_write_uint(thr, (duk_uint32_t) DUK_HBUFFER_GET_SIZE(h)); - } duk_debug_write_buffer(thr, (const char *) DUK_HBUFFER_GET_DATA_PTR(heap, h), (duk_size_t) DUK_HBUFFER_GET_SIZE(h)); break; } @@ -33262,7 +41619,7 @@ DUK_LOCAL void duk__debug_dump_strtab_probe(duk_hthread *thr, duk_heap *heap) { #endif /* DUK_USE_STRTAB_PROBE */ DUK_LOCAL void duk__debug_handle_dump_heap(duk_hthread *thr, duk_heap *heap) { - DUK_D(DUK_DPRINT("debug command dumpheap")); + DUK_D(DUK_DPRINT("debug command DumpHeap")); duk_debug_write_reply(thr); duk__debug_dump_heap_allocated(thr, heap); @@ -33285,7 +41642,7 @@ DUK_LOCAL void duk__debug_handle_get_bytecode(duk_hthread *thr, duk_heap *heap) DUK_UNREF(heap); - DUK_D(DUK_DPRINT("debug command getbytecode")); + DUK_D(DUK_DPRINT("debug command GetBytecode")); duk_debug_write_reply(thr); if (thr->callstack_top == 0) { @@ -33299,9 +41656,9 @@ DUK_LOCAL void duk__debug_handle_get_bytecode(duk_hthread *thr, duk_heap *heap) } DUK_ASSERT(fun == NULL || DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) fun)); - if (fun) { + if (fun != NULL) { n = DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT(heap, fun); - duk_debug_write_int(thr, (int) n); + duk_debug_write_int(thr, (duk_int32_t) n); tv = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(heap, fun); for (i = 0; i < n; i++) { duk_debug_write_tval(thr, tv); @@ -33309,7 +41666,7 @@ DUK_LOCAL void duk__debug_handle_get_bytecode(duk_hthread *thr, duk_heap *heap) } n = DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(heap, fun); - duk_debug_write_int(thr, (int) n); + duk_debug_write_int(thr, (duk_int32_t) n); fn = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(heap, fun); for (i = 0; i < n; i++) { duk_debug_write_hobject(thr, *fn); @@ -33327,17 +41684,24 @@ DUK_LOCAL void duk__debug_handle_get_bytecode(duk_hthread *thr, duk_heap *heap) duk_debug_write_eom(thr); } +/* Process one debug message. Automatically restore value stack top to its + * entry value, so that individual message handlers don't need exact value + * stack handling which is convenient. + */ DUK_LOCAL void duk__debug_process_message(duk_hthread *thr) { duk_context *ctx = (duk_context *) thr; duk_heap *heap; duk_uint8_t x; duk_int32_t cmd; + duk_idx_t entry_top; DUK_ASSERT(thr != NULL); heap = thr->heap; DUK_ASSERT(heap != NULL); DUK_UNREF(ctx); + entry_top = duk_get_top(ctx); + x = duk_debug_read_byte(thr); switch (x) { case DUK_DBG_MARKER_REQUEST: { @@ -33398,6 +41762,10 @@ DUK_LOCAL void duk__debug_process_message(duk_hthread *thr) { break; } case DUK_DBG_CMD_DETACH: { + /* The actual detached_cb call is postponed to message loop so + * we don't need any special precautions here (just skip to EOM + * on the already closed connection). + */ duk__debug_handle_detach(thr, heap); break; } @@ -33436,14 +41804,87 @@ DUK_LOCAL void duk__debug_process_message(duk_hthread *thr) { } } /* switch initial byte */ + DUK_ASSERT(duk_get_top(ctx) >= entry_top); + duk_set_top(ctx, entry_top); duk__debug_skip_to_eom(thr); return; fail: - DUK__SET_CONN_BROKEN(thr); + DUK_ASSERT(duk_get_top(ctx) >= entry_top); + duk_set_top(ctx, entry_top); + DUK__SET_CONN_BROKEN(thr, 1); return; } +/* Halt execution and enter a debugger message loop until execution is resumed + * by the client. PC for the current activation may be temporarily decremented + * so that the "current" instruction will be shown by the client. This helper + * is callable from anywhere, also outside bytecode executor. + */ + +DUK_INTERNAL void duk_debug_halt_execution(duk_hthread *thr, duk_bool_t use_prev_pc) { + duk_activation *act; + duk_hcompiledfunction *fun; + duk_instr_t *old_pc = NULL; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT(DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)); + DUK_ASSERT(thr->heap->dbg_processing == 0); + + DUK_HEAP_SET_PAUSED(thr->heap); + + act = duk_hthread_get_current_activation(thr); + + /* NOTE: act may be NULL if an error is thrown outside of any activation, + * which may happen in the case of, e.g. syntax errors. + */ + + /* Decrement PC if that was requested, this requires a PC sync. */ + if (act != NULL) { + duk_hthread_sync_currpc(thr); + old_pc = act->curr_pc; + fun = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act); + + /* Short circuit if is safe: if act->curr_pc != NULL, 'fun' is + * guaranteed to be a non-NULL Ecmascript function. + */ + DUK_ASSERT(act->curr_pc == NULL || + (fun != NULL && DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) fun))); + if (use_prev_pc && + act->curr_pc != NULL && + act->curr_pc > DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, fun)) { + act->curr_pc--; + } + } + + /* Process debug messages until we are no longer paused. */ + + /* NOTE: This is a bit fragile. It's important to ensure that neither + * duk_debug_send_status() or duk_debug_process_messages() throws an + * error or act->curr_pc will never be reset. + */ + + thr->heap->dbg_processing = 1; + duk_debug_send_status(thr); + while (thr->heap->dbg_paused) { + DUK_ASSERT(thr->heap->dbg_processing); + duk_debug_process_messages(thr, 0 /*no_block*/); + } + thr->heap->dbg_processing = 0; + + /* XXX: Decrementing and restoring act->curr_pc works now, but if the + * debugger message loop gains the ability to adjust the current PC + * (e.g. a forced jump) restoring the PC here will break. Another + * approach would be to use a state flag for the "decrement 1 from + * topmost activation's PC" and take it into account whenever dealing + * with PC values. + */ + if (act != NULL) { + act->curr_pc = old_pc; /* restore PC */ + } +} + DUK_INTERNAL duk_bool_t duk_debug_process_messages(duk_hthread *thr, duk_bool_t no_block) { duk_context *ctx = (duk_context *) thr; #if defined(DUK_USE_ASSERTIONS) @@ -33453,6 +41894,8 @@ DUK_INTERNAL duk_bool_t duk_debug_process_messages(duk_hthread *thr, duk_bool_t DUK_ASSERT(thr != NULL); DUK_UNREF(ctx); + DUK_ASSERT(thr->heap != NULL); + DUK_ASSERT(DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)); #if defined(DUK_USE_ASSERTIONS) entry_top = duk_get_top(ctx); #endif @@ -33479,6 +41922,17 @@ DUK_INTERNAL duk_bool_t duk_debug_process_messages(duk_hthread *thr, duk_bool_t } duk__debug_process_message(thr); + + if (thr->heap->dbg_read_cb == NULL) { + /* Became detached during message handling (perhaps because + * of an error or by an explicit Detach). Call detached + * callback here, between messages, to avoid confusing the + * broken connection and a possible replacement (which may + * be provided by an instant reattach inside the detached + * callback). + */ + duk__debug_do_detach2(thr->heap); + } if (thr->heap->dbg_state_dirty) { /* Executed something that may have affected status, * resend. @@ -33550,6 +42004,7 @@ DUK_INTERNAL duk_bool_t duk_debug_remove_breakpoint(duk_hthread *thr, duk_small_ DUK_ASSERT(thr != NULL); heap = thr->heap; DUK_ASSERT(heap != NULL); + DUK_ASSERT(DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)); DUK_ASSERT_DISABLE(breakpoint_index >= 0); /* unsigned */ if (breakpoint_index >= heap->dbg_breakpoint_count) { @@ -33564,13 +42019,14 @@ DUK_INTERNAL duk_bool_t duk_debug_remove_breakpoint(duk_hthread *thr, duk_small_ move_size = sizeof(duk_breakpoint) * (heap->dbg_breakpoint_count - breakpoint_index - 1); if (move_size > 0) { DUK_MEMMOVE((void *) b, - (void *) (b + 1), - move_size); + (const void *) (b + 1), + (size_t) move_size); } heap->dbg_breakpoint_count--; heap->dbg_breakpoints_active[0] = (duk_breakpoint *) NULL; DUK_HSTRING_DECREF(thr, h); /* side effects */ + DUK_UNREF(h); /* w/o refcounting */ /* Breakpoint entries above the used area are left as garbage. */ @@ -33635,7 +42091,7 @@ DUK_INTERNAL duk_bool_t duk_debug_remove_breakpoint(duk_hthread *thr, duk_small_ * The user error handler is stored in 'Duktape.errCreate' or * 'Duktape.errThrow' depending on whether we're augmenting the error at * creation or throw time. There are several alternatives to this approach, - * see doc/error-objects.txt for discussion. + * see doc/error-objects.rst for discussion. * * Note: since further longjmp()s may occur while calling the error handler * (for many reasons, e.g. a labeled 'break' inside the handler), the @@ -33723,12 +42179,11 @@ DUK_LOCAL void duk__err_augment_user(duk_hthread *thr, duk_small_uint_t stridx_c DUK_ASSERT(!DUK_HEAP_HAS_ERRHANDLER_RUNNING(thr->heap)); /* since no recursive error handler calls */ DUK_HEAP_SET_ERRHANDLER_RUNNING(thr->heap); - call_flags = DUK_CALL_FLAG_PROTECTED | - DUK_CALL_FLAG_IGNORE_RECLIMIT; /* protected, ignore reclimit, not constructor */ + call_flags = DUK_CALL_FLAG_IGNORE_RECLIMIT; /* ignore reclimit, not constructor */ - rc = duk_handle_call(thr, - 1, /* num args */ - call_flags); /* call_flags */ + rc = duk_handle_call_protected(thr, + 1, /* num args */ + call_flags); /* call_flags */ DUK_UNREF(rc); /* no need to check now: both success and error are OK */ DUK_ASSERT(DUK_HEAP_HAS_ERRHANDLER_RUNNING(thr->heap)); @@ -33736,13 +42191,13 @@ DUK_LOCAL void duk__err_augment_user(duk_hthread *thr, duk_small_uint_t stridx_c /* [ ... errval ] */ } -#endif /* DUK_USE_ERRTHROW || DUK_USE_ERRHANDLE */ +#endif /* DUK_USE_ERRTHROW || DUK_USE_ERRCREATE */ /* - * Add tracedata to an error on the stack top. + * Add ._Tracedata to an error on the stack top. */ -#ifdef DUK_USE_TRACEBACKS +#if defined(DUK_USE_TRACEBACKS) DUK_LOCAL void duk__add_traceback(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_bool_t noblame_fileline) { duk_context *ctx = (duk_context *) thr; duk_small_uint_t depth; @@ -33761,7 +42216,7 @@ DUK_LOCAL void duk__add_traceback(duk_hthread *thr, duk_hthread *thr_callstack, * and cheap to create. It may change arbitrarily from version to version. * It should be decoded/accessed through version specific accessors only. * - * See doc/error-objects.txt. + * See doc/error-objects.rst. */ DUK_DDD(DUK_DDDPRINT("adding traceback to object: %!T", @@ -33770,8 +42225,8 @@ DUK_LOCAL void duk__add_traceback(duk_hthread *thr, duk_hthread *thr_callstack, duk_push_array(ctx); /* XXX: specify array size, as we know it */ arr_idx = 0; - /* compiler SyntaxErrors (and other errors) come first; blame the source - * code file/line primarily. + /* Compiler SyntaxErrors (and other errors) come first, and are + * blamed by default (not flagged "noblame"). */ if (thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL) { duk_push_hstring(ctx, thr->compile_ctx->h_filename); @@ -33783,7 +42238,7 @@ DUK_LOCAL void duk__add_traceback(duk_hthread *thr, duk_hthread *thr_callstack, arr_idx++; } - /* filename/line from C macros (__FILE__, __LINE__) are added as an + /* Filename/line from C macros (__FILE__, __LINE__) are added as an * entry with a special format: (string, number). The number contains * the line and flags. */ @@ -33796,7 +42251,9 @@ DUK_LOCAL void duk__add_traceback(duk_hthread *thr, duk_hthread *thr_callstack, /* XXX: using duk_put_prop_index() would cause obscure error cases when Array.prototype * has write-protected array index named properties. This was seen as DoubleErrors * in e.g. some test262 test cases. Using duk_xdef_prop_index() is better but heavier. - * The best fix is to fill in the tracedata directly into the array part. + * The best fix is to fill in the tracedata directly into the array part. There are + * no side effect concerns if the array part is allocated directly and only INCREFs + * happen after that. */ /* [ ... error arr ] */ @@ -33848,10 +42305,7 @@ DUK_LOCAL void duk__add_traceback(duk_hthread *thr, duk_hthread *thr_callstack, * PC points to next instruction, find offending PC. Note that * PC == 0 for native code. */ - pc = thr_callstack->callstack[i].pc; - if (pc > 0) { - pc--; - } + pc = duk_hthread_get_act_prev_pc(thr_callstack, thr_callstack->callstack + i); DUK_ASSERT_DISABLE(pc >= 0); /* unsigned */ DUK_ASSERT((duk_double_t) pc < DUK_DOUBLE_2TO32); /* assume PC is at most 32 bits and non-negative */ d = ((duk_double_t) thr_callstack->callstack[i].flags) * DUK_DOUBLE_2TO32 + (duk_double_t) pc; @@ -33870,34 +42324,22 @@ DUK_LOCAL void duk__add_traceback(duk_hthread *thr, duk_hthread *thr_callstack, } #endif /* DUK_USE_TRACEBACKS */ -#if defined(DUK_USE_AUGMENT_ERROR_CREATE) -DUK_LOCAL void duk__err_augment_builtin_throw(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_small_int_t noblame_fileline, duk_hobject *obj) { - duk_context *ctx = (duk_context *) thr; -#ifdef DUK_USE_ASSERTIONS +/* + * Add .fileName and .lineNumber to an error on the stack top. + */ + +#if !defined(DUK_USE_TRACEBACKS) +DUK_LOCAL void duk__add_fileline(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_bool_t noblame_fileline) { + duk_context *ctx; +#if defined(DUK_USE_ASSERTIONS) duk_int_t entry_top; #endif -#ifdef DUK_USE_ASSERTIONS + ctx = (duk_context *) thr; +#if defined(DUK_USE_ASSERTIONS) entry_top = duk_get_top(ctx); #endif - DUK_ASSERT(obj != NULL); - DUK_UNREF(obj); /* unreferenced w/o tracebacks */ - DUK_UNREF(ctx); /* unreferenced w/ tracebacks */ - -#ifdef DUK_USE_TRACEBACKS - /* - * If tracebacks are enabled, the '_Tracedata' property is the only - * thing we need: 'fileName' and 'lineNumber' are virtual properties - * which use '_Tracedata'. - */ - - if (duk_hobject_hasprop_raw(thr, obj, DUK_HTHREAD_STRING_INT_TRACEDATA(thr))) { - DUK_DDD(DUK_DDDPRINT("error value already has a '_Tracedata' property, not modifying it")); - } else { - duk__add_traceback(thr, thr_callstack, c_filename, c_line, noblame_fileline); - } -#else /* * If tracebacks are disabled, 'fileName' and 'lineNumber' are added * as plain own properties. Since Error.prototype has accessors of @@ -33907,36 +42349,49 @@ DUK_LOCAL void duk__err_augment_builtin_throw(duk_hthread *thr, duk_hthread *thr */ if (thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL) { - /* Compiler SyntaxError (or other error) gets the primary blame. */ - duk_push_hstring(ctx, thr->compile_ctx->h_filename); - duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE); - duk_push_uint(ctx, (duk_uint_t) thr->compile_ctx->curr_token.start_line); - duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LINE_NUMBER, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE); - } else if (c_filename && !noblame_fileline) { - /* XXX: file/line is disabled in minimal builds, so disable this too - * when appropriate. + /* Compiler SyntaxError (or other error) gets the primary blame. + * Currently no flag to prevent blaming. + */ + duk_push_uint(ctx, (duk_uint_t) thr->compile_ctx->curr_token.start_line); + duk_push_hstring(ctx, thr->compile_ctx->h_filename); + } else if (c_filename && !noblame_fileline) { + /* C call site gets blamed next, unless flagged not to do so. + * XXX: file/line is disabled in minimal builds, so disable this + * too when appropriate. */ - duk_push_string(ctx, c_filename); - duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE); duk_push_int(ctx, c_line); - duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LINE_NUMBER, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE); - } else if (thr_callstack->callstack_top > 0) { - duk_activation *act; - duk_hobject *func; + duk_push_string(ctx, c_filename); + } else { + /* Finally, blame the innermost callstack entry which has a + * .fileName property. + */ + duk_small_uint_t depth; + duk_int_t i, i_min; + duk_uint32_t ecma_line; - act = thr_callstack->callstack + thr_callstack->callstack_top - 1; - DUK_ASSERT(act >= thr_callstack->callstack && act < thr_callstack->callstack + thr_callstack->callstack_size); - func = DUK_ACT_GET_FUNC(act); - if (func) { + depth = DUK_USE_TRACEBACK_DEPTH; + i_min = (thr_callstack->callstack_top > (duk_size_t) depth ? (duk_int_t) (thr_callstack->callstack_top - depth) : 0); + DUK_ASSERT(i_min >= 0); + + DUK_ASSERT(thr_callstack->callstack_top <= DUK_INT_MAX); /* callstack limits */ + for (i = (duk_int_t) (thr_callstack->callstack_top - 1); i >= i_min; i--) { + duk_activation *act; + duk_hobject *func; duk_uint32_t pc; - /* PC points to next instruction, find offending PC. Note that + act = thr_callstack->callstack + i; + DUK_ASSERT(act >= thr_callstack->callstack && act < thr_callstack->callstack + thr_callstack->callstack_size); + + func = DUK_ACT_GET_FUNC(act); + if (func == NULL) { + /* Lightfunc, not blamed now. */ + continue; + } + + /* PC points to next instruction, find offending PC, * PC == 0 for native code. */ - pc = act->pc; - if (pc > 0) { - pc--; - } + pc = duk_hthread_get_act_prev_pc(thr, act); /* thr argument only used for thr->heap, so specific thread doesn't matter */ DUK_ASSERT_DISABLE(pc >= 0); /* unsigned */ DUK_ASSERT((duk_double_t) pc < DUK_DOUBLE_2TO32); /* assume PC is at most 32 bits and non-negative */ act = NULL; /* invalidated by pushes, so get out of the way */ @@ -33946,31 +42401,126 @@ DUK_LOCAL void duk__err_augment_builtin_throw(duk_hthread *thr, duk_hthread *thr /* [ ... error func ] */ duk_get_prop_stridx(ctx, -1, DUK_STRIDX_FILE_NAME); - duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE); + if (!duk_is_string(ctx, -1)) { + duk_pop_2(ctx); + continue; + } + /* [ ... error func fileName ] */ + + ecma_line = 0; #if defined(DUK_USE_PC2LINE) if (DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) { - duk_uint32_t ecma_line; -#if 0 - duk_push_u32(ctx, pc); - duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_PC, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAGS_NO_OVERWRITE); -#endif - ecma_line = duk_hobject_pc2line_query(ctx, -1, (duk_uint_fast32_t) pc); - if (ecma_line > 0) { - duk_push_u32(ctx, (duk_uint32_t) ecma_line); /* -> [ ... error func line ] */ - duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_LINE_NUMBER, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE); - } + ecma_line = duk_hobject_pc2line_query(ctx, -2, (duk_uint_fast32_t) pc); } else { /* Native function, no relevant lineNumber. */ } #endif /* DUK_USE_PC2LINE */ + duk_push_u32(ctx, ecma_line); - duk_pop(ctx); + /* [ ... error func fileName lineNumber ] */ + + duk_replace(ctx, -3); + + /* [ ... error lineNumber fileName ] */ + goto define_props; } - } -#endif /* DUK_USE_TRACEBACKS */ -#ifdef DUK_USE_ASSERTIONS + /* No activation matches, use undefined for both .fileName and + * .lineNumber (matches what we do with a _Tracedata based + * no-match lookup. + */ + duk_push_undefined(ctx); + duk_push_undefined(ctx); + } + + define_props: + /* [ ... error lineNumber fileName ] */ +#if defined(DUK_USE_ASSERTIONS) + DUK_ASSERT(duk_get_top(ctx) == entry_top + 2); +#endif + duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE); + duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LINE_NUMBER, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE); +} +#endif /* !DUK_USE_TRACEBACKS */ + +/* + * Add line number to a compiler error. + */ + +DUK_LOCAL void duk__add_compiler_error_line(duk_hthread *thr) { + duk_context *ctx; + + /* Append a "(line NNN)" to the "message" property of any error + * thrown during compilation. Usually compilation errors are + * SyntaxErrors but they can also be out-of-memory errors and + * the like. + */ + + /* [ ... error ] */ + + ctx = (duk_context *) thr; + DUK_ASSERT(duk_is_object(ctx, -1)); + + if (!(thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL)) { + return; + } + + DUK_DDD(DUK_DDDPRINT("compile error, before adding line info: %!T", + (duk_tval *) duk_get_tval(ctx, -1))); + + if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_MESSAGE)) { + duk_push_sprintf(ctx, " (line %ld)", (long) thr->compile_ctx->curr_token.start_line); + duk_concat(ctx, 2); + duk_put_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE); + } else { + duk_pop(ctx); + } + + DUK_DDD(DUK_DDDPRINT("compile error, after adding line info: %!T", + (duk_tval *) duk_get_tval(ctx, -1))); +} + +/* + * Augment an error being created using Duktape specific properties + * like _Tracedata or .fileName/.lineNumber. + */ + +#if defined(DUK_USE_AUGMENT_ERROR_CREATE) +DUK_LOCAL void duk__err_augment_builtin_create(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_small_int_t noblame_fileline, duk_hobject *obj) { + duk_context *ctx = (duk_context *) thr; +#if defined(DUK_USE_ASSERTIONS) + duk_int_t entry_top; +#endif + +#if defined(DUK_USE_ASSERTIONS) + entry_top = duk_get_top(ctx); +#endif + DUK_ASSERT(obj != NULL); + + DUK_UNREF(obj); /* unreferenced w/o tracebacks */ + DUK_UNREF(ctx); /* unreferenced w/o asserts */ + + duk__add_compiler_error_line(thr); + +#if defined(DUK_USE_TRACEBACKS) + /* If tracebacks are enabled, the '_Tracedata' property is the only + * thing we need: 'fileName' and 'lineNumber' are virtual properties + * which use '_Tracedata'. + */ + if (duk_hobject_hasprop_raw(thr, obj, DUK_HTHREAD_STRING_INT_TRACEDATA(thr))) { + DUK_DDD(DUK_DDDPRINT("error value already has a '_Tracedata' property, not modifying it")); + } else { + duk__add_traceback(thr, thr_callstack, c_filename, c_line, noblame_fileline); + } +#else + /* Without tracebacks the concrete .fileName and .lineNumber need + * to be added directly. + */ + duk__add_fileline(thr, thr_callstack, c_filename, c_line, noblame_fileline); +#endif + +#if defined(DUK_USE_ASSERTIONS) DUK_ASSERT(duk_get_top(ctx) == entry_top); #endif } @@ -34031,7 +42581,7 @@ DUK_INTERNAL void duk_err_augment_error_create(duk_hthread *thr, duk_hthread *th } if (DUK_HOBJECT_HAS_EXTENSIBLE(obj)) { DUK_DDD(DUK_DDDPRINT("error meets criteria, built-in augment")); - duk__err_augment_builtin_throw(thr, thr_callstack, c_filename, c_line, noblame_fileline, obj); + duk__err_augment_builtin_create(thr, thr_callstack, c_filename, c_line, noblame_fileline, obj); } else { DUK_DDD(DUK_DDDPRINT("error does not meet criteria, no built-in augment")); } @@ -34068,6 +42618,12 @@ DUK_INTERNAL void duk_err_augment_error_throw(duk_hthread *thr) { DUK_INTERNAL void duk_err_longjmp(duk_hthread *thr) { DUK_ASSERT(thr != NULL); +#if defined(DUK_USE_CPP_EXCEPTIONS) + /* XXX: detecting uncaught exception case for C++ case; perhaps need + * some marker in heap->lj state that a try-catch is active. For now, + * invokes C++ uncaught exception handling. + */ +#else if (!thr->heap->lj.jmpbuf_ptr) { /* * If we don't have a jmpbuf_ptr, there is little we can do @@ -34082,8 +42638,16 @@ DUK_INTERNAL void duk_err_longjmp(duk_hthread *thr) { duk_fatal((duk_context *) thr, DUK_ERR_UNCAUGHT_ERROR, "uncaught error"); DUK_UNREACHABLE(); } +#endif +#if defined(DUK_USE_CPP_EXCEPTIONS) + { + duk_internal_exception exc; /* dummy */ + throw exc; + } +#else DUK_LONGJMP(thr->heap->lj.jmpbuf_ptr->jb); +#endif DUK_UNREACHABLE(); } #line 1 "duk_error_misc.c" @@ -34093,6 +42657,38 @@ DUK_INTERNAL void duk_err_longjmp(duk_hthread *thr) { /* include removed: duk_internal.h */ +/* + * Helper to walk the thread chain and see if there is an active error + * catcher. Protected calls or finally blocks aren't considered catching. + */ + +#if defined(DUK_USE_DEBUGGER_SUPPORT) && \ + (defined(DUK_USE_DEBUGGER_THROW_NOTIFY) || defined(DUK_USE_DEBUGGER_PAUSE_UNCAUGHT)) +DUK_LOCAL duk_bool_t duk__have_active_catcher(duk_hthread *thr) { + /* + * XXX: As noted above, a protected API call won't be counted as a + * catcher. This is usually convenient, e.g. in the case of a top- + * level duk_pcall(), but may not always be desirable. Perhaps add an + * argument to treat them as catchers? + */ + + duk_size_t i; + + DUK_ASSERT(thr != NULL); + + while (thr != NULL) { + for (i = 0; i < thr->catchstack_top; i++) { + duk_catcher *cat = thr->catchstack + i; + if (DUK_CAT_HAS_CATCH_ENABLED(cat)) { + return 1; /* all we need to know */ + } + } + thr = thr->resumer; + } + return 0; +} +#endif /* DUK_USE_DEBUGGER_SUPPORT && (DUK_USE_DEBUGGER_THROW_NOTIFY || DUK_USE_DEBUGGER_PAUSE_UNCAUGHT) */ + /* * Get prototype object for an integer error code. */ @@ -34129,15 +42725,61 @@ DUK_INTERNAL duk_hobject *duk_error_prototype_from_code(duk_hthread *thr, duk_er */ DUK_INTERNAL void duk_err_setup_heap_ljstate(duk_hthread *thr, duk_small_int_t lj_type) { - duk_tval tv_tmp; +#if defined(DUK_USE_DEBUGGER_SUPPORT) + /* If something is thrown with the debugger attached and nobody will + * catch it, execution is paused before the longjmp, turning over + * control to the debug client. This allows local state to be examined + * before the stack is unwound. Errors are not intercepted when debug + * message loop is active (e.g. for Eval). + */ + + /* XXX: Allow customizing the pause and notify behavior at runtime + * using debugger runtime flags. For now the behavior is fixed using + * config options. + */ +#if defined(DUK_USE_DEBUGGER_THROW_NOTIFY) || defined(DUK_USE_DEBUGGER_PAUSE_UNCAUGHT) + if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap) && + !thr->heap->dbg_processing && + lj_type == DUK_LJ_TYPE_THROW) { + duk_context *ctx = (duk_context *) thr; + duk_bool_t fatal; + duk_hobject *h_obj; + + /* Don't intercept a DoubleError, we may have caused the initial double + * fault and attempting to intercept it will cause us to be called + * recursively and exhaust the C stack. + */ + h_obj = duk_get_hobject(ctx, -1); + if (h_obj == thr->builtins[DUK_BIDX_DOUBLE_ERROR]) { + DUK_D(DUK_DPRINT("built-in DoubleError instance thrown, not intercepting")); + goto skip_throw_intercept; + } + + DUK_D(DUK_DPRINT("throw with debugger attached, report to client")); + + fatal = !duk__have_active_catcher(thr); + +#if defined(DUK_USE_DEBUGGER_THROW_NOTIFY) + /* Report it to the debug client */ + duk_debug_send_throw(thr, fatal); +#endif + +#if defined(DUK_USE_DEBUGGER_PAUSE_UNCAUGHT) + if (fatal) { + DUK_D(DUK_DPRINT("throw will be fatal, halt before longjmp")); + duk_debug_halt_execution(thr, 1 /*use_prev_pc*/); + } +#endif + } + + skip_throw_intercept: +#endif /* DUK_USE_DEBUGGER_THROW_NOTIFY || DUK_USE_DEBUGGER_PAUSE_UNCAUGHT */ +#endif /* DUK_USE_DEBUGGER_SUPPORT */ thr->heap->lj.type = lj_type; DUK_ASSERT(thr->valstack_top > thr->valstack); - DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1); - DUK_TVAL_SET_TVAL(&thr->heap->lj.value1, thr->valstack_top - 1); - DUK_TVAL_INCREF(thr, &thr->heap->lj.value1); - DUK_TVAL_DECREF(thr, &tv_tmp); + DUK_TVAL_SET_TVAL_UPDREF(thr, &thr->heap->lj.value1, thr->valstack_top - 1); /* side effects */ duk_pop((duk_context *) thr); } @@ -34185,6 +42827,23 @@ DUK_INTERNAL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code) thr->heap->handling_error = 1; + if (!double_error) { + /* Allow headroom for calls during error handling (see GH-191). + * We allow space for 10 additional recursions, with one extra + * for, e.g. a print() call at the deepest level. + */ + DUK_ASSERT(thr->callstack_max == DUK_CALLSTACK_DEFAULT_MAX); + thr->callstack_max = DUK_CALLSTACK_DEFAULT_MAX + DUK_CALLSTACK_GROW_STEP + 11; + } + + DUK_ASSERT(thr->callstack_max == DUK_CALLSTACK_DEFAULT_MAX + DUK_CALLSTACK_GROW_STEP + 11); /* just making sure */ + + /* Sync so that augmentation sees up-to-date activations, NULL + * thr->ptr_curr_pc so that it's not used if side effects occur + * in augmentation or longjmp handling. + */ + duk_hthread_sync_and_null_currpc(thr); + /* * Create and push an error object onto the top of stack. * If a "double error" occurs, use a fixed error instance @@ -34245,10 +42904,11 @@ DUK_INTERNAL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code) * Finally, longjmp */ - thr->heap->handling_error = 0; - duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_THROW); + thr->callstack_max = DUK_CALLSTACK_DEFAULT_MAX; /* reset callstack limit */ + thr->heap->handling_error = 0; + DUK_DDD(DUK_DDDPRINT("THROW ERROR (INTERNAL): %!iT, %!iT (after throw augment)", (duk_tval *) &thr->heap->lj.value1, (duk_tval *) &thr->heap->lj.value2)); @@ -34271,6 +42931,7 @@ DUK_INTERNAL void duk_error_throw_from_negative_rc(duk_hthread *thr, duk_ret_t r /* XXX: this generates quite large code - perhaps select the error * class based on the code and then just use the error 'name'? */ + /* XXX: shared strings */ code = -rc; @@ -34311,10 +42972,18 @@ DUK_INTERNAL void duk_error_throw_from_negative_rc(duk_hthread *thr, duk_ret_t r /* include removed: duk_internal.h */ -DUK_INTERNAL duk_hbuffer *duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk_small_uint_t flags) { +/* Allocate a new duk_hbuffer of a certain type and return a pointer to it + * (NULL on error). Write buffer data pointer to 'out_bufdata' (only if + * allocation successful). + */ +DUK_INTERNAL duk_hbuffer *duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk_small_uint_t flags, void **out_bufdata) { duk_hbuffer *res = NULL; + duk_size_t header_size; duk_size_t alloc_size; + DUK_ASSERT(heap != NULL); + DUK_ASSERT(out_bufdata != NULL); + DUK_DDD(DUK_DDDPRINT("allocate hbuffer")); /* Size sanity check. Should not be necessary because caller is @@ -34324,12 +42993,17 @@ DUK_INTERNAL duk_hbuffer *duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk */ if (size > DUK_HBUFFER_MAX_BYTELEN) { DUK_D(DUK_DPRINT("hbuffer alloc failed: size too large: %ld", (long) size)); - return NULL; + return NULL; /* no need to write 'out_bufdata' */ } - if (flags & DUK_BUF_FLAG_DYNAMIC) { + if (flags & DUK_BUF_FLAG_EXTERNAL) { + header_size = sizeof(duk_hbuffer_external); + alloc_size = sizeof(duk_hbuffer_external); + } if (flags & DUK_BUF_FLAG_DYNAMIC) { + header_size = sizeof(duk_hbuffer_dynamic); alloc_size = sizeof(duk_hbuffer_dynamic); } else { + header_size = sizeof(duk_hbuffer_fixed); alloc_size = sizeof(duk_hbuffer_fixed) + size; DUK_ASSERT(alloc_size >= sizeof(duk_hbuffer_fixed)); /* no wrapping */ } @@ -34342,20 +43016,30 @@ DUK_INTERNAL duk_hbuffer *duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk /* zero everything unless requested not to do so */ #if defined(DUK_USE_ZERO_BUFFER_DATA) DUK_MEMZERO((void *) res, - (flags & DUK_BUF_FLAG_NOZERO) ? - ((flags & DUK_BUF_FLAG_DYNAMIC) ? - sizeof(duk_hbuffer_dynamic) : - sizeof(duk_hbuffer_fixed)) : - alloc_size); + (flags & DUK_BUF_FLAG_NOZERO) ? header_size : alloc_size); #else - DUK_MEMZERO((void *) res, - (flags & DUK_BUF_FLAG_DYNAMIC) ? sizeof(duk_hbuffer_dynamic) : sizeof(duk_hbuffer_fixed)); + DUK_MEMZERO((void *) res, header_size); #endif - if (flags & DUK_BUF_FLAG_DYNAMIC) { + if (flags & DUK_BUF_FLAG_EXTERNAL) { + duk_hbuffer_external *h; + h = (duk_hbuffer_external *) res; + DUK_UNREF(h); + *out_bufdata = NULL; +#if defined(DUK_USE_EXPLICIT_NULL_INIT) +#if defined(DUK_USE_HEAPPTR16) +/* the compressed pointer is zeroed which maps to NULL, so nothing to do. */ +#else + DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap, h, NULL); +#endif +#endif + DUK_ASSERT(DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap, h) == NULL); + } else if (flags & DUK_BUF_FLAG_DYNAMIC) { duk_hbuffer_dynamic *h = (duk_hbuffer_dynamic *) res; void *ptr; + if (size > 0) { + DUK_ASSERT(!(flags & DUK_BUF_FLAG_EXTERNAL)); /* alloc external with size zero */ DUK_DDD(DUK_DDDPRINT("dynamic buffer with nonzero size, alloc actual buffer")); #ifdef DUK_USE_ZERO_BUFFER_DATA ptr = DUK_ALLOC_ZEROED(heap, size); @@ -34366,15 +43050,22 @@ DUK_INTERNAL duk_hbuffer *duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk /* Because size > 0, NULL check is correct */ goto error; } + *out_bufdata = ptr; DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap, h, ptr); - DUK_HBUFFER_DYNAMIC_SET_ALLOC_SIZE(h, size); /* snug */ } else { -#ifdef DUK_USE_EXPLICIT_NULL_INIT - h->curr_alloc = NULL; + *out_bufdata = NULL; +#if defined(DUK_USE_EXPLICIT_NULL_INIT) +#if defined(DUK_USE_HEAPPTR16) +/* the compressed pointer is zeroed which maps to NULL, so nothing to do. */ +#else + DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap, h, NULL); #endif - DUK_ASSERT(DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(h) == 0); +#endif + DUK_ASSERT(DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, h) == NULL); } + } else { + *out_bufdata = (void *) ((duk_hbuffer_fixed *) res + 1); } DUK_HBUFFER_SET_SIZE(res, size); @@ -34382,6 +43073,11 @@ DUK_INTERNAL duk_hbuffer *duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk DUK_HEAPHDR_SET_TYPE(&res->hdr, DUK_HTYPE_BUFFER); if (flags & DUK_BUF_FLAG_DYNAMIC) { DUK_HBUFFER_SET_DYNAMIC(res); + if (flags & DUK_BUF_FLAG_EXTERNAL) { + DUK_HBUFFER_SET_EXTERNAL(res); + } + } else { + DUK_ASSERT(!(flags & DUK_BUF_FLAG_EXTERNAL)); } DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap, &res->hdr); @@ -34392,7 +43088,7 @@ DUK_INTERNAL duk_hbuffer *duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk DUK_DD(DUK_DDPRINT("hbuffer allocation failed")); DUK_FREE(heap, res); - return NULL; + return NULL; /* no need to write 'out_bufdata' */ } /* For indirect allocs. */ @@ -34420,34 +43116,20 @@ DUK_INTERNAL void *duk_hbuffer_get_dynalloc_ptr(duk_heap *heap, void *ud) { * Resizing */ -DUK_LOCAL duk_size_t duk__add_spare(duk_size_t size) { - duk_size_t spare = (size / DUK_HBUFFER_SPARE_DIVISOR) + DUK_HBUFFER_SPARE_ADD; - duk_size_t res; - - res = size + spare; - if (res < size) { - /* XXX: handle corner cases where size is close to size limit (wraparound) */ - DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "duk_size_t wrapped"); - } - DUK_ASSERT(res >= size); - - return res; -} - -DUK_INTERNAL void duk_hbuffer_resize(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t new_size, duk_size_t new_alloc_size) { +DUK_INTERNAL void duk_hbuffer_resize(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t new_size) { void *res; - duk_size_t prev_alloc_size; + duk_size_t prev_size; DUK_ASSERT(thr != NULL); DUK_ASSERT(buf != NULL); - DUK_ASSERT(new_alloc_size >= new_size); DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); + DUK_ASSERT(!DUK_HBUFFER_HAS_EXTERNAL(buf)); /* * Maximum size check */ - if (new_alloc_size > DUK_HBUFFER_MAX_BYTELEN) { + if (new_size > DUK_HBUFFER_MAX_BYTELEN) { DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, "buffer too long"); } @@ -34457,465 +43139,71 @@ DUK_INTERNAL void duk_hbuffer_resize(duk_hthread *thr, duk_hbuffer_dynamic *buf, * collection. */ - res = DUK_REALLOC_INDIRECT(thr->heap, duk_hbuffer_get_dynalloc_ptr, (void *) buf, new_alloc_size); - if (res != NULL || new_alloc_size == 0) { + res = DUK_REALLOC_INDIRECT(thr->heap, duk_hbuffer_get_dynalloc_ptr, (void *) buf, new_size); + if (res != NULL || new_size == 0) { /* 'res' may be NULL if new allocation size is 0. */ - DUK_DDD(DUK_DDDPRINT("resized dynamic buffer %p:%ld:%ld -> %p:%ld:%ld", + DUK_DDD(DUK_DDDPRINT("resized dynamic buffer %p:%ld -> %p:%ld", (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, buf), (long) DUK_HBUFFER_DYNAMIC_GET_SIZE(buf), - (long) DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(buf), (void *) res, - (long) new_size, - (long) new_alloc_size)); + (long) new_size)); /* * The entire allocated buffer area, regardless of actual used * size, is kept zeroed in resizes for simplicity. If the buffer - * is grown, zero the new part. Another policy would be to - * ensure data is zeroed as the used part is extended. The - * current approach is much more simple and is not a big deal - * because the spare part is relatively small. + * is grown, zero the new part. */ - prev_alloc_size = DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(buf); - if (new_alloc_size > prev_alloc_size) { - DUK_ASSERT(new_alloc_size - prev_alloc_size > 0); + prev_size = DUK_HBUFFER_DYNAMIC_GET_SIZE(buf); + if (new_size > prev_size) { + DUK_ASSERT(new_size - prev_size > 0); #ifdef DUK_USE_ZERO_BUFFER_DATA - DUK_MEMZERO((void *) ((char *) res + prev_alloc_size), - new_alloc_size - prev_alloc_size); + DUK_MEMZERO((void *) ((char *) res + prev_size), + (duk_size_t) (new_size - prev_size)); #endif } DUK_HBUFFER_DYNAMIC_SET_SIZE(buf, new_size); - DUK_HBUFFER_DYNAMIC_SET_ALLOC_SIZE(buf, new_alloc_size); DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(thr->heap, buf, res); } else { - DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, "buffer resize failed: %ld:%ld to %ld:%ld", + DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, "buffer resize failed: %ld to %ld", (long) DUK_HBUFFER_DYNAMIC_GET_SIZE(buf), - (long) DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(buf), - (long) new_size, - (long) new_alloc_size); + (long) new_size); } - DUK_ASSERT(res != NULL || new_alloc_size == 0); + DUK_ASSERT(res != NULL || new_size == 0); } DUK_INTERNAL void duk_hbuffer_reset(duk_hthread *thr, duk_hbuffer_dynamic *buf) { DUK_ASSERT(thr != NULL); DUK_ASSERT(buf != NULL); DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); + DUK_ASSERT(!DUK_HBUFFER_HAS_EXTERNAL(buf)); - duk_hbuffer_resize(thr, buf, 0, 0); + duk_hbuffer_resize(thr, buf, 0); } +/* include removed: duk_internal.h */ +#line 2 "duk_hbufferobject_misc.c" -#if 0 /*unused*/ -DUK_INTERNAL void duk_hbuffer_compact(duk_hthread *thr, duk_hbuffer_dynamic *buf) { - duk_size_t curr_size; +#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) +DUK_INTERNAL duk_uint_t duk_hbufferobject_clamp_bytelength(duk_hbufferobject *h_bufobj, duk_uint_t len) { + duk_uint_t buf_size; + duk_uint_t buf_avail; - DUK_ASSERT(thr != NULL); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); + DUK_ASSERT(h_bufobj != NULL); + DUK_ASSERT(h_bufobj->buf != NULL); - curr_size = DUK_HBUFFER_GET_SIZE(buf); - duk_hbuffer_resize(thr, buf, curr_size, curr_size); -} -#endif - -/* - * Inserts - */ - -DUK_INTERNAL void duk_hbuffer_insert_bytes(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, const duk_uint8_t *data, duk_size_t length) { - duk_uint8_t *p; - - /* XXX: allow inserts with offset > curr_size? i.e., insert zeroes automatically? */ - - DUK_ASSERT(thr != NULL); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); - DUK_ASSERT_DISABLE(offset >= 0); /* unsigned, so always true */ - DUK_ASSERT(offset <= DUK_HBUFFER_GET_SIZE(buf)); /* equality is OK (= append) */ - DUK_ASSERT(data != NULL); - DUK_ASSERT_DISABLE(length >= 0); /* unsigned, so always true */ - - if (length == 0) { - return; + buf_size = (duk_uint_t) DUK_HBUFFER_GET_SIZE(h_bufobj->buf); + if (h_bufobj->offset > buf_size) { + /* Slice starting point is beyond current length. */ + return 0; } + buf_avail = buf_size - h_bufobj->offset; - if (DUK_HBUFFER_DYNAMIC_GET_SPARE_SIZE(buf) < length) { - duk_hbuffer_resize(thr, - buf, - DUK_HBUFFER_GET_SIZE(buf), - duk__add_spare(DUK_HBUFFER_GET_SIZE(buf) + length)); - } - DUK_ASSERT(DUK_HBUFFER_DYNAMIC_GET_SPARE_SIZE(buf) >= length); - - p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, buf); - if (offset < DUK_HBUFFER_GET_SIZE(buf)) { - /* not an append */ - - DUK_ASSERT(DUK_HBUFFER_GET_SIZE(buf) - offset > 0); - DUK_MEMMOVE((void *) (p + offset + length), - (void *) (p + offset), - DUK_HBUFFER_GET_SIZE(buf) - offset); - } - - DUK_ASSERT(length > 0); - DUK_MEMCPY((void *) (p + offset), - data, - length); - - DUK_HBUFFER_DYNAMIC_ADD_SIZE(buf, length); -} - -#if 0 /*unused*/ -DUK_INTERNAL void duk_hbuffer_insert_byte(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_uint8_t byte) { - DUK_ASSERT(thr != NULL); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); - - duk_hbuffer_insert_bytes(thr, buf, offset, &byte, 1); -} -#endif - -#if 0 /*unused*/ -DUK_INTERNAL duk_size_t duk_hbuffer_insert_cstring(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, const char *str) { - duk_size_t len; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(str != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); - - len = DUK_STRLEN(str); - duk_hbuffer_insert_bytes(thr, buf, offset, (duk_uint8_t *) str, len); - return len; -} -#endif - -#if 0 /*unused*/ -DUK_INTERNAL duk_size_t duk_hbuffer_insert_hstring(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_hstring *str) { - duk_size_t len; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(str != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); - - len = DUK_HSTRING_GET_BYTELEN(str); - duk_hbuffer_insert_bytes(thr, buf, offset, (duk_uint8_t *) DUK_HSTRING_GET_DATA(str), len); - return len; -} -#endif - -DUK_INTERNAL duk_size_t duk_hbuffer_insert_xutf8(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_ucodepoint_t codepoint) { - duk_uint8_t tmp[DUK_UNICODE_MAX_XUTF8_LENGTH]; - duk_size_t len; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); - /* No range assertion for 'codepoint' */ - - /* Intentionally no fast path: insertion is not that central */ - - len = (duk_size_t) duk_unicode_encode_xutf8(codepoint, tmp); - duk_hbuffer_insert_bytes(thr, buf, offset, tmp, len); - return len; -} - -/* Append a Unicode codepoint to the buffer in CESU-8 format, i.e., convert - * non-BMP characters to surrogate pairs which are then "UTF-8" encoded. - * If the codepoint is initially a surrogate, it is also encoded into CESU-8. - * Codepoints above valid Unicode range (> U+10FFFF) are mangled. - */ - -#if 0 /*unused*/ -DUK_INTERNAL duk_size_t duk_hbuffer_insert_cesu8(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_ucodepoint_t codepoint) { - duk_uint8_t tmp[DUK_UNICODE_MAX_CESU8_LENGTH]; - duk_size_t len; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); - DUK_ASSERT_DISABLE(codepoint >= 0); /* unsigned */ - DUK_ASSERT(codepoint <= 0x10ffff); /* if not in this range, results are garbage (but no crash) */ - - /* Intentionally no fast path: insertion is not that central */ - - len = (duk_size_t) duk_unicode_encode_cesu8(codepoint, tmp); - duk_hbuffer_insert_bytes(thr, buf, offset, tmp, len); - return len; -} -#endif - -/* - * Appends - * - * Note: an optimized duk_hbuffer_append_bytes() could be implemented, but - * it is more compact to use duk_hbuffer_insert_bytes() instead. The - * important fast paths bypass these functions. anyway. - */ - -DUK_INTERNAL void duk_hbuffer_append_bytes(duk_hthread *thr, duk_hbuffer_dynamic *buf, const duk_uint8_t *data, duk_size_t length) { - DUK_ASSERT(thr != NULL); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); - DUK_ASSERT(data != NULL); - - duk_hbuffer_insert_bytes(thr, buf, DUK_HBUFFER_GET_SIZE(buf), data, length); -} - -DUK_INTERNAL void duk_hbuffer_append_byte(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_uint8_t byte) { - DUK_ASSERT(thr != NULL); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); - - duk_hbuffer_insert_bytes(thr, buf, DUK_HBUFFER_GET_SIZE(buf), &byte, 1); -} - -DUK_INTERNAL duk_size_t duk_hbuffer_append_cstring(duk_hthread *thr, duk_hbuffer_dynamic *buf, const char *str) { - duk_size_t len; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(str != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); - - len = DUK_STRLEN(str); - duk_hbuffer_insert_bytes(thr, buf, DUK_HBUFFER_GET_SIZE(buf), (duk_uint8_t *) str, len); - return len; -} - -DUK_INTERNAL duk_size_t duk_hbuffer_append_hstring(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_hstring *str) { - duk_size_t len; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(str != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); - - len = DUK_HSTRING_GET_BYTELEN(str); - duk_hbuffer_insert_bytes(thr, buf, DUK_HBUFFER_GET_SIZE(buf), (duk_uint8_t *) DUK_HSTRING_GET_DATA(str), len); - return len; -} - -/* Append a Unicode codepoint to the buffer in extended UTF-8 format, i.e. - * allow codepoints above standard Unicode range (> U+10FFFF) up to seven - * byte encoding (36 bits, but argument type is 32 bits). In particular, - * allows encoding of all unsigned 32-bit integers. If the codepoint is - * initially a surrogate, it is encoded without checking (and will become, - * effectively, CESU-8 encoded). - */ - -DUK_INTERNAL duk_size_t duk_hbuffer_append_xutf8(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_ucodepoint_t codepoint) { - duk_uint8_t tmp[DUK_UNICODE_MAX_XUTF8_LENGTH]; - duk_size_t len; - duk_size_t sz; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); - /* No range assertion for 'codepoint' */ - - if (DUK_LIKELY(codepoint < 0x80 && DUK_HBUFFER_DYNAMIC_GET_SPARE_SIZE(buf) > 0)) { - /* fast path: ASCII and there is spare */ - duk_uint8_t *p = ((duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, buf)); - sz = DUK_HBUFFER_DYNAMIC_GET_SIZE(buf); - p[sz++] = (duk_uint8_t) codepoint; - DUK_HBUFFER_DYNAMIC_SET_SIZE(buf, sz); - return 1; - } - - len = (duk_size_t) duk_unicode_encode_xutf8(codepoint, tmp); - duk_hbuffer_insert_bytes(thr, buf, DUK_HBUFFER_GET_SIZE(buf), tmp, len); - return len; -} - -/* Append a Unicode codepoint to the buffer in CESU-8 format, i.e., convert - * non-BMP characters to surrogate pairs which are then "UTF-8" encoded. - * If the codepoint is initially a surrogate, it is also encoded into CESU-8. - * Codepoints above valid Unicode range (> U+10FFFF) are mangled. - */ - -DUK_INTERNAL duk_size_t duk_hbuffer_append_cesu8(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_ucodepoint_t codepoint) { - duk_uint8_t tmp[DUK_UNICODE_MAX_CESU8_LENGTH]; - duk_size_t len; - duk_size_t sz; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); - DUK_ASSERT_DISABLE(codepoint >= 0); /* unsigned */ - DUK_ASSERT(codepoint <= 0x10ffff); /* if not in this range, results are garbage (but no crash) */ - - if (DUK_LIKELY(codepoint < 0x80 && DUK_HBUFFER_DYNAMIC_GET_SPARE_SIZE(buf) > 0)) { - /* fast path: ASCII and there is spare */ - duk_uint8_t *p = ((duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, buf)); - sz = DUK_HBUFFER_DYNAMIC_GET_SIZE(buf); - p[sz++] = (duk_uint8_t) codepoint; - DUK_HBUFFER_DYNAMIC_SET_SIZE(buf, sz); - return 1; - } - - len = (duk_size_t) duk_unicode_encode_cesu8(codepoint, tmp); - duk_hbuffer_insert_bytes(thr, buf, DUK_HBUFFER_GET_SIZE(buf), tmp, len); - return len; -} - -/* Append an duk_uint32_t in native byte order. */ -#if 0 /*unused*/ -DUK_INTERNAL void duk_hbuffer_append_native_u32(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_uint32_t val) { - /* relies on duk_uint32_t being exactly right size */ - DUK_ASSERT(sizeof(val) == 4); - duk_hbuffer_insert_bytes(thr, - buf, - DUK_HBUFFER_GET_SIZE(buf), - (duk_uint8_t *) &val, - sizeof(duk_uint32_t)); -} -#endif - -/* - * In-buffer "slices" - * - * Slices are identified with an offset+length pair, referring to the current - * buffer data. A caller cannot otherwise reliably refer to existing data, - * because the buffer may be reallocated before a data pointer is referenced. - */ - -DUK_INTERNAL void duk_hbuffer_remove_slice(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_size_t length) { - duk_uint8_t *p; - duk_size_t end_offset; - - DUK_UNREF(thr); - - DUK_ASSERT(thr != NULL); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); - DUK_ASSERT_DISABLE(offset >= 0); /* always true */ - DUK_ASSERT(offset <= DUK_HBUFFER_GET_SIZE(buf)); /* allow equality */ - DUK_ASSERT_DISABLE(length >= 0); /* always true */ - DUK_ASSERT(offset + length <= DUK_HBUFFER_GET_SIZE(buf)); /* allow equality */ - - if (length == 0) { - return; - } - - p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, buf); - - end_offset = offset + length; - - if (end_offset < DUK_HBUFFER_GET_SIZE(buf)) { - /* not strictly from end of buffer; need to shuffle data */ - DUK_ASSERT(DUK_HBUFFER_GET_SIZE(buf) - end_offset > 0); - DUK_MEMMOVE(p + offset, - p + end_offset, - DUK_HBUFFER_GET_SIZE(buf) - end_offset); - } - - /* Here we want to zero data even with automatic buffer zeroing - * disabled as we depend on this internally too. - */ - DUK_ASSERT(length > 0); - DUK_MEMZERO(p + DUK_HBUFFER_GET_SIZE(buf) - length, - length); - - DUK_HBUFFER_DYNAMIC_SUB_SIZE(buf, length); - - /* Note: no shrink check, intentional */ -} - -DUK_INTERNAL void duk_hbuffer_insert_slice(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t dst_offset, duk_size_t src_offset, duk_size_t length) { - duk_uint8_t *p; - duk_size_t src_end_offset; /* source end (exclusive) in initial buffer */ - duk_size_t len; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); - DUK_ASSERT_DISABLE(dst_offset >= 0); /* always true */ - DUK_ASSERT(dst_offset <= DUK_HBUFFER_GET_SIZE(buf)); /* allow equality */ - DUK_ASSERT_DISABLE(src_offset >= 0); /* always true */ - DUK_ASSERT(src_offset <= DUK_HBUFFER_GET_SIZE(buf)); /* allow equality */ - DUK_ASSERT_DISABLE(length >= 0); /* always true */ - DUK_ASSERT(src_offset + length <= DUK_HBUFFER_GET_SIZE(buf)); /* allow equality */ - - if (length == 0) { - return; - } - - if (DUK_HBUFFER_DYNAMIC_GET_SPARE_SIZE(buf) < length) { - duk_hbuffer_resize(thr, - buf, - DUK_HBUFFER_GET_SIZE(buf), - duk__add_spare(DUK_HBUFFER_GET_SIZE(buf) + length)); - } - DUK_ASSERT(DUK_HBUFFER_DYNAMIC_GET_SPARE_SIZE(buf) >= length); - - p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, buf); - DUK_ASSERT(p != NULL); /* must be the case because length > 0, and buffer has been resized if necessary */ - - /* - * src_offset and dst_offset refer to the state of the buffer - * before any changes are made. This must be taken into account - * when moving data around; in particular, the source data may - * "straddle" the dst_offset, so the insert may need to be handled - * in two pieces. - */ - - src_end_offset = src_offset + length; - - /* create a hole for the insert */ - len = DUK_HBUFFER_GET_SIZE(buf) - dst_offset; - DUK_MEMMOVE(p + dst_offset + length, - p + dst_offset, - len); /* zero size is not an issue: pointers are valid */ - - if (src_offset < dst_offset) { - if (src_end_offset <= dst_offset) { - /* entire source is before 'dst_offset' */ - DUK_MEMCPY(p + dst_offset, - p + src_offset, - length); - } else { - /* part of the source is before 'dst_offset'; straddles */ - len = dst_offset - src_offset; - DUK_ASSERT(len >= 1 && len < length); - DUK_ASSERT(length - len >= 1); - DUK_MEMCPY(p + dst_offset, - p + src_offset, - len); - DUK_MEMCPY(p + dst_offset + len, - p + src_offset + length + len, /* take above memmove() into account */ - length - len); - } - } else { - /* entire source is after 'dst_offset' */ - DUK_MEMCPY(p + dst_offset, - p + src_offset + length, /* take above memmove() into account */ - length); - } - - DUK_HBUFFER_DYNAMIC_ADD_SIZE(buf, length); -} - -DUK_INTERNAL void duk_hbuffer_append_slice(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t src_offset, duk_size_t length) { - DUK_ASSERT(thr != NULL); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); - DUK_ASSERT_DISABLE(src_offset >= 0); /* always true */ - DUK_ASSERT(src_offset <= DUK_HBUFFER_GET_SIZE(buf)); /* allow equality */ - DUK_ASSERT_DISABLE(length >= 0); /* always true */ - DUK_ASSERT(src_offset + length <= DUK_HBUFFER_GET_SIZE(buf)); /* allow equality */ - - duk_hbuffer_insert_slice(thr, - buf, - DUK_HBUFFER_GET_SIZE(buf), - src_offset, - length); + return buf_avail >= len ? len : buf_avail; } +#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ #line 1 "duk_heap_alloc.c" /* * duk_heap allocation and freeing. @@ -34975,7 +43263,7 @@ DUK_INTERNAL void duk_free_hbuffer_inner(duk_heap *heap, duk_hbuffer *h) { DUK_ASSERT(heap != NULL); DUK_ASSERT(h != NULL); - if (DUK_HBUFFER_HAS_DYNAMIC(h)) { + if (DUK_HBUFFER_HAS_DYNAMIC(h) && !DUK_HBUFFER_HAS_EXTERNAL(h)) { duk_hbuffer_dynamic *g = (duk_hbuffer_dynamic *) h; DUK_DDD(DUK_DDDPRINT("free dynamic buffer %p", (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, g))); DUK_FREE(heap, DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, g)); @@ -35052,7 +43340,7 @@ DUK_LOCAL void duk__free_allocated(duk_heap *heap) { } } -#ifdef DUK_USE_REFERENCE_COUNTING +#if defined(DUK_USE_REFERENCE_COUNTING) DUK_LOCAL void duk__free_refzero_list(duk_heap *heap) { duk_heaphdr *curr; duk_heaphdr *next; @@ -35068,7 +43356,7 @@ DUK_LOCAL void duk__free_refzero_list(duk_heap *heap) { } #endif -#ifdef DUK_USE_MARK_AND_SWEEP +#if defined(DUK_USE_MARK_AND_SWEEP) DUK_LOCAL void duk__free_markandsweep_finalize_list(duk_heap *heap) { duk_heaphdr *curr; duk_heaphdr *next; @@ -35092,16 +43380,17 @@ DUK_LOCAL void duk__free_stringtable(duk_heap *heap) { DUK_LOCAL void duk__free_run_finalizers(duk_heap *heap) { duk_hthread *thr; duk_heaphdr *curr; -#ifdef DUK_USE_DEBUG - duk_size_t count_obj = 0; -#endif + duk_uint_t round_no; + duk_size_t count_all; + duk_size_t count_finalized; + duk_size_t curr_limit; DUK_ASSERT(heap != NULL); DUK_ASSERT(heap->heap_thread != NULL); -#ifdef DUK_USE_REFERENCE_COUNTING +#if defined(DUK_USE_REFERENCE_COUNTING) DUK_ASSERT(heap->refzero_list == NULL); /* refzero not running -> must be empty */ #endif -#ifdef DUK_USE_MARK_AND_SWEEP +#if defined(DUK_USE_MARK_AND_SWEEP) DUK_ASSERT(heap->finalize_list == NULL); /* mark-and-sweep not running -> must be empty */ #endif @@ -35111,30 +43400,74 @@ DUK_LOCAL void duk__free_run_finalizers(duk_heap *heap) { thr = heap->heap_thread; DUK_ASSERT(thr != NULL); - curr = heap->heap_allocated; - while (curr) { - if (DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT) { - /* Only objects in heap_allocated may have finalizers. Check that - * the object itself has a _Finalizer property so that we don't - * execute finalizers for e.g. Proxy objects. - */ - DUK_ASSERT(thr != NULL); - DUK_ASSERT(curr != NULL); + /* Prevent mark-and-sweep for the pending finalizers, also prevents + * refzero handling from moving objects away from the heap_allocated + * list. + */ + DUK_ASSERT(!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)); + DUK_HEAP_SET_MARKANDSWEEP_RUNNING(heap); - if (duk_hobject_hasprop_raw(thr, (duk_hobject *) curr, DUK_HTHREAD_STRING_INT_FINALIZER(thr))) { - duk_hobject_run_finalizer(thr, (duk_hobject *) curr); + curr_limit = 0; /* suppress warning, not used */ + for (round_no = 0; ; round_no++) { + curr = heap->heap_allocated; + count_all = 0; + count_finalized = 0; + while (curr) { + count_all++; + if (DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT) { + /* Only objects in heap_allocated may have finalizers. Check that + * the object itself has a _Finalizer property (own or inherited) + * so that we don't execute finalizers for e.g. Proxy objects. + */ + DUK_ASSERT(thr != NULL); + DUK_ASSERT(curr != NULL); + + if (duk_hobject_hasprop_raw(thr, (duk_hobject *) curr, DUK_HTHREAD_STRING_INT_FINALIZER(thr))) { + if (!DUK_HEAPHDR_HAS_FINALIZED((duk_heaphdr *) curr)) { + DUK_ASSERT(DUK_HEAP_HAS_FINALIZER_NORESCUE(heap)); /* maps to finalizer 2nd argument */ + duk_hobject_run_finalizer(thr, (duk_hobject *) curr); + count_finalized++; + } + } } -#ifdef DUK_USE_DEBUG - count_obj++; -#endif + curr = DUK_HEAPHDR_GET_NEXT(heap, curr); + } + + /* Each round of finalizer execution may spawn new finalizable objects + * which is normal behavior for some applications. Allow multiple + * rounds of finalization, but use a shrinking limit based on the + * first round to detect the case where a runaway finalizer creates + * an unbounded amount of new finalizable objects. Finalizer rescue + * is not supported: the semantics are unclear because most of the + * objects being finalized here are already reachable. The finalizer + * is given a boolean to indicate that rescue is not possible. + * + * See discussion in: https://github.com/svaarala/duktape/pull/473 + */ + + if (round_no == 0) { + /* Cannot wrap: each object is at least 8 bytes so count is + * at most 1/8 of that. + */ + curr_limit = count_all * 2; + } else { + curr_limit = (curr_limit * 3) / 4; /* Decrease by 25% every round */ + } + DUK_D(DUK_DPRINT("finalizer round %ld complete, %ld objects, tried to execute %ld finalizers, current limit is %ld", + (long) round_no, (long) count_all, (long) count_finalized, (long) curr_limit)); + + if (count_finalized == 0) { + DUK_D(DUK_DPRINT("no more finalizable objects, forced finalization finished")); + break; + } + if (count_finalized >= curr_limit) { + DUK_D(DUK_DPRINT("finalizer count above limit, potentially runaway finalizer; skip remaining finalizers")); + break; } - curr = DUK_HEAPHDR_GET_NEXT(heap, curr); } - /* Note: count includes all objects, not only those with an actual finalizer. */ -#ifdef DUK_USE_DEBUG - DUK_D(DUK_DPRINT("checked %ld objects for finalizers before freeing heap", (long) count_obj)); -#endif + DUK_ASSERT(DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)); + DUK_HEAP_CLEAR_MARKANDSWEEP_RUNNING(heap); } DUK_INTERNAL void duk_heap_free(duk_heap *heap) { @@ -35148,6 +43481,9 @@ DUK_INTERNAL void duk_heap_free(duk_heap *heap) { /* Detach a debugger if attached (can be called multiple times) * safely. */ + /* XXX: Add a flag to reject an attempt to re-attach? Otherwise + * the detached callback may immediately reattach. + */ duk_debug_do_detach(heap); #endif @@ -35155,33 +43491,45 @@ DUK_INTERNAL void duk_heap_free(duk_heap *heap) { * objects, and regardless of whether or not mark-and-sweep is * enabled. This gives finalizers the chance to free any native * resources like file handles, allocations made outside Duktape, - * etc. + * etc. This is quite tricky to get right, so that all finalizer + * guarantees are honored. * * XXX: this perhaps requires an execution time limit. */ DUK_D(DUK_DPRINT("execute finalizers before freeing heap")); -#ifdef DUK_USE_MARK_AND_SWEEP - /* run mark-and-sweep a few times just in case (unreachable - * object finalizers run already here) +#if defined(DUK_USE_MARK_AND_SWEEP) + /* Run mark-and-sweep a few times just in case (unreachable object + * finalizers run already here). The last round must rescue objects + * from the previous round without running any more finalizers. This + * ensures rescued objects get their FINALIZED flag cleared so that + * their finalizer is called once more in forced finalization to + * satisfy finalizer guarantees. However, we don't want to run any + * more finalizer because that'd required one more loop, and so on. */ + DUK_D(DUK_DPRINT("forced gc #1 in heap destruction")); duk_heap_mark_and_sweep(heap, 0); + DUK_D(DUK_DPRINT("forced gc #2 in heap destruction")); duk_heap_mark_and_sweep(heap, 0); + DUK_D(DUK_DPRINT("forced gc #3 in heap destruction (don't run finalizers)")); + duk_heap_mark_and_sweep(heap, DUK_MS_FLAG_SKIP_FINALIZERS); /* skip finalizers; queue finalizable objects to heap_allocated */ #endif + + DUK_HEAP_SET_FINALIZER_NORESCUE(heap); /* rescue no longer supported */ duk__free_run_finalizers(heap); - /* Note: heap->heap_thread, heap->curr_thread, heap->heap_object, - * and heap->log_buffer are on the heap allocated list. + /* Note: heap->heap_thread, heap->curr_thread, and heap->heap_object + * are on the heap allocated list. */ DUK_D(DUK_DPRINT("freeing heap objects of heap: %p", (void *) heap)); duk__free_allocated(heap); -#ifdef DUK_USE_REFERENCE_COUNTING +#if defined(DUK_USE_REFERENCE_COUNTING) DUK_D(DUK_DPRINT("freeing refzero list of heap: %p", (void *) heap)); duk__free_refzero_list(heap); #endif -#ifdef DUK_USE_MARK_AND_SWEEP +#if defined(DUK_USE_MARK_AND_SWEEP) DUK_D(DUK_DPRINT("freeing mark-and-sweep finalize list of heap: %p", (void *) heap)); duk__free_markandsweep_finalize_list(heap); #endif @@ -35328,7 +43676,7 @@ DUK_LOCAL duk_bool_t duk__init_heap_thread(duk_heap *heap) { return 1; } -#ifdef DUK_USE_DEBUG +#if defined(DUK_USE_DEBUG) #define DUK__DUMPSZ(t) do { \ DUK_D(DUK_DPRINT("" #t "=%ld", (long) sizeof(t))); \ } while (0) @@ -35342,18 +43690,18 @@ DUK_LOCAL duk_bool_t duk__init_heap_thread(duk_heap *heap) { DUK_D(DUK_DPRINT(t "=[%ld,%ld]=[%lf,%lf]", \ (long) (a), (long) (b), \ (double) (a), (double) (b))); \ - } while(0) + } while (0) #define DUK__DUMPLM_UNSIGNED_RAW(t,a,b) do { \ DUK_D(DUK_DPRINT(t "=[%lu,%lu]=[%lf,%lf]", \ (unsigned long) (a), (unsigned long) (b), \ (double) (a), (double) (b))); \ - } while(0) + } while (0) #define DUK__DUMPLM_SIGNED(t) do { \ DUK__DUMPLM_SIGNED_RAW("DUK_" #t "_{MIN,MAX}", DUK_##t##_MIN, DUK_##t##_MAX); \ - } while(0) + } while (0) #define DUK__DUMPLM_UNSIGNED(t) do { \ DUK__DUMPLM_UNSIGNED_RAW("DUK_" #t "_{MIN,MAX}", DUK_##t##_MIN, DUK_##t##_MAX); \ - } while(0) + } while (0) DUK_LOCAL void duk__dump_type_sizes(void) { DUK_D(DUK_DPRINT("sizeof()")); @@ -35424,7 +43772,9 @@ DUK_LOCAL void duk__dump_type_sizes(void) { DUK__DUMPSZ(duk_tval); /* structs from duk_forwdecl.h */ +#if !defined(DUK_USE_CPP_EXCEPTIONS) DUK__DUMPSZ(duk_jmpbuf); +#endif DUK__DUMPSZ(duk_heaphdr); DUK__DUMPSZ(duk_heaphdr_string); DUK__DUMPSZ(duk_hstring); @@ -35436,6 +43786,7 @@ DUK_LOCAL void duk__dump_type_sizes(void) { DUK__DUMPSZ(duk_hbuffer); DUK__DUMPSZ(duk_hbuffer_fixed); DUK__DUMPSZ(duk_hbuffer_dynamic); + DUK__DUMPSZ(duk_hbuffer_external); DUK__DUMPSZ(duk_propaccessor); DUK__DUMPSZ(duk_propvalue); DUK__DUMPSZ(duk_propdesc); @@ -35514,19 +43865,27 @@ DUK_LOCAL void duk__dump_type_limits(void) { DUK_LOCAL void duk__dump_misc_options(void) { DUK_D(DUK_DPRINT("DUK_VERSION: %ld", (long) DUK_VERSION)); DUK_D(DUK_DPRINT("DUK_GIT_DESCRIBE: %s", DUK_GIT_DESCRIBE)); + DUK_D(DUK_DPRINT("OS string: %s", DUK_USE_OS_STRING)); + DUK_D(DUK_DPRINT("architecture string: %s", DUK_USE_ARCH_STRING)); + DUK_D(DUK_DPRINT("compiler string: %s", DUK_USE_COMPILER_STRING)); #if defined(DUK_USE_PACKED_TVAL) DUK_D(DUK_DPRINT("DUK_USE_PACKED_TVAL: yes")); #else DUK_D(DUK_DPRINT("DUK_USE_PACKED_TVAL: no")); #endif -#if defined(DUK_USE_INTEGER_LE) - DUK_D(DUK_DPRINT("Integer endianness: little")); -#elif defined(DUK_USE_INTEGER_ME) - DUK_D(DUK_DPRINT("Integer endianness: mixed")); -#elif defined(DUK_USE_INTEGER_BE) - DUK_D(DUK_DPRINT("Integer endianness: big")); +#if defined(DUK_USE_VARIADIC_MACROS) + DUK_D(DUK_DPRINT("DUK_USE_VARIADIC_MACROS: yes")); #else - DUK_D(DUK_DPRINT("Integer endianness: ???")); + DUK_D(DUK_DPRINT("DUK_USE_VARIADIC_MACROS: no")); +#endif +#if defined(DUK_USE_INTEGER_LE) + DUK_D(DUK_DPRINT("integer endianness: little")); +#elif defined(DUK_USE_INTEGER_ME) + DUK_D(DUK_DPRINT("integer endianness: mixed")); +#elif defined(DUK_USE_INTEGER_BE) + DUK_D(DUK_DPRINT("integer endianness: big")); +#else + DUK_D(DUK_DPRINT("integer endianness: ???")); #endif #if defined(DUK_USE_DOUBLE_LE) DUK_D(DUK_DPRINT("IEEE double endianness: little")); @@ -35548,13 +43907,16 @@ duk_heap *duk_heap_alloc(duk_alloc_function alloc_func, duk_fatal_function fatal_func) { duk_heap *res = NULL; + /* Silence a few global unused warnings here. */ + DUK_UNREF(duk_str_unsupported); + DUK_D(DUK_DPRINT("allocate heap")); /* * Debug dump type sizes */ -#ifdef DUK_USE_DEBUG +#if defined(DUK_USE_DEBUG) duk__dump_misc_options(); duk__dump_type_sizes(); duk__dump_type_limits(); @@ -35563,13 +43925,17 @@ duk_heap *duk_heap_alloc(duk_alloc_function alloc_func, /* * If selftests enabled, run them as early as possible */ -#ifdef DUK_USE_SELF_TESTS +#if defined(DUK_USE_SELF_TESTS) DUK_D(DUK_DPRINT("running self tests")); duk_selftest_run_tests(); DUK_D(DUK_DPRINT("self tests passed")); #endif -#ifdef DUK_USE_COMPUTED_NAN + /* + * Computed values (e.g. INFINITY) + */ + +#if defined(DUK_USE_COMPUTED_NAN) do { /* Workaround for some exotic platforms where NAN is missing * and the expression (0.0 / 0.0) does NOT result in a NaN. @@ -35585,11 +43951,7 @@ duk_heap *duk_heap_alloc(duk_alloc_function alloc_func, } while (0); #endif - /* - * Computed values (e.g. INFINITY) - */ - -#ifdef DUK_USE_COMPUTED_INFINITY +#if defined(DUK_USE_COMPUTED_INFINITY) do { /* Similar workaround for INFINITY. */ volatile double dbl1 = 1.0; @@ -35616,20 +43978,19 @@ duk_heap *duk_heap_alloc(duk_alloc_function alloc_func, DUK_MEMZERO(res, sizeof(*res)); /* explicit NULL inits */ -#ifdef DUK_USE_EXPLICIT_NULL_INIT +#if defined(DUK_USE_EXPLICIT_NULL_INIT) res->heap_udata = NULL; res->heap_allocated = NULL; -#ifdef DUK_USE_REFERENCE_COUNTING +#if defined(DUK_USE_REFERENCE_COUNTING) res->refzero_list = NULL; res->refzero_list_tail = NULL; #endif -#ifdef DUK_USE_MARK_AND_SWEEP +#if defined(DUK_USE_MARK_AND_SWEEP) res->finalize_list = NULL; #endif res->heap_thread = NULL; res->curr_thread = NULL; res->heap_object = NULL; - res->log_buffer = NULL; #if defined(DUK_USE_STRTAB_CHAIN) /* nothing to NULL */ #elif defined(DUK_USE_STRTAB_PROBE) @@ -35639,12 +44000,16 @@ duk_heap *duk_heap_alloc(duk_alloc_function alloc_func, res->strtable = (duk_hstring **) NULL; #endif #endif +#if defined(DUK_USE_HEAPPTR16) +/* res->strs16[] is zeroed and zero decodes to NULL, so no NULL inits. */ +#else { duk_small_uint_t i; for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) { res->strs[i] = NULL; } } +#endif #if defined(DUK_USE_DEBUGGER_SUPPORT) res->dbg_read_cb = NULL; res->dbg_write_cb = NULL; @@ -35671,7 +44036,7 @@ duk_heap *duk_heap_alloc(duk_alloc_function alloc_func, /* res->mark_and_sweep_trigger_counter == 0 -> now causes immediate GC; which is OK */ res->call_recursion_depth = 0; - res->call_recursion_limit = DUK_HEAP_DEFAULT_CALL_RECURSION_LIMIT; + res->call_recursion_limit = DUK_USE_NATIVE_CALL_RECLIMIT; /* XXX: use the pointer as a seed for now: mix in time at least */ @@ -35683,20 +44048,17 @@ duk_heap *duk_heap_alloc(duk_alloc_function alloc_func, */ res->hash_seed = (duk_uint32_t) (duk_intptr_t) res; res->rnd_state = (duk_uint32_t) (duk_intptr_t) res; - -#ifdef DUK_USE_INTERRUPT_COUNTER - /* zero value causes an interrupt before executing first instruction */ - DUK_ASSERT(res->interrupt_counter == 0); - DUK_ASSERT(res->interrupt_init == 0); +#if !defined(DUK_USE_STRHASH_DENSE) + res->hash_seed ^= 5381; /* Bernstein hash init value is normally 5381; XOR it in in case pointer low bits are 0 */ #endif -#ifdef DUK_USE_EXPLICIT_NULL_INIT +#if defined(DUK_USE_EXPLICIT_NULL_INIT) res->lj.jmpbuf_ptr = NULL; #endif DUK_ASSERT(res->lj.type == DUK_LJ_TYPE_UNKNOWN); /* zero */ - DUK_TVAL_SET_UNDEFINED_UNUSED(&res->lj.value1); - DUK_TVAL_SET_UNDEFINED_UNUSED(&res->lj.value2); + DUK_TVAL_SET_UNDEFINED(&res->lj.value1); + DUK_TVAL_SET_UNDEFINED(&res->lj.value2); #if (DUK_STRTAB_INITIAL_SIZE < DUK_UTIL_MIN_HASH_PRIME) #error initial heap stringtable size is defined incorrectly @@ -35708,7 +44070,7 @@ duk_heap *duk_heap_alloc(duk_alloc_function alloc_func, #if defined(DUK_USE_STRTAB_CHAIN) DUK_MEMZERO(res->strtable, sizeof(duk_strtab_entry) * DUK_STRTAB_CHAIN_SIZE); -#ifdef DUK_USE_EXPLICIT_NULL_INIT +#if defined(DUK_USE_EXPLICIT_NULL_INIT) { duk_small_uint_t i; for (i = 0; i < DUK_STRTAB_CHAIN_SIZE; i++) { @@ -35739,7 +44101,7 @@ duk_heap *duk_heap_alloc(duk_alloc_function alloc_func, } #endif /* DUK_USE_HEAPPTR16 */ res->st_size = DUK_STRTAB_INITIAL_SIZE; -#ifdef DUK_USE_EXPLICIT_NULL_INIT +#if defined(DUK_USE_EXPLICIT_NULL_INIT) { duk_small_uint_t i; DUK_ASSERT(res->st_size == DUK_STRTAB_INITIAL_SIZE); @@ -35764,7 +44126,7 @@ duk_heap *duk_heap_alloc(duk_alloc_function alloc_func, * Init stringcache */ -#ifdef DUK_USE_EXPLICIT_NULL_INIT +#if defined(DUK_USE_EXPLICIT_NULL_INIT) { duk_small_uint_t i; for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) { @@ -35810,19 +44172,6 @@ duk_heap *duk_heap_alloc(duk_alloc_function alloc_func, } DUK_HOBJECT_INCREF(res->heap_thread, res->heap_object); - /* - * Init log buffer - */ - - DUK_DD(DUK_DDPRINT("HEAP: INIT LOG BUFFER")); - res->log_buffer = (duk_hbuffer_dynamic *) duk_hbuffer_alloc(res, - DUK_BI_LOGGER_SHORT_MSG_LIMIT, - DUK_BUF_FLAG_DYNAMIC /*flags*/); - if (!res->log_buffer) { - goto error; - } - DUK_HBUFFER_INCREF(res->heap_thread, res->log_buffer); - /* * All done */ @@ -35847,11 +44196,23 @@ duk_heap *duk_heap_alloc(duk_alloc_function alloc_func, #line 1 "duk_heap_hashstring.c" /* * String hash computation (interning). + * + * String hashing is performance critical because a string hash is computed + * for all new strings which are candidates to be added to the string table. + * However, strings actually added to the string table go through a codepoint + * length calculation which dominates performance because it goes through + * every byte of the input string (but only for strings added). + * + * The string hash algorithm should be fast, but on the other hand provide + * good enough hashes to ensure both string table and object property table + * hash tables work reasonably well (i.e., there aren't too many collisions + * with real world inputs). Unless the hash is cryptographic, it's always + * possible to craft inputs with maximal hash collisions. */ /* include removed: duk_internal.h */ -/* constants for duk_hashstring() */ +#if defined(DUK_USE_STRHASH_DENSE) #define DUK__STRHASH_SHORTSTRING 4096L #define DUK__STRHASH_MEDIUMSTRING (256L * 1024L) #define DUK__STRHASH_BLOCKSIZE 256L @@ -35859,25 +44220,21 @@ duk_heap *duk_heap_alloc(duk_alloc_function alloc_func, DUK_INTERNAL duk_uint32_t duk_heap_hashstring(duk_heap *heap, const duk_uint8_t *str, duk_size_t len) { duk_uint32_t hash; - /* - * Sampling long strings by byte skipping (like Lua does) is potentially - * a cache problem. Here we do 'block skipping' instead for long strings: - * hash an initial part, and then sample the rest of the string with - * reasonably sized chunks. + /* Use Murmurhash2 directly for short strings, and use "block skipping" + * for long strings: hash an initial part and then sample the rest of + * the string with reasonably sized chunks. An initial offset for the + * sampling is computed based on a hash of the initial part of the string; + * this is done to (usually) avoid the case where all long strings have + * certain offset ranges which are never sampled. * - * Skip should depend on length and bound the total time to roughly - * logarithmic. + * Skip should depend on length and bound the total time to roughly + * logarithmic. With current values: * - * With current values: + * 1M string => 256 * 241 = 61696 bytes (0.06M) of hashing + * 1G string => 256 * 16321 = 4178176 bytes (3.98M) of hashing * - * 1M string => 256 * 241 = 61696 bytes (0.06M) of hashing - * 1G string => 256 * 16321 = 4178176 bytes (3.98M) of hashing - * - * After an initial part has been hashed, an offset is applied before - * starting the sampling. The initial offset is computed from the - * hash of the initial part of the string. The idea is to avoid the - * case that all long strings have certain offset ranges that are never - * sampled. + * XXX: It would be better to compute the skip offset more "smoothly" + * instead of having a few boundary values. */ /* note: mixing len into seed improves hashing when skipping */ @@ -35915,6 +44272,44 @@ DUK_INTERNAL duk_uint32_t duk_heap_hashstring(duk_heap *heap, const duk_uint8_t #endif return hash; } + +#undef DUK__STRHASH_SHORTSTRING +#undef DUK__STRHASH_MEDIUMSTRING +#undef DUK__STRHASH_BLOCKSIZE +#else /* DUK_USE_STRHASH_DENSE */ +DUK_INTERNAL duk_uint32_t duk_heap_hashstring(duk_heap *heap, const duk_uint8_t *str, duk_size_t len) { + duk_uint32_t hash; + duk_size_t step; + duk_size_t off; + + /* Slightly modified "Bernstein hash" from: + * + * http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx + * + * Modifications: string skipping and reverse direction similar to + * Lua 5.1.5, and different hash initializer. + * + * The reverse direction ensures last byte it always included in the + * hash which is a good default as changing parts of the string are + * more often in the suffix than in the prefix. + */ + + hash = heap->hash_seed ^ ((duk_uint32_t) len); /* Bernstein hash init value is normally 5381 */ + step = (len >> DUK_USE_STRHASH_SKIP_SHIFT) + 1; + for (off = len; off >= step; off -= step) { + DUK_ASSERT(off >= 1); /* off >= step, and step >= 1 */ + hash = (hash * 33) + str[off - 1]; + } + +#if defined(DUK_USE_STRHASH16) + /* Truncate to 16 bits here, so that a computed hash can be compared + * against a hash stored in a 16-bit field. + */ + hash &= 0x0000ffffUL; +#endif + return hash; +} +#endif /* DUK_USE_STRHASH_DENSE */ #line 1 "duk_heap_markandsweep.c" /* * Mark-and-sweep garbage collection. @@ -35990,7 +44385,7 @@ DUK_LOCAL void duk__mark_hobject(duk_heap *heap, duk_hobject *h) { if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) { duk_hcompiledfunction *f = (duk_hcompiledfunction *) h; duk_tval *tv, *tv_end; - duk_hobject **funcs, **funcs_end; + duk_hobject **fn, **fn_end; /* 'data' is reachable through every compiled function which * contains a reference. @@ -36005,22 +44400,25 @@ DUK_LOCAL void duk__mark_hobject(duk_heap *heap, duk_hobject *h) { tv++; } - funcs = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(heap, f); - funcs_end = DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(heap, f); - while (funcs < funcs_end) { - duk__mark_heaphdr(heap, (duk_heaphdr *) *funcs); - funcs++; + fn = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(heap, f); + fn_end = DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(heap, f); + while (fn < fn_end) { + duk__mark_heaphdr(heap, (duk_heaphdr *) *fn); + fn++; } } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) { duk_hnativefunction *f = (duk_hnativefunction *) h; DUK_UNREF(f); /* nothing to mark */ + } else if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) { + duk_hbufferobject *b = (duk_hbufferobject *) h; + duk__mark_heaphdr(heap, (duk_heaphdr *) b->buf); } else if (DUK_HOBJECT_IS_THREAD(h)) { duk_hthread *t = (duk_hthread *) h; duk_tval *tv; tv = t->valstack; - while (tv < t->valstack_end) { + while (tv < t->valstack_top) { duk__mark_tval(heap, tv); tv++; } @@ -36065,7 +44463,7 @@ DUK_LOCAL void duk__mark_heaphdr(duk_heap *heap, duk_heaphdr *h) { } DUK_HEAPHDR_SET_REACHABLE(h); - if (heap->mark_and_sweep_recursion_depth >= DUK_HEAP_MARK_AND_SWEEP_RECURSION_LIMIT) { + if (heap->mark_and_sweep_recursion_depth >= DUK_USE_MARK_AND_SWEEP_RECLIMIT) { /* log this with a normal debug level because this should be relatively rare */ DUK_D(DUK_DPRINT("mark-and-sweep recursion limit reached, marking as temproot: %p", (void *) h)); DUK_HEAP_SET_MARKANDSWEEP_RECLIMIT_REACHED(heap); @@ -36114,7 +44512,6 @@ DUK_LOCAL void duk__mark_roots_heap(duk_heap *heap) { duk__mark_heaphdr(heap, (duk_heaphdr *) heap->heap_thread); duk__mark_heaphdr(heap, (duk_heaphdr *) heap->heap_object); - duk__mark_heaphdr(heap, (duk_heaphdr *) heap->log_buffer); for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) { duk_hstring *h = DUK_HEAP_GET_STRING(heap, i); @@ -36771,7 +45168,7 @@ DUK_LOCAL void duk__sweep_heap(duk_heap *heap, duk_int_t flags, duk_size_t *out_ * Run (object) finalizers in the "to be finalized" work list. */ -DUK_LOCAL void duk__run_object_finalizers(duk_heap *heap) { +DUK_LOCAL void duk__run_object_finalizers(duk_heap *heap, duk_small_uint_t flags) { duk_heaphdr *curr; duk_heaphdr *next; #ifdef DUK_USE_DEBUG @@ -36794,13 +45191,22 @@ DUK_LOCAL void duk__run_object_finalizers(duk_heap *heap) { DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr)); DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr)); - /* run the finalizer */ - duk_hobject_run_finalizer(thr, (duk_hobject *) curr); /* must never longjmp */ - - /* mark FINALIZED, for next mark-and-sweep (will collect unless has become reachable; - * prevent running finalizer again if reachable) - */ - DUK_HEAPHDR_SET_FINALIZED(curr); + if (DUK_LIKELY((flags & DUK_MS_FLAG_SKIP_FINALIZERS) == 0)) { + /* Run the finalizer, duk_hobject_run_finalizer() sets FINALIZED. + * Next mark-and-sweep will collect the object unless it has + * become reachable (i.e. rescued). FINALIZED prevents the + * finalizer from being executed again before that. + */ + duk_hobject_run_finalizer(thr, (duk_hobject *) curr); /* must never longjmp */ + DUK_ASSERT(DUK_HEAPHDR_HAS_FINALIZED(curr)); + } else { + /* Used during heap destruction: don't actually run finalizers + * because we're heading into forced finalization. Instead, + * queue finalizable objects back to the heap_allocated list. + */ + DUK_D(DUK_DPRINT("skip finalizers flag set, queue object to heap_allocated without finalizing")); + DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr)); + } /* queue back to heap_allocated */ next = DUK_HEAPHDR_GET_NEXT(heap, curr); @@ -36982,6 +45388,52 @@ DUK_LOCAL void duk__assert_valid_refcounts(duk_heap *heap) { #endif /* DUK_USE_REFERENCE_COUNTING */ #endif /* DUK_USE_ASSERTIONS */ +/* + * Finalizer torture. Do one fake finalizer call which causes side effects + * similar to one or more finalizers on actual objects. + */ + +#if defined(DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE) +DUK_LOCAL duk_ret_t duk__markandsweep_fake_finalizer(duk_context *ctx) { + DUK_D(DUK_DPRINT("fake mark-and-sweep torture finalizer executed")); + + /* Require a lot of stack to force a value stack grow/shrink. + * Recursive mark-and-sweep is prevented by allocation macros + * so this won't trigger another mark-and-sweep. + */ + duk_require_stack(ctx, 100000); + + /* XXX: do something to force a callstack grow/shrink, perhaps + * just a manual forced resize or a forced relocating realloc? + */ + + return 0; +} + +DUK_LOCAL void duk__markandsweep_torture_finalizer(duk_hthread *thr) { + duk_context *ctx; + duk_int_t rc; + + DUK_ASSERT(thr != NULL); + ctx = (duk_context *) thr; + + /* Avoid fake finalization when callstack limit has been reached. + * Otherwise a callstack limit error will be created, then refzero'ed. + */ + if (thr->heap->call_recursion_depth >= thr->heap->call_recursion_limit || + thr->callstack_size + 2 * DUK_CALLSTACK_GROW_STEP >= thr->callstack_max /*approximate*/) { + DUK_D(DUK_DPRINT("call recursion depth reached, avoid fake mark-and-sweep torture finalizer")); + return; + } + + /* Run fake finalizer. Avoid creating unnecessary garbage. */ + duk_push_c_function(ctx, duk__markandsweep_fake_finalizer, 0 /*nargs*/); + rc = duk_pcall(ctx, 0 /*nargs*/); + DUK_UNREF(rc); /* ignored */ + duk_pop(ctx); +} +#endif /* DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE */ + /* * Main mark-and-sweep function. * @@ -37003,6 +45455,9 @@ DUK_INTERNAL duk_bool_t duk_heap_mark_and_sweep(duk_heap *heap, duk_small_uint_t * If we don't have a thread, the entire mark-and-sweep is now * skipped (although we could just skip finalizations). */ + /* XXX: if thr != NULL, the thr may still be in the middle of + * initialization; improve the thread viability test. + */ thr = duk__get_temp_hthread(heap); if (thr == NULL) { DUK_D(DUK_DPRINT("temporary hack: gc skipped because we don't have a temp thread")); @@ -37169,10 +45624,26 @@ DUK_INTERNAL duk_bool_t duk_heap_mark_and_sweep(duk_heap *heap, duk_small_uint_t * already happened, this is probably good enough for now. */ - if (!(flags & DUK_MS_FLAG_NO_FINALIZERS)) { - duk__run_object_finalizers(heap); +#if defined(DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE) + /* Cannot simulate individual finalizers because finalize_list only + * contains objects with actual finalizers. But simulate side effects + * from finalization by doing a bogus function call and resizing the + * stacks. + */ + if (flags & DUK_MS_FLAG_NO_FINALIZERS) { + DUK_D(DUK_DPRINT("skip mark-and-sweep torture finalizer, DUK_MS_FLAG_NO_FINALIZERS is set")); + } else if (!(thr->valstack != NULL && thr->callstack != NULL && thr->catchstack != NULL)) { + DUK_D(DUK_DPRINT("skip mark-and-sweep torture finalizer, thread not yet viable")); } else { + DUK_D(DUK_DPRINT("run mark-and-sweep torture finalizer")); + duk__markandsweep_torture_finalizer(thr); + } +#endif /* DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE */ + + if (flags & DUK_MS_FLAG_NO_FINALIZERS) { DUK_D(DUK_DPRINT("finalizer run skipped because DUK_MS_FLAG_NO_FINALIZERS is set")); + } else { + duk__run_object_finalizers(heap, flags); } /* @@ -37650,14 +46121,35 @@ DUK_INTERNAL void duk_heap_insert_into_heap_allocated(duk_heap *heap, duk_heaphd #ifdef DUK_USE_INTERRUPT_COUNTER DUK_INTERNAL void duk_heap_switch_thread(duk_heap *heap, duk_hthread *new_thr) { - /* Copy currently active interrupt counter from the active thread - * back to the heap structure. It doesn't need to be copied to - * the target thread, as the bytecode executor does that when it - * resumes execution for a new thread. - */ - if (heap->curr_thread != NULL) { - heap->interrupt_counter = heap->curr_thread->interrupt_counter; + duk_hthread *curr_thr; + + DUK_ASSERT(heap != NULL); + + if (new_thr != NULL) { + curr_thr = heap->curr_thread; + if (curr_thr == NULL) { + /* For initial entry use default value; zero forces an + * interrupt before executing the first insturction. + */ + DUK_DD(DUK_DDPRINT("switch thread, initial entry, init default interrupt counter")); + new_thr->interrupt_counter = 0; + new_thr->interrupt_init = 0; + } else { + /* Copy interrupt counter/init value state to new thread (if any). + * It's OK for new_thr to be the same as curr_thr. + */ +#if defined(DUK_USE_DEBUG) + if (new_thr != curr_thr) { + DUK_DD(DUK_DDPRINT("switch thread, not initial entry, copy interrupt counter")); + } +#endif + new_thr->interrupt_counter = curr_thr->interrupt_counter; + new_thr->interrupt_init = curr_thr->interrupt_init; + } + } else { + DUK_DD(DUK_DDPRINT("switch thread, new thread is NULL, no interrupt counter changes")); } + heap->curr_thread = new_thr; /* may be NULL */ } #endif /* DUK_USE_INTERRUPT_COUNTER */ @@ -37771,12 +46263,17 @@ DUK_LOCAL void duk__refcount_finalize_hobject(duk_hthread *thr, duk_hobject *h) duk_hnativefunction *f = (duk_hnativefunction *) h; DUK_UNREF(f); /* nothing to finalize */ + } else if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) { + duk_hbufferobject *b = (duk_hbufferobject *) h; + if (b->buf) { + duk_heaphdr_decref(thr, (duk_heaphdr *) b->buf); + } } else if (DUK_HOBJECT_IS_THREAD(h)) { duk_hthread *t = (duk_hthread *) h; duk_tval *tv; tv = t->valstack; - while (tv < t->valstack_end) { + while (tv < t->valstack_top) { duk_tval_decref(thr, tv); tv++; } @@ -37822,6 +46319,60 @@ DUK_INTERNAL void duk_heaphdr_refcount_finalize(duk_hthread *thr, duk_heaphdr *h } } +#if defined(DUK_USE_REFZERO_FINALIZER_TORTURE) +DUK_LOCAL duk_ret_t duk__refcount_fake_finalizer(duk_context *ctx) { + DUK_UNREF(ctx); + DUK_D(DUK_DPRINT("fake refcount torture finalizer executed")); +#if 0 + DUK_DD(DUK_DDPRINT("fake torture finalizer for: %!T", duk_get_tval(ctx, 0))); +#endif + /* Require a lot of stack to force a value stack grow/shrink. */ + duk_require_stack(ctx, 100000); + + /* XXX: do something to force a callstack grow/shrink, perhaps + * just a manual forced resize? + */ + return 0; +} + +DUK_LOCAL void duk__refcount_run_torture_finalizer(duk_hthread *thr, duk_hobject *obj) { + duk_context *ctx; + duk_int_t rc; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(obj != NULL); + ctx = (duk_context *) thr; + + /* Avoid fake finalization for the duk__refcount_fake_finalizer function + * itself, otherwise we're in infinite recursion. + */ + if (DUK_HOBJECT_HAS_NATIVEFUNCTION(obj)) { + if (((duk_hnativefunction *) obj)->func == duk__refcount_fake_finalizer) { + DUK_DD(DUK_DDPRINT("avoid fake torture finalizer for duk__refcount_fake_finalizer itself")); + return; + } + } + /* Avoid fake finalization when callstack limit has been reached. + * Otherwise a callstack limit error will be created, then refzero'ed, + * and we're in an infinite loop. + */ + if (thr->heap->call_recursion_depth >= thr->heap->call_recursion_limit || + thr->callstack_size + 2 * DUK_CALLSTACK_GROW_STEP >= thr->callstack_max /*approximate*/) { + DUK_D(DUK_DPRINT("call recursion depth reached, avoid fake torture finalizer")); + return; + } + + /* Run fake finalizer. Avoid creating new refzero queue entries + * so that we are not forced into a forever loop. + */ + duk_push_c_function(ctx, duk__refcount_fake_finalizer, 1 /*nargs*/); + duk_push_hobject(ctx, obj); + rc = duk_pcall(ctx, 1); + DUK_UNREF(rc); /* ignored */ + duk_pop(ctx); +} +#endif /* DUK_USE_REFZERO_FINALIZER_TORTURE */ + /* * Refcount memory freeing loop. * @@ -37871,6 +46422,20 @@ DUK_LOCAL void duk__refzero_free_pending(duk_hthread *thr) { DUK_ASSERT(DUK_HEAPHDR_GET_PREV(heap, h1) == NULL); DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(h1) == DUK_HTYPE_OBJECT); /* currently, always the case */ +#if defined(DUK_USE_REFZERO_FINALIZER_TORTURE) + /* Torture option to shake out finalizer side effect issues: + * make a bogus function call for every finalizable object, + * essentially simulating the case where everything has a + * finalizer. + */ + DUK_DD(DUK_DDPRINT("refzero torture enabled, fake finalizer")); + DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(h1) == 0); + DUK_HEAPHDR_PREINC_REFCOUNT(h1); /* bump refcount to prevent refzero during finalizer processing */ + duk__refcount_run_torture_finalizer(thr, obj); /* must never longjmp */ + DUK_HEAPHDR_PREDEC_REFCOUNT(h1); /* remove artificial bump */ + DUK_ASSERT_DISABLE(h1->h_refcount >= 0); /* refcount is unsigned, so always true */ +#endif + /* * Finalizer check. * @@ -37882,10 +46447,9 @@ DUK_LOCAL void duk__refzero_free_pending(duk_hthread *thr) { * objects and must be safe (not throw any errors, ever). */ - /* XXX: If object has FINALIZED, it was finalized by mark-and-sweep on - * its previous run. Any point in running finalizer again here? If - * finalization semantics is changed so that finalizer is only run once, - * checking for FINALIZED would happen here. + /* An object may have FINALIZED here if it was finalized by mark-and-sweep + * on a previous run and refcount then decreased to zero. We won't run the + * finalizer again here. */ /* A finalizer is looked up from the object and up its prototype chain @@ -37898,6 +46462,7 @@ DUK_LOCAL void duk__refzero_free_pending(duk_hthread *thr) { DUK_HEAPHDR_PREINC_REFCOUNT(h1); /* bump refcount to prevent refzero during finalizer processing */ duk_hobject_run_finalizer(thr, obj); /* must never longjmp */ + DUK_ASSERT(DUK_HEAPHDR_HAS_FINALIZED(h1)); /* duk_hobject_run_finalizer() sets */ DUK_HEAPHDR_PREDEC_REFCOUNT(h1); /* remove artificial bump */ DUK_ASSERT_DISABLE(h1->h_refcount >= 0); /* refcount is unsigned, so always true */ @@ -37938,6 +46503,9 @@ DUK_LOCAL void duk__refzero_free_pending(duk_hthread *thr) { if (rescued) { /* yes -> move back to heap allocated */ DUK_DD(DUK_DDPRINT("object rescued during refcount finalization: %p", (void *) h1)); + DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(h1)); + DUK_ASSERT(DUK_HEAPHDR_HAS_FINALIZED(h1)); + DUK_HEAPHDR_CLEAR_FINALIZED(h1); DUK_HEAPHDR_SET_PREV(heap, h1, NULL); DUK_HEAPHDR_SET_NEXT(heap, h1, heap->heap_allocated); heap->heap_allocated = h1; @@ -37991,22 +46559,25 @@ DUK_INTERNAL void duk_heaphdr_refzero(duk_hthread *thr, duk_heaphdr *h) { heap = thr->heap; DUK_DDD(DUK_DDDPRINT("refzero %p: %!O", (void *) h, (duk_heaphdr *) h)); -#ifdef DUK_USE_MARK_AND_SWEEP /* * If mark-and-sweep is running, don't process 'refzero' situations at all. * They may happen because mark-and-sweep needs to finalize refcounts for * each object it sweeps. Otherwise the target objects of swept objects * would have incorrect refcounts. * + * This check must be enabled also when mark-and-sweep support has been + * disabled: the flag is also used in heap destruction when running + * finalizers for remaining objects, and the flag prevents objects from + * being moved around in heap linked lists. + * * Note: mark-and-sweep could use a separate decref handler to avoid coming * here at all. However, mark-and-sweep may also call finalizers, which * can do arbitrary operations and would use this decref variant anyway. */ - if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) { + if (DUK_UNLIKELY(DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap))) { DUK_DDD(DUK_DDDPRINT("refzero handling suppressed when mark-and-sweep running, object: %p", (void *) h)); return; } -#endif switch ((duk_small_int_t) DUK_HEAPHDR_GET_TYPE(h)) { case DUK_HTYPE_STRING: @@ -38203,9 +46774,13 @@ DUK_INTERNAL void duk_heap_strcache_string_remove(duk_heap *heap, duk_hstring *h /* * String scanning helpers + * + * All bytes other than UTF-8 continuation bytes ([0x80,0xbf]) are + * considered to contribute a character. This must match how string + * character length is computed. */ -DUK_LOCAL duk_uint8_t *duk__scan_forwards(duk_uint8_t *p, duk_uint8_t *q, duk_uint_fast32_t n) { +DUK_LOCAL const duk_uint8_t *duk__scan_forwards(const duk_uint8_t *p, const duk_uint8_t *q, duk_uint_fast32_t n) { while (n > 0) { for (;;) { p++; @@ -38221,7 +46796,7 @@ DUK_LOCAL duk_uint8_t *duk__scan_forwards(duk_uint8_t *p, duk_uint8_t *q, duk_ui return p; } -DUK_LOCAL duk_uint8_t *duk__scan_backwards(duk_uint8_t *p, duk_uint8_t *q, duk_uint_fast32_t n) { +DUK_LOCAL const duk_uint8_t *duk__scan_backwards(const duk_uint8_t *p, const duk_uint8_t *q, duk_uint_fast32_t n) { while (n > 0) { for (;;) { p--; @@ -38256,9 +46831,9 @@ DUK_INTERNAL duk_uint_fast32_t duk_heap_strcache_offset_char2byte(duk_hthread *t duk_small_int_t i; duk_bool_t use_cache; duk_uint_fast32_t dist_start, dist_end, dist_sce; - duk_uint8_t *p_start; - duk_uint8_t *p_end; - duk_uint8_t *p_found; + const duk_uint8_t *p_start; + const duk_uint8_t *p_end; + const duk_uint8_t *p_found; if (char_offset > DUK_HSTRING_GET_CHARLEN(h)) { goto error; @@ -38325,8 +46900,8 @@ DUK_INTERNAL duk_uint_fast32_t duk_heap_strcache_offset_char2byte(duk_hthread *t dist_end = DUK_HSTRING_GET_CHARLEN(h) - char_offset; dist_sce = 0; DUK_UNREF(dist_sce); /* initialize for debug prints, needed if sce==NULL */ - p_start = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h); - p_end = (duk_uint8_t *) (p_start + DUK_HSTRING_GET_BYTELEN(h)); + p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h); + p_end = (const duk_uint8_t *) (p_start + DUK_HSTRING_GET_BYTELEN(h)); p_found = NULL; if (sce) { @@ -38437,7 +47012,7 @@ DUK_INTERNAL duk_uint_fast32_t duk_heap_strcache_offset_char2byte(duk_hthread *t tmp = *sce; DUK_MEMMOVE((void *) (&heap->strcache[1]), - (void *) (&heap->strcache[0]), + (const void *) (&heap->strcache[0]), (size_t) (((char *) sce) - ((char *) &heap->strcache[0]))); heap->strcache[0] = tmp; @@ -38712,7 +47287,7 @@ DUK_LOCAL duk_hstring *duk__find_matching_string_chain(duk_heap *heap, const duk duk_hstring *h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.str16); DUK_ASSERT(h != NULL); if (DUK_HSTRING_GET_BYTELEN(h) == blen && - DUK_MEMCMP(str, DUK_HSTRING_GET_DATA(h), blen) == 0) { + DUK_MEMCMP((const void *) str, (const void *) DUK_HSTRING_GET_DATA(h), (size_t) blen) == 0) { return h; } } @@ -38725,7 +47300,7 @@ DUK_LOCAL duk_hstring *duk__find_matching_string_chain(duk_heap *heap, const duk duk_hstring *h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, lst[i]); DUK_ASSERT(h != NULL); if (DUK_HSTRING_GET_BYTELEN(h) == blen && - DUK_MEMCMP(str, DUK_HSTRING_GET_DATA(h), blen) == 0) { + DUK_MEMCMP((const void *) str, (const void *) DUK_HSTRING_GET_DATA(h), (size_t) blen) == 0) { return h; } } @@ -38750,7 +47325,7 @@ DUK_LOCAL duk_hstring *duk__find_matching_string_chain(duk_heap *heap, const duk if (e->listlen == 0) { if (e->u.str != NULL && DUK_HSTRING_GET_BYTELEN(e->u.str) == blen && - DUK_MEMCMP(str, DUK_HSTRING_GET_DATA(e->u.str), blen) == 0) { + DUK_MEMCMP((const void *) str, (const void *) DUK_HSTRING_GET_DATA(e->u.str), (size_t) blen) == 0) { return e->u.str; } } else { @@ -38759,7 +47334,7 @@ DUK_LOCAL duk_hstring *duk__find_matching_string_chain(duk_heap *heap, const duk for (i = 0, n = e->listlen; i < n; i++) { if (lst[i] != NULL && DUK_HSTRING_GET_BYTELEN(lst[i]) == blen && - DUK_MEMCMP(str, DUK_HSTRING_GET_DATA(lst[i]), blen) == 0) { + DUK_MEMCMP((const void *) str, (const void *) DUK_HSTRING_GET_DATA(lst[i]), (size_t) blen) == 0) { return lst[i]; } } @@ -39011,7 +47586,7 @@ DUK_LOCAL duk_hstring *duk__find_matching_string_probe(duk_heap *heap, duk_hstri return NULL; } if (e != DUK__DELETED_MARKER(heap) && DUK_HSTRING_GET_BYTELEN(e) == blen) { - if (DUK_MEMCMP(str, DUK_HSTRING_GET_DATA(e), blen) == 0) { + if (DUK_MEMCMP((const void *) str, (const void *) DUK_HSTRING_GET_DATA(e), (size_t) blen) == 0) { DUK_DDD(DUK_DDDPRINT("find matching hit: %ld (step %ld, size %ld)", (long) i, (long) step, (long) size)); return e; @@ -39436,6 +48011,7 @@ DUK_INTERNAL duk_hstring *duk_heap_string_intern_u32_checked(duk_hthread *thr, d } /* find and remove string from stringtable; caller must free the string itself */ +#if defined(DUK_USE_REFERENCE_COUNTING) DUK_INTERNAL void duk_heap_string_remove(duk_heap *heap, duk_hstring *h) { DUK_DDD(DUK_DDDPRINT("remove string from stringtable: %!O", (duk_heaphdr *) h)); @@ -39454,6 +48030,7 @@ DUK_INTERNAL void duk_heap_string_remove(duk_heap *heap, duk_hstring *h) { #error internal error, invalid strtab options #endif } +#endif #if defined(DUK_USE_MARK_AND_SWEEP) && defined(DUK_USE_MS_STRINGTABLE_RESIZE) DUK_INTERNAL void duk_heap_force_strtab_resize(duk_heap *heap) { @@ -39658,7 +48235,7 @@ DUK_INTERNAL duk_hcompiledfunction *duk_hcompiledfunction_alloc(duk_heap *heap, duk__init_object_parts(heap, &res->obj, hobject_flags); #ifdef DUK_USE_EXPLICIT_NULL_INIT -#ifdef DUK_HEAPPTR16 +#ifdef DUK_USE_HEAPPTR16 /* NULL pointer is required to encode to zero, so memset is enough. */ #else res->data = NULL; @@ -39688,6 +48265,25 @@ DUK_INTERNAL duk_hnativefunction *duk_hnativefunction_alloc(duk_heap *heap, duk_ return res; } +DUK_INTERNAL duk_hbufferobject *duk_hbufferobject_alloc(duk_heap *heap, duk_uint_t hobject_flags) { + duk_hbufferobject *res; + + res = (duk_hbufferobject *) DUK_ALLOC(heap, sizeof(duk_hbufferobject)); + if (!res) { + return NULL; + } + DUK_MEMZERO(res, sizeof(duk_hbufferobject)); + + duk__init_object_parts(heap, &res->obj, hobject_flags); + +#ifdef DUK_USE_EXPLICIT_NULL_INIT + res->buf = NULL; +#endif + + DUK_ASSERT_HBUFFEROBJECT_VALID(res); + return res; +} + /* * Allocate a new thread. * @@ -39708,6 +48304,7 @@ DUK_INTERNAL duk_hthread *duk_hthread_alloc(duk_heap *heap, duk_uint_t hobject_f duk__init_object_parts(heap, &res->obj, hobject_flags); #ifdef DUK_USE_EXPLICIT_NULL_INIT + res->ptr_curr_pc = NULL; res->heap = NULL; res->valstack = NULL; res->valstack_end = NULL; @@ -39717,7 +48314,11 @@ DUK_INTERNAL duk_hthread *duk_hthread_alloc(duk_heap *heap, duk_uint_t hobject_f res->catchstack = NULL; res->resumer = NULL; res->compile_ctx = NULL, +#ifdef DUK_USE_HEAPPTR16 + res->strs16 = NULL; +#else res->strs = NULL; +#endif { int i; for (i = 0; i < DUK_NUM_BUILTINS; i++) { @@ -39772,6 +48373,13 @@ DUK_INTERNAL duk_hobject *duk_hobject_alloc_checked(duk_hthread *thr, duk_uint_t /* must match exactly the number of internal properties inserted to enumerator */ #define DUK__ENUM_START_INDEX 2 +DUK_LOCAL const duk_uint16_t duk__bufferobject_virtual_props[] = { + DUK_STRIDX_LENGTH, + DUK_STRIDX_BYTE_LENGTH, + DUK_STRIDX_BYTE_OFFSET, + DUK_STRIDX_BYTES_PER_ELEMENT +}; + /* * Helper to sort array index keys. The keys are in the enumeration object * entry part, starting from DUK__ENUM_START_INDEX, and the entry part is dense. @@ -39880,7 +48488,7 @@ DUK_LOCAL void duk__sort_array_indices(duk_hthread *thr, duk_hobject *h_obj) { (long) (p_curr - p_insert), (void *) h_curr)); DUK_MEMMOVE((void *) (p_insert + 1), - (void *) p_insert, + (const void *) p_insert, (size_t) ((p_curr - p_insert) * sizeof(duk_hstring *))); *p_insert = h_curr; /* keep val_highest */ @@ -39996,7 +48604,7 @@ DUK_INTERNAL void duk_hobject_enumerator_create(duk_context *ctx, duk_small_uint * * For keys, we simply skip non-string keys which seems to be * consistent with how e.g. Object.keys() will process proxy trap - * results (ES6 draft, Section 19.1.2.14). + * results (ES6, Section 19.1.2.14). */ if (duk_get_prop_index(ctx, -1, i) && duk_is_string(ctx, -1)) { /* [ ... enum_target res trap_result val ] */ @@ -40036,7 +48644,7 @@ DUK_INTERNAL void duk_hobject_enumerator_create(duk_context *ctx, duk_small_uint */ if (DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(curr) || - DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(curr)) { + DUK_HOBJECT_IS_BUFFEROBJECT(curr)) { /* String and buffer enumeration behavior is identical now, * so use shared handler. */ @@ -40046,11 +48654,20 @@ DUK_INTERNAL void duk_hobject_enumerator_create(duk_context *ctx, duk_small_uint DUK_ASSERT(h_val != NULL); /* string objects must not created without internal value */ len = (duk_uint_fast32_t) DUK_HSTRING_GET_CHARLEN(h_val); } else { - duk_hbuffer *h_val; - DUK_ASSERT(DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(curr)); - h_val = duk_hobject_get_internal_value_buffer(thr->heap, curr); - DUK_ASSERT(h_val != NULL); /* buffer objects must not created without internal value */ - len = (duk_uint_fast32_t) DUK_HBUFFER_GET_SIZE(h_val); + duk_hbufferobject *h_bufobj; + DUK_ASSERT(DUK_HOBJECT_IS_BUFFEROBJECT(curr)); + h_bufobj = (duk_hbufferobject *) curr; + if (h_bufobj == NULL) { + /* Neutered buffer, zero length seems + * like good behavior here. + */ + len = 0; + } else { + /* There's intentionally no check for + * current underlying buffer length. + */ + len = (duk_uint_fast32_t) (h_bufobj->length >> h_bufobj->shift); + } } for (i = 0; i < len; i++) { @@ -40067,14 +48684,28 @@ DUK_INTERNAL void duk_hobject_enumerator_create(duk_context *ctx, duk_small_uint /* [enum_target res] */ } - /* 'length' property is not enumerable, but is included if - * non-enumerable properties are requested. + /* 'length' and other virtual properties are not + * enumerable, but are included if non-enumerable + * properties are requested. */ if (enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE) { - duk_push_hstring_stridx(ctx, DUK_STRIDX_LENGTH); - duk_push_true(ctx); - duk_put_prop(ctx, -3); + duk_uint_fast32_t n; + + if (DUK_HOBJECT_IS_BUFFEROBJECT(curr)) { + n = sizeof(duk__bufferobject_virtual_props) / sizeof(duk_uint16_t); + } else { + DUK_ASSERT(DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(curr)); + DUK_ASSERT(duk__bufferobject_virtual_props[0] == DUK_STRIDX_LENGTH); + n = 1; /* only 'length' */ + } + + for (i = 0; i < n; i++) { + duk_push_hstring_stridx(ctx, duk__bufferobject_virtual_props[i]); + duk_push_true(ctx); + duk_put_prop(ctx, -3); + } + } } else if (DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(curr)) { if (enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE) { @@ -40097,7 +48728,7 @@ DUK_INTERNAL void duk_hobject_enumerator_create(duk_context *ctx, duk_small_uint duk_tval *tv; tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, curr, i); - if (DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) { + if (DUK_TVAL_IS_UNUSED(tv)) { continue; } k = duk_heap_string_intern_u32_checked(thr, i); @@ -40137,7 +48768,7 @@ DUK_INTERNAL void duk_hobject_enumerator_create(duk_context *ctx, duk_small_uint } DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, curr, i) || - !DUK_TVAL_IS_UNDEFINED_UNUSED(&DUK_HOBJECT_E_GET_VALUE_PTR(thr->heap, curr, i)->v)); + !DUK_TVAL_IS_UNUSED(&DUK_HOBJECT_E_GET_VALUE_PTR(thr->heap, curr, i)->v)); duk_push_hstring(ctx, k); duk_push_true(ctx); @@ -40254,7 +48885,7 @@ DUK_INTERNAL duk_bool_t duk_hobject_enumerator_next(duk_context *ctx, duk_bool_t k = DUK_HOBJECT_E_GET_KEY(thr->heap, e, idx); DUK_ASSERT(k != NULL); DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, e, idx)); - DUK_ASSERT(!DUK_TVAL_IS_UNDEFINED_UNUSED(&DUK_HOBJECT_E_GET_VALUE(thr->heap, e, idx).v)); + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(&DUK_HOBJECT_E_GET_VALUE(thr->heap, e, idx).v)); idx++; @@ -40363,7 +48994,10 @@ DUK_INTERNAL duk_ret_t duk_hobject_get_enumerated_keys(duk_context *ctx, duk_sma /* include removed: duk_internal.h */ DUK_LOCAL duk_ret_t duk__finalize_helper(duk_context *ctx) { + duk_hthread *thr; + DUK_ASSERT(ctx != NULL); + thr = (duk_hthread *) ctx; DUK_DDD(DUK_DDDPRINT("protected finalization helper running")); @@ -40381,9 +49015,10 @@ DUK_LOCAL duk_ret_t duk__finalize_helper(duk_context *ctx) { DUK_DDD(DUK_DDDPRINT("-> no finalizer or finalizer not callable")); return 0; } - duk_dup(ctx, -2); /* -> [... obj finalizer obj] */ + duk_dup(ctx, -2); + duk_push_boolean(ctx, DUK_HEAP_HAS_FINALIZER_NORESCUE(thr->heap)); DUK_DDD(DUK_DDDPRINT("-> finalizer found, calling finalizer")); - duk_call(ctx, 1); /* -> [... obj retval] */ + duk_call(ctx, 2); /* [ ... obj finalizer obj heapDestruct ] -> [ ... obj retval ] */ DUK_DDD(DUK_DDDPRINT("finalizer finished successfully")); return 0; @@ -40416,6 +49051,20 @@ DUK_INTERNAL void duk_hobject_run_finalizer(duk_hthread *thr, duk_hobject *obj) * may trigger an error (getter may throw one, for instance). */ + if (DUK_HEAPHDR_HAS_FINALIZED((duk_heaphdr *) obj)) { + DUK_D(DUK_DPRINT("object already finalized, avoid running finalizer twice: %!O", obj)); + return; + } + DUK_HEAPHDR_SET_FINALIZED((duk_heaphdr *) obj); /* ensure never re-entered until rescue cycle complete */ + if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj)) { + /* This shouldn't happen; call sites should avoid looking up + * _Finalizer "through" a Proxy, but ignore if we come here + * with a Proxy to avoid finalizer re-entry. + */ + DUK_D(DUK_DPRINT("object is a proxy, skip finalizer call")); + return; + } + /* XXX: use a NULL error handler for the finalizer call? */ DUK_DDD(DUK_DDDPRINT("-> finalizer found, calling wrapped finalize helper")); @@ -40467,7 +49116,7 @@ DUK_INTERNAL duk_bool_t duk_hobject_prototype_chain_contains(duk_hthread *thr, d return 0; } -DUK_INTERNAL void duk_hobject_set_prototype(duk_hthread *thr, duk_hobject *h, duk_hobject *p) { +DUK_INTERNAL void duk_hobject_set_prototype_updref(duk_hthread *thr, duk_hobject *h, duk_hobject *p) { #ifdef DUK_USE_REFERENCE_COUNTING duk_hobject *tmp; @@ -40489,7 +49138,7 @@ DUK_INTERNAL void duk_hobject_set_prototype(duk_hthread *thr, duk_hobject *h, du * * The run-time pc2line data is bit-packed, and documented in: * - * doc/function-objects.txt + * doc/function-objects.rst */ /* include removed: duk_internal.h */ @@ -40522,7 +49171,7 @@ DUK_INTERNAL void duk_hobject_pc2line_pack(duk_hthread *thr, duk_compiler_instr duk_push_dynamic_buffer(ctx, (duk_size_t) curr_offset); h_buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1); DUK_ASSERT(h_buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(h_buf)); + DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(h_buf) && !DUK_HBUFFER_HAS_EXTERNAL(h_buf)); hdr = (duk_uint32_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h_buf); DUK_ASSERT(hdr != NULL); @@ -40531,7 +49180,7 @@ DUK_INTERNAL void duk_hobject_pc2line_pack(duk_hthread *thr, duk_compiler_instr curr_pc = 0U; while (curr_pc < length) { new_size = (duk_size_t) (curr_offset + DUK_PC2LINE_MAX_DIFF_LENGTH); - duk_hbuffer_resize(thr, h_buf, new_size, new_size); + duk_hbuffer_resize(thr, h_buf, new_size); hdr = (duk_uint32_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h_buf); DUK_ASSERT(hdr != NULL); @@ -40598,7 +49247,7 @@ DUK_INTERNAL void duk_hobject_pc2line_pack(duk_hthread *thr, duk_compiler_instr /* compact */ new_size = (duk_size_t) curr_offset; - duk_hbuffer_resize(thr, h_buf, new_size, new_size); + duk_hbuffer_resize(thr, h_buf, new_size); (void) duk_to_fixed_buffer(ctx, -1, NULL); @@ -40623,7 +49272,7 @@ DUK_LOCAL duk_uint_fast32_t duk__hobject_pc2line_query_raw(duk_hthread *thr, duk duk_uint_fast32_t curr_line; DUK_ASSERT(buf != NULL); - DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC((duk_hbuffer *) buf)); + DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC((duk_hbuffer *) buf) && !DUK_HBUFFER_HAS_EXTERNAL((duk_hbuffer *) buf)); DUK_UNREF(thr); /* @@ -40639,7 +49288,7 @@ DUK_LOCAL duk_uint_fast32_t duk__hobject_pc2line_query_raw(duk_hthread *thr, duk goto error; } - hdr = (duk_uint32_t *) DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, buf); + hdr = (duk_uint32_t *) (void *) DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, buf); pc_limit = hdr[0]; if (pc >= pc_limit) { /* Note: pc is unsigned and cannot be negative */ @@ -40722,7 +49371,7 @@ DUK_INTERNAL duk_uint_fast32_t duk_hobject_pc2line_query(duk_context *ctx, duk_i duk_get_prop_stridx(ctx, idx_func, DUK_STRIDX_INT_PC2LINE); pc2line = (duk_hbuffer_fixed *) duk_get_hbuffer(ctx, -1); if (pc2line != NULL) { - DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC((duk_hbuffer *) pc2line)); + DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC((duk_hbuffer *) pc2line) && !DUK_HBUFFER_HAS_EXTERNAL((duk_hbuffer *) pc2line)); line = duk__hobject_pc2line_query_raw((duk_hthread *) ctx, pc2line, (duk_uint_fast32_t) pc); } else { line = 0; @@ -40738,8 +49387,8 @@ DUK_INTERNAL duk_uint_fast32_t duk_hobject_pc2line_query(duk_context *ctx, duk_i * Hobject property set/get functionality. * * This is very central functionality for size, performance, and compliance. - * It is also rather intricate; see hobject-algorithms.txt for discussion on - * the algorithms and memory-management.txt for discussion on refcounts and + * It is also rather intricate; see hobject-algorithms.rst for discussion on + * the algorithms and memory-management.rst for discussion on refcounts and * side effect issues. * * Notes: @@ -40822,6 +49471,7 @@ DUK_LOCAL_DECL duk_bool_t duk__handle_put_array_length(duk_hthread *thr, duk_hob DUK_LOCAL_DECL duk_bool_t duk__get_property_desc(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *out_desc, duk_small_uint_t flags); DUK_LOCAL_DECL duk_bool_t duk__get_own_property_desc_raw(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_uint32_t arr_idx, duk_propdesc *out_desc, duk_small_uint_t flags); DUK_LOCAL_DECL duk_bool_t duk__get_own_property_desc(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *out_desc, duk_small_uint_t flags); +DUK_LOCAL duk_uint32_t duk__get_old_array_length(duk_hthread *thr, duk_hobject *obj, duk_propdesc *temp_desc); /* * Misc helpers @@ -40983,7 +49633,7 @@ DUK_LOCAL void duk__compute_a_stats(duk_hthread *thr, duk_hobject *obj, duk_uint a = DUK_HOBJECT_A_GET_BASE(thr->heap, obj); for (i = 0; i < DUK_HOBJECT_GET_ASIZE(obj); i++) { duk_tval *tv = a++; - if (!DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) { + if (!DUK_TVAL_IS_UNUSED(tv)) { used++; highest_idx = i; } @@ -41092,7 +49742,37 @@ DUK_INTERNAL duk_bool_t duk_hobject_proxy_check(duk_hthread *thr, duk_hobject *o return 1; } -#endif +#endif /* DUK_USE_ES6_PROXY */ + +/* Get Proxy target object. If the argument is not a Proxy, return it as is. + * If a Proxy is revoked, an error is thrown. + */ +#if defined(DUK_USE_ES6_PROXY) +DUK_INTERNAL duk_hobject *duk_hobject_resolve_proxy_target(duk_hthread *thr, duk_hobject *obj) { + duk_hobject *h_target; + duk_hobject *h_handler; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(obj != NULL); + + /* Resolve Proxy targets until Proxy chain ends. No explicit check for + * a Proxy loop: user code cannot create such a loop without tweaking + * internal properties directly. + */ + + while (DUK_UNLIKELY(DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj))) { + if (duk_hobject_proxy_check(thr, obj, &h_target, &h_handler)) { + DUK_ASSERT(h_target != NULL); + obj = h_target; + } else { + break; + } + } + + DUK_ASSERT(obj != NULL); + return obj; +} +#endif /* DUK_USE_ES6_PROXY */ #if defined(DUK_USE_ES6_PROXY) DUK_LOCAL duk_bool_t duk__proxy_check_prop(duk_hthread *thr, duk_hobject *obj, duk_small_uint_t stridx_trap, duk_tval *tv_key, duk_hobject **out_target) { @@ -41307,7 +49987,7 @@ void duk__realloc_props(duk_hthread *thr, #ifdef DUK_USE_MARK_AND_SWEEP prev_mark_and_sweep_base_flags = thr->heap->mark_and_sweep_base_flags; thr->heap->mark_and_sweep_base_flags |= - DUK_MS_FLAG_NO_FINALIZERS | /* avoid attempts to add/remove object keys */ + DUK_MS_FLAG_NO_FINALIZERS | /* avoid attempts to add/remove object keys */ DUK_MS_FLAG_NO_OBJECT_COMPACTION; /* avoid attempt to compact the current object */ #endif @@ -41384,7 +50064,7 @@ void duk__realloc_props(duk_hthread *thr, DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL); tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, i); - if (DUK_TVAL_IS_UNDEFINED_UNUSED(tv1)) { + if (DUK_TVAL_IS_UNUSED(tv1)) { continue; } @@ -41476,7 +50156,7 @@ void duk__realloc_props(duk_hthread *thr, /* fill new entries with -unused- (required, gc reachable) */ for (i = DUK_HOBJECT_GET_ASIZE(obj); i < new_a_size; i++) { duk_tval *tv = &new_a[i]; - DUK_TVAL_SET_UNDEFINED_UNUSED(tv); + DUK_TVAL_SET_UNUSED(tv); } } else { #ifdef DUK_USE_ASSERTIONS @@ -41487,7 +50167,7 @@ void duk__realloc_props(duk_hthread *thr, tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, i); /* current assertion is quite strong: decref's and set to unused */ - DUK_ASSERT(DUK_TVAL_IS_UNDEFINED_UNUSED(tv)); + DUK_ASSERT(DUK_TVAL_IS_UNUSED(tv)); } } #endif @@ -41591,15 +50271,7 @@ void duk__realloc_props(duk_hthread *thr, * so it would be nice to free it forcibly even with only * mark-and-sweep enabled. Not a big issue though. */ - duk_hbuffer_dynamic *buf; - DUK_ASSERT(new_alloc_size > 0); - DUK_ASSERT(duk_is_buffer(ctx, -1)); - buf = (duk_hbuffer_dynamic *) duk_require_hbuffer(ctx, -1); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); - DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(thr->heap, buf); - DUK_HBUFFER_DYNAMIC_SET_SIZE(buf, 0); /* these size resets are not strictly necessary, but nice for consistency */ - DUK_HBUFFER_DYNAMIC_SET_ALLOC_SIZE(buf, 0); + (void) duk_steal_buffer(ctx, -1, NULL); duk_pop(ctx); } else { DUK_ASSERT(new_alloc_size == 0); @@ -41638,7 +50310,7 @@ void duk__realloc_props(duk_hthread *thr, i--; DUK_ASSERT(new_e_k != NULL); DUK_ASSERT(new_e_k[i] != NULL); - DUK_HSTRING_DECREF(thr, new_e_k[i]); + DUK_HSTRING_DECREF(thr, new_e_k[i]); /* side effects */ } #ifdef DUK_USE_MARK_AND_SWEEP @@ -42045,8 +50717,6 @@ DUK_INTERNAL duk_bool_t duk_hobject_get_internal_value(duk_heap *heap, duk_hobje DUK_ASSERT(obj != NULL); DUK_ASSERT(tv_out != NULL); - DUK_TVAL_SET_UNDEFINED_UNUSED(tv_out); - /* always in entry part, no need to look up parents etc */ duk_hobject_find_existing_entry(heap, obj, DUK_HEAP_STRING_INT_VALUE(heap), &e_idx, &h_idx); if (e_idx >= 0) { @@ -42054,6 +50724,7 @@ DUK_INTERNAL duk_bool_t duk_hobject_get_internal_value(duk_heap *heap, duk_hobje DUK_TVAL_SET_TVAL(tv_out, DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap, obj, e_idx)); return 1; } + DUK_TVAL_SET_UNDEFINED(tv_out); return 0; } @@ -42063,6 +50734,11 @@ DUK_INTERNAL duk_hstring *duk_hobject_get_internal_value_string(duk_heap *heap, DUK_ASSERT(heap != NULL); DUK_ASSERT(obj != NULL); + /* This is not strictly necessary, but avoids compiler warnings; e.g. + * gcc won't reliably detect that no uninitialized data is read below. + */ + DUK_MEMZERO((void *) &tv, sizeof(duk_tval)); + if (duk_hobject_get_internal_value(heap, obj, &tv)) { duk_hstring *h; DUK_ASSERT(DUK_TVAL_IS_STRING(&tv)); @@ -42073,22 +50749,6 @@ DUK_INTERNAL duk_hstring *duk_hobject_get_internal_value_string(duk_heap *heap, return NULL; } -DUK_INTERNAL duk_hbuffer *duk_hobject_get_internal_value_buffer(duk_heap *heap, duk_hobject *obj) { - duk_tval tv; - - DUK_ASSERT(heap != NULL); - DUK_ASSERT(obj != NULL); - - if (duk_hobject_get_internal_value(heap, obj, &tv)) { - duk_hbuffer *h; - DUK_ASSERT(DUK_TVAL_IS_BUFFER(&tv)); - h = DUK_TVAL_GET_BUFFER(&tv); - return h; - } - - return NULL; -} - /* * Arguments handling helpers (argument map mainly). * @@ -42339,7 +50999,7 @@ DUK_LOCAL duk_bool_t duk__get_own_property_desc_raw(duk_hthread *thr, duk_hobjec if (DUK_HOBJECT_HAS_ARRAY_PART(obj) && arr_idx != DUK__NO_ARRAY_INDEX) { if (arr_idx < DUK_HOBJECT_GET_ASIZE(obj)) { tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, arr_idx); - if (!DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) { + if (!DUK_TVAL_IS_UNUSED(tv)) { DUK_DDD(DUK_DDDPRINT("-> found in array part")); if (flags & DUK__DESC_FLAG_PUSH_VALUE) { duk_push_tval(ctx, tv); @@ -42436,26 +51096,35 @@ DUK_LOCAL duk_bool_t duk__get_own_property_desc_raw(duk_hthread *thr, duk_hobjec DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj)); return 1; /* cannot be arguments exotic */ } - } else if (DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(obj)) { - DUK_DDD(DUK_DDDPRINT("buffer object exotic property get for key: %!O, arr_idx: %ld", + } else if (DUK_HOBJECT_IS_BUFFEROBJECT(obj)) { + duk_hbufferobject *h_bufobj; + duk_uint_t byte_off; + duk_small_uint_t elem_size; + + h_bufobj = (duk_hbufferobject *) obj; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); + DUK_DDD(DUK_DDDPRINT("bufferobject property get for key: %!O, arr_idx: %ld", (duk_heaphdr *) key, (long) arr_idx)); if (arr_idx != DUK__NO_ARRAY_INDEX) { - duk_hbuffer *h_val; - DUK_DDD(DUK_DDDPRINT("array index exists")); - h_val = duk_hobject_get_internal_value_buffer(thr->heap, obj); - DUK_ASSERT(h_val); - /* SCANBUILD: h_val is known to be non-NULL but scan-build cannot - * know it, so it produces NULL pointer dereference warnings for - * 'h_val'. + /* Careful with wrapping: arr_idx upshift may easily wrap, whereas + * length downshift won't. */ - - if (arr_idx < DUK_HBUFFER_GET_SIZE(h_val)) { - DUK_DDD(DUK_DDDPRINT("-> found, array index inside buffer")); + if (arr_idx < (h_bufobj->length >> h_bufobj->shift)) { + byte_off = arr_idx << h_bufobj->shift; /* no wrap assuming h_bufobj->length is valid */ + elem_size = 1 << h_bufobj->shift; if (flags & DUK__DESC_FLAG_PUSH_VALUE) { - duk_push_int(ctx, ((duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_val))[arr_idx]); + duk_uint8_t *data; + + if (h_bufobj->buf != NULL && DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_bufobj, byte_off + elem_size)) { + data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf) + h_bufobj->offset + byte_off; + duk_hbufferobject_push_validated_read(ctx, h_bufobj, data, elem_size); + } else { + DUK_D(DUK_DPRINT("bufferobject access out of underlying buffer, ignoring (read zero)")); + duk_push_uint(ctx, 0); + } } out_desc->flags = DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_ENUMERABLE | @@ -42468,24 +51137,42 @@ DUK_LOCAL duk_bool_t duk__get_own_property_desc_raw(duk_hthread *thr, duk_hobjec DUK_DDD(DUK_DDDPRINT("array index outside buffer -> normal property")); } } else if (key == DUK_HTHREAD_STRING_LENGTH(thr)) { - duk_hbuffer *h_val; - DUK_DDD(DUK_DDDPRINT("-> found, key is 'length', length exotic behavior")); - /* XXX: buffer length should be writable and have exotic behavior - * like arrays. For now, make it read-only and use explicit methods - * to operate on buffer length. - */ - - h_val = duk_hobject_get_internal_value_buffer(thr->heap, obj); - DUK_ASSERT(h_val != NULL); if (flags & DUK__DESC_FLAG_PUSH_VALUE) { - duk_push_uint(ctx, (duk_uint_t) DUK_HBUFFER_GET_SIZE(h_val)); + /* Length in elements: take into account shift, but + * intentionally don't check the underlying buffer here. + */ + duk_push_uint(ctx, h_bufobj->length >> h_bufobj->shift); } out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL; DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj)); return 1; /* cannot be arguments exotic */ + } else if (key == DUK_HTHREAD_STRING_BYTE_LENGTH(thr)) { + /* If neutered must return 0; length is zeroed during + * neutering. + */ + if (flags & DUK__DESC_FLAG_PUSH_VALUE) { + duk_push_uint(ctx, h_bufobj->length); + } + out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL; + return 1; /* cannot be arguments exotic */ + } else if (key == DUK_HTHREAD_STRING_BYTE_OFFSET(thr)) { + /* If neutered must return 0; offset is zeroed during + * neutering. + */ + if (flags & DUK__DESC_FLAG_PUSH_VALUE) { + duk_push_uint(ctx, h_bufobj->offset); + } + out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL; + return 1; /* cannot be arguments exotic */ + } else if (key == DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr)) { + if (flags & DUK__DESC_FLAG_PUSH_VALUE) { + duk_push_uint(ctx, 1 << h_bufobj->shift); + } + out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL; + return 1; /* cannot be arguments exotic */ } } else if (DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(obj)) { DUK_DDD(DUK_DDDPRINT("duktape/c object exotic property get for key: %!O, arr_idx: %ld", @@ -42661,46 +51348,7 @@ DUK_LOCAL duk_bool_t duk__get_property_desc(duk_hthread *thr, duk_hobject *obj, * standard Array objects. */ -#if 0 /* XXX: unused now */ -DUK_LOCAL duk_tval *duk__shallow_fast_path_array_check_u32(duk_hobject *obj, duk_uint32_t key_idx) { - duk_tval *tv; - - if ((!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj)) && - (!DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(obj)) && - (!DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(obj)) && - (!DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj)) && - (DUK_HOBJECT_HAS_ARRAY_PART(obj)) && - (key_idx < obj->a_size)) { - /* technically required to check, but obj->a_size check covers this */ - DUK_ASSERT(key_idx != 0xffffffffUL); - - DUK_DDD(DUK_DDDPRINT("fast path attempt (key is an array index, no exotic " - "string/arguments/buffer behavior, object has array part, key " - "inside array size)")); - - DUK_ASSERT(obj->a_size > 0); /* true even for key_idx == 0 */ - tv = DUK_HOBJECT_A_GET_VALUE_PTR(obj, key_idx); - if (!DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) { - DUK_DDD(DUK_DDDPRINT("-> fast path successful")); - return tv; - } - - /* - * Not found, fall back to slow path. - * - * Note: this approach has the unfortunate side effect that accesses - * to undefined entries (or entries outside valid array range) cause - * a string intern operation. - */ - - DUK_DDD(DUK_DDDPRINT("fast path attempt failed, fall back to slow path")); - } - - return NULL; -} -#endif - -DUK_LOCAL duk_tval *duk__shallow_fast_path_array_check_tval(duk_hthread *thr, duk_hobject *obj, duk_tval *key_tv) { +DUK_LOCAL duk_tval *duk__getprop_shallow_fastpath_array_tval(duk_hthread *thr, duk_hobject *obj, duk_tval *tv_key) { duk_tval *tv; duk_uint32_t idx; @@ -42709,7 +51357,7 @@ DUK_LOCAL duk_tval *duk__shallow_fast_path_array_check_tval(duk_hthread *thr, du if (!(DUK_HOBJECT_HAS_ARRAY_PART(obj) && !DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj) && !DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(obj) && - !DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(obj) && + !DUK_HOBJECT_IS_BUFFEROBJECT(obj) && !DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj))) { /* Must have array part and no conflicting exotic behaviors. * Doesn't need to have array special behavior, e.g. Arguments @@ -42724,51 +51372,222 @@ DUK_LOCAL duk_tval *duk__shallow_fast_path_array_check_tval(duk_hthread *thr, du "behavior, object has array part)")); #if defined(DUK_USE_FASTINT) - if (DUK_TVAL_IS_FASTINT(key_tv)) { - idx = duk__tval_fastint_to_arr_idx(key_tv); + if (DUK_TVAL_IS_FASTINT(tv_key)) { + idx = duk__tval_fastint_to_arr_idx(tv_key); } else #endif - if (DUK_TVAL_IS_NUMBER(key_tv)) { - idx = duk__tval_number_to_arr_idx(key_tv); + if (DUK_TVAL_IS_DOUBLE(tv_key)) { + idx = duk__tval_number_to_arr_idx(tv_key); } else { DUK_DDD(DUK_DDDPRINT("key is not a number")); return NULL; } - if (idx != DUK__NO_ARRAY_INDEX) { - /* Note: idx is not necessarily a valid array index (0xffffffffUL is not valid) */ - DUK_ASSERT_DISABLE(idx >= 0); /* disabled because idx is duk_uint32_t so always true */ - DUK_ASSERT_DISABLE(idx <= 0xffffffffUL); /* same */ - - if (idx < DUK_HOBJECT_GET_ASIZE(obj)) { - /* technically required to check, but obj->a_size check covers this */ - DUK_ASSERT(idx != 0xffffffffUL); - - /* XXX: for array instances we could take a shortcut here and assume - * Array.prototype doesn't contain an array index property. - */ - - DUK_DDD(DUK_DDDPRINT("key is a valid array index and inside array part")); - tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, idx); - if (!DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) { - DUK_DDD(DUK_DDDPRINT("-> fast path successful")); - return tv; - } - } else { - DUK_DDD(DUK_DDDPRINT("key is outside array part")); - } - } else { - DUK_DDD(DUK_DDDPRINT("key is not a valid array index")); - } - - /* - * Not found in array part, use slow path. + /* If index is not valid, idx will be DUK__NO_ARRAY_INDEX which + * is 0xffffffffUL. We don't need to check for that explicitly + * because 0xffffffffUL will never be inside object 'a_size'. */ + if (idx >= DUK_HOBJECT_GET_ASIZE(obj)) { + DUK_DDD(DUK_DDDPRINT("key is not an array index or outside array part")); + return NULL; + } + DUK_ASSERT(idx != 0xffffffffUL); + DUK_ASSERT(idx != DUK__NO_ARRAY_INDEX); + + /* XXX: for array instances we could take a shortcut here and assume + * Array.prototype doesn't contain an array index property. + */ + + DUK_DDD(DUK_DDDPRINT("key is a valid array index and inside array part")); + tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, idx); + if (!DUK_TVAL_IS_UNUSED(tv)) { + DUK_DDD(DUK_DDDPRINT("-> fast path successful")); + return tv; + } + DUK_DDD(DUK_DDDPRINT("fast path attempt failed, fall back to slow path")); return NULL; } +DUK_LOCAL duk_bool_t duk__putprop_shallow_fastpath_array_tval(duk_hthread *thr, duk_hobject *obj, duk_tval *tv_key, duk_tval *tv_val, duk_propdesc *temp_desc) { + duk_tval *tv; + duk_uint32_t idx; + duk_uint32_t old_len, new_len; + + if (!(DUK_HOBJECT_HAS_EXOTIC_ARRAY(obj) && + DUK_HOBJECT_HAS_ARRAY_PART(obj) && + DUK_HOBJECT_HAS_EXTENSIBLE(obj))) { + return 0; + } + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv_key)) { + idx = duk__tval_fastint_to_arr_idx(tv_key); + } else +#endif + if (DUK_TVAL_IS_DOUBLE(tv_key)) { + idx = duk__tval_number_to_arr_idx(tv_key); + } else { + DUK_DDD(DUK_DDDPRINT("key is not a number")); + return 0; + } + + /* If index is not valid, idx will be DUK__NO_ARRAY_INDEX which + * is 0xffffffffUL. We don't need to check for that explicitly + * because 0xffffffffUL will never be inside object 'a_size'. + */ + + if (idx >= DUK_HOBJECT_GET_ASIZE(obj)) { /* for resizing of array part, use slow path */ + return 0; + } + DUK_ASSERT(idx != 0xffffffffUL); + DUK_ASSERT(idx != DUK__NO_ARRAY_INDEX); + + old_len = duk__get_old_array_length(thr, obj, temp_desc); + + if (idx >= old_len) { + DUK_DDD(DUK_DDDPRINT("write new array entry requires length update " + "(arr_idx=%ld, old_len=%ld)", + (long) idx, (long) old_len)); + if (!(temp_desc->flags & DUK_PROPDESC_FLAG_WRITABLE)) { + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_WRITABLE); + return 0; /* not reachable */ + } + new_len = idx + 1; + + /* No resize has occurred so temp_desc->e_idx is still OK */ + tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, temp_desc->e_idx); + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); +#if defined(DUK_USE_FASTINT) + DUK_TVAL_SET_FASTINT_U32(tv, new_len); /* no need for decref/incref because value is a number */ +#else + DUK_TVAL_SET_NUMBER(tv, (duk_double_t) new_len); /* no need for decref/incref because value is a number */ +#endif + } else { + ; + } + + tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, idx); + DUK_TVAL_SET_TVAL_UPDREF(thr, tv, tv_val); /* side effects */ + + DUK_DDD(DUK_DDDPRINT("array fast path success for index %ld", (long) idx)); + return 1; +} + +/* + * Fast path for bufferobject getprop/putprop + */ + +DUK_LOCAL duk_bool_t duk__getprop_fastpath_bufobj_tval(duk_hthread *thr, duk_hobject *obj, duk_tval *tv_key) { + duk_context *ctx; + duk_uint32_t idx; + duk_hbufferobject *h_bufobj; + duk_uint_t byte_off; + duk_small_uint_t elem_size; + duk_uint8_t *data; + + ctx = (duk_context *) thr; + + if (!DUK_HOBJECT_IS_BUFFEROBJECT(obj)) { + return 0; + } + h_bufobj = (duk_hbufferobject *) obj; + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv_key)) { + idx = duk__tval_fastint_to_arr_idx(tv_key); + } else +#endif + if (DUK_TVAL_IS_DOUBLE(tv_key)) { + idx = duk__tval_number_to_arr_idx(tv_key); + } else { + return 0; + } + + /* If index is not valid, idx will be DUK__NO_ARRAY_INDEX which + * is 0xffffffffUL. We don't need to check for that explicitly + * because 0xffffffffUL will never be inside bufferobject length. + */ + + /* Careful with wrapping (left shifting idx would be unsafe). */ + if (idx >= (h_bufobj->length >> h_bufobj->shift)) { + return 0; + } + DUK_ASSERT(idx != DUK__NO_ARRAY_INDEX); + + byte_off = idx << h_bufobj->shift; /* no wrap assuming h_bufobj->length is valid */ + elem_size = 1 << h_bufobj->shift; + + if (h_bufobj->buf != NULL && DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_bufobj, byte_off + elem_size)) { + data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf) + h_bufobj->offset + byte_off; + duk_hbufferobject_push_validated_read(ctx, h_bufobj, data, elem_size); + } else { + DUK_D(DUK_DPRINT("bufferobject access out of underlying buffer, ignoring (read zero)")); + duk_push_uint(ctx, 0); + } + + return 1; +} + +DUK_LOCAL duk_bool_t duk__putprop_fastpath_bufobj_tval(duk_hthread *thr, duk_hobject *obj, duk_tval *tv_key, duk_tval *tv_val) { + duk_context *ctx; + duk_uint32_t idx; + duk_hbufferobject *h_bufobj; + duk_uint_t byte_off; + duk_small_uint_t elem_size; + duk_uint8_t *data; + + ctx = (duk_context *) thr; + + if (!(DUK_HOBJECT_IS_BUFFEROBJECT(obj) && + DUK_TVAL_IS_NUMBER(tv_val))) { + return 0; + } + h_bufobj = (duk_hbufferobject *) obj; + +#if defined(DUK_USE_FASTINT) + if (DUK_TVAL_IS_FASTINT(tv_key)) { + idx = duk__tval_fastint_to_arr_idx(tv_key); + } else +#endif + if (DUK_TVAL_IS_DOUBLE(tv_key)) { + idx = duk__tval_number_to_arr_idx(tv_key); + } else { + return 0; + } + + /* If index is not valid, idx will be DUK__NO_ARRAY_INDEX which + * is 0xffffffffUL. We don't need to check for that explicitly + * because 0xffffffffUL will never be inside bufferobject length. + */ + + /* Careful with wrapping (left shifting idx would be unsafe). */ + if (idx >= (h_bufobj->length >> h_bufobj->shift)) { + return 0; + } + DUK_ASSERT(idx != DUK__NO_ARRAY_INDEX); + + byte_off = idx << h_bufobj->shift; /* no wrap assuming h_bufobj->length is valid */ + elem_size = 1 << h_bufobj->shift; + + /* Value is required to be a number in the fast path so there + * are no side effects in write coercion. + */ + duk_push_tval(ctx, tv_val); + DUK_ASSERT(duk_is_number(ctx, -1)); + + if (h_bufobj->buf != NULL && DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_bufobj, byte_off + elem_size)) { + data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf) + h_bufobj->offset + byte_off; + duk_hbufferobject_validated_write(ctx, h_bufobj, data, elem_size); + } else { + DUK_D(DUK_DPRINT("bufferobject access out of underlying buffer, ignoring (write skipped)")); + } + + duk_pop(ctx); + return 1; +} + /* * GETPROP: Ecmascript property read. */ @@ -42818,7 +51637,12 @@ DUK_INTERNAL duk_bool_t duk_hobject_getprop(duk_hthread *thr, duk_tval *tv_obj, case DUK_TAG_NULL: { /* Note: unconditional throw */ DUK_DDD(DUK_DDDPRINT("base object is undefined or null -> reject")); +#if defined(DUK_USE_PARANOID_ERRORS) DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_BASE); +#else + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "cannot read property %s of %s", + duk_push_string_tval_readable(ctx, tv_key), duk_push_string_tval_readable(ctx, tv_obj)); +#endif return 0; } @@ -42895,6 +51719,24 @@ DUK_INTERNAL duk_bool_t duk_hobject_getprop(duk_hthread *thr, duk_tval *tv_obj, curr = DUK_TVAL_GET_OBJECT(tv_obj); DUK_ASSERT(curr != NULL); + tmp = duk__getprop_shallow_fastpath_array_tval(thr, curr, tv_key); + if (tmp) { + duk_push_tval(ctx, tmp); + + DUK_DDD(DUK_DDDPRINT("-> %!T (base is object, key is a number, array part " + "fast path)", + (duk_tval *) duk_get_tval(ctx, -1))); + return 1; + } + + if (duk__getprop_fastpath_bufobj_tval(thr, curr, tv_key) != 0) { + /* Read value pushed on stack. */ + DUK_DDD(DUK_DDDPRINT("-> %!T (base is bufobj, key is a number, bufferobject " + "fast path)", + (duk_tval *) duk_get_tval(ctx, -1))); + return 1; + } + #if defined(DUK_USE_ES6_PROXY) if (DUK_UNLIKELY(DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(curr))) { duk_hobject *h_target; @@ -42950,16 +51792,6 @@ DUK_INTERNAL duk_bool_t duk_hobject_getprop(duk_hthread *thr, duk_tval *tv_obj, } #endif /* DUK_USE_ES6_PROXY */ - tmp = duk__shallow_fast_path_array_check_tval(thr, curr, tv_key); - if (tmp) { - duk_push_tval(ctx, tmp); - - DUK_DDD(DUK_DDDPRINT("-> %!T (base is object, key is a number, array part " - "fast path)", - (duk_tval *) duk_get_tval(ctx, -1))); - return 1; - } - if (DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(curr)) { arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key); DUK_ASSERT(key != NULL); @@ -43017,7 +51849,7 @@ DUK_INTERNAL duk_bool_t duk_hobject_getprop(duk_hthread *thr, duk_tval *tv_obj, if (arr_idx != DUK__NO_ARRAY_INDEX && arr_idx < DUK_HBUFFER_GET_SIZE(h)) { duk_pop_n(ctx, pop_count); - duk_push_int(ctx, ((duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h))[arr_idx]); + duk_push_uint(ctx, ((duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h))[arr_idx]); DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is an index inside buffer length " "after coercion -> return byte as number)", @@ -43036,12 +51868,29 @@ DUK_INTERNAL duk_bool_t duk_hobject_getprop(duk_hthread *thr, duk_tval *tv_obj, (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx)); } - if (key == DUK_HTHREAD_STRING_LENGTH(thr)) { + if (key == DUK_HTHREAD_STRING_LENGTH(thr) || + key == DUK_HTHREAD_STRING_BYTE_LENGTH(thr)) { duk_pop(ctx); /* [key] -> [] */ duk_push_uint(ctx, (duk_uint_t) DUK_HBUFFER_GET_SIZE(h)); /* [] -> [res] */ - DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is 'length' after coercion -> " - "return buffer length)", + DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is 'length' or 'byteLength' " + "after coercion -> return buffer length)", + (duk_tval *) duk_get_tval(ctx, -1))); + return 1; + } else if (key == DUK_HTHREAD_STRING_BYTE_OFFSET(thr)) { + duk_pop(ctx); /* [key] -> [] */ + duk_push_uint(ctx, 0); /* [] -> [res] */ + + DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is 'byteOffset' after coercion -> " + "return 0 for consistency with Buffer objects)", + (duk_tval *) duk_get_tval(ctx, -1))); + return 1; + } else if (key == DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr)) { + duk_pop(ctx); /* [key] -> [] */ + duk_push_uint(ctx, 1); /* [] -> [res] */ + + DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is 'BYTES_PER_ELEMENT' after coercion -> " + "return 1 for consistency with Buffer objects)", (duk_tval *) duk_get_tval(ctx, -1))); return 1; } @@ -43085,6 +51934,7 @@ DUK_INTERNAL duk_bool_t duk_hobject_getprop(duk_hthread *thr, duk_tval *tv_obj, default: { /* number */ DUK_DDD(DUK_DDDPRINT("base object is a number, start lookup from number prototype")); + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv_obj)); DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_obj)); curr = thr->builtins[DUK_BIDX_NUMBER_PROTOTYPE]; break; @@ -43480,7 +52330,6 @@ duk_bool_t duk__handle_put_array_length_smaller(duk_hthread *thr, duk_uint32_t arr_idx; duk_hstring *key; duk_tval *tv; - duk_tval tv_tmp; duk_bool_t rc; DUK_DDD(DUK_DDDPRINT("new array length smaller than old (%ld -> %ld), " @@ -43528,9 +52377,7 @@ duk_bool_t duk__handle_put_array_length_smaller(duk_hthread *thr, while (i > new_len) { i--; tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, i); - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_UNDEFINED_UNUSED(tv); - DUK_TVAL_DECREF(thr, &tv_tmp); + DUK_TVAL_SET_UNUSED_UPDREF(thr, tv); /* side effects */ } *out_result_len = new_len; @@ -43830,7 +52677,12 @@ DUK_INTERNAL duk_bool_t duk_hobject_putprop(duk_hthread *thr, duk_tval *tv_obj, /* Note: unconditional throw */ DUK_DDD(DUK_DDDPRINT("base object is undefined or null -> reject (object=%!iT)", (duk_tval *) tv_obj)); +#if defined(DUK_USE_PARANOID_ERRORS) DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_BASE); +#else + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "cannot write property %s of %s", + duk_push_string_tval_readable(ctx, tv_key), duk_push_string_tval_readable(ctx, tv_obj)); +#endif return 0; } @@ -43876,60 +52728,23 @@ DUK_INTERNAL duk_bool_t duk_hobject_putprop(duk_hthread *thr, duk_tval *tv_obj, * the fast path will incorrectly ignore them. * * This fast path could be made compliant by falling through - * to the slow path if the previous value was UNDEFINED_UNUSED. - * This would also remove the need to check for extensibility. - * Right now a non-extensible array is slower than an extensible - * one as far as writes are concerned. + * to the slow path if the previous value was UNUSED. This would + * also remove the need to check for extensibility. Right now a + * non-extensible array is slower than an extensible one as far + * as writes are concerned. * * The fast path behavior is documented in more detail here: - * ecmascript-testcases/test-misc-array-fast-write.js + * tests/ecmascript/test-misc-array-fast-write.js */ - if (DUK_HOBJECT_HAS_EXOTIC_ARRAY(orig) && - DUK_HOBJECT_HAS_ARRAY_PART(orig) && - DUK_HOBJECT_HAS_EXTENSIBLE(orig) && - DUK_TVAL_IS_NUMBER(tv_key)) { - arr_idx = duk__tval_number_to_arr_idx(tv_key); - if (arr_idx != DUK__NO_ARRAY_INDEX && - arr_idx < DUK_HOBJECT_GET_ASIZE(orig)) { /* for resizing of array part, use slow path */ - duk_tval tv_tmp; - duk_uint32_t old_len, new_len; + if (duk__putprop_shallow_fastpath_array_tval(thr, orig, tv_key, tv_val, &desc) != 0) { + DUK_DDD(DUK_DDDPRINT("array fast path success")); + return 1; + } - DUK_ASSERT(arr_idx < DUK_HOBJECT_GET_ASIZE(orig)); - - old_len = duk__get_old_array_length(thr, orig, &desc); - - if (arr_idx >= old_len) { - DUK_DDD(DUK_DDDPRINT("write new array entry requires length update " - "(arr_idx=%ld, old_len=%ld)", - (long) arr_idx, (long) old_len)); - if (!(desc.flags & DUK_PROPDESC_FLAG_WRITABLE)) { - DUK_DD(DUK_DDPRINT("attempt to extend array, but array 'length' is not writable")); - goto fail_not_writable; - } - new_len = arr_idx + 1; - - /* No resize has occurred so desc.e_idx is still OK */ - tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, orig, desc.e_idx); - DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); -#if defined(DUK_USE_FASTINT) - DUK_TVAL_SET_FASTINT_U32(tv, new_len); /* no need for decref/incref because value is a number */ -#else - DUK_TVAL_SET_NUMBER(tv, (duk_double_t) new_len); /* no need for decref/incref because value is a number */ -#endif - } else { - ; - } - - tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, orig, arr_idx); - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_TVAL(tv, tv_val); - DUK_TVAL_INCREF(thr, tv); - DUK_TVAL_DECREF(thr, &tv_tmp); /* note: may trigger gc and props compaction, must be last */ - - DUK_DDD(DUK_DDDPRINT("array fast path success for index %ld", (long) arr_idx)); - return 1; - } + if (duk__putprop_fastpath_bufobj_tval(thr, orig, tv_key, tv_val) != 0) { + DUK_DDD(DUK_DDDPRINT("base is bufobj, key is a number, bufferobject fast path")); + return 1; } #if defined(DUK_USE_ES6_PROXY) @@ -44043,7 +52858,7 @@ DUK_INTERNAL duk_bool_t duk_hobject_putprop(duk_hthread *thr, duk_tval *tv_obj, #endif { duk_push_tval(ctx, tv_val); - data[arr_idx] = (duk_uint8_t) duk_to_int(ctx, -1); + data[arr_idx] = (duk_uint8_t) duk_to_uint32(ctx, -1); pop_count++; } @@ -44063,7 +52878,10 @@ DUK_INTERNAL duk_bool_t duk_hobject_putprop(duk_hthread *thr, duk_tval *tv_obj, (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx)); } - if (key == DUK_HTHREAD_STRING_LENGTH(thr)) { + if (key == DUK_HTHREAD_STRING_LENGTH(thr) || + key == DUK_HTHREAD_STRING_BYTE_LENGTH(thr) || + key == DUK_HTHREAD_STRING_BYTE_OFFSET(thr) || + key == DUK_HTHREAD_STRING_BYTES_PER_ELEMENT(thr)) { goto fail_not_writable; } @@ -44195,23 +53013,41 @@ DUK_INTERNAL duk_bool_t duk_hobject_putprop(duk_hthread *thr, duk_tval *tv_obj, } if (desc.flags & DUK_PROPDESC_FLAG_VIRTUAL) { DUK_DD(DUK_DDPRINT("found existing own (non-inherited) virtual property, property is writable")); - if (DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(curr)) { - duk_hbuffer *h; + if (DUK_HOBJECT_IS_BUFFEROBJECT(curr)) { + duk_hbufferobject *h_bufobj; + duk_uint_t byte_off; + duk_small_uint_t elem_size; + + h_bufobj = (duk_hbufferobject *) curr; + DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj); DUK_DD(DUK_DDPRINT("writable virtual property is in buffer object")); - h = duk_hobject_get_internal_value_buffer(thr->heap, curr); - DUK_ASSERT(h != NULL); - if (arr_idx != DUK__NO_ARRAY_INDEX && - arr_idx < DUK_HBUFFER_GET_SIZE(h)) { + /* Careful with wrapping: arr_idx upshift may easily wrap, whereas + * length downshift won't. + */ + if (arr_idx < (h_bufobj->length >> h_bufobj->shift)) { duk_uint8_t *data; DUK_DDD(DUK_DDDPRINT("writing to buffer data at index %ld", (long) arr_idx)); - data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h); - duk_push_tval(ctx, tv_val); - /* XXX: duk_to_int() ensures we'll get 8 lowest bits as - * as input is within duk_int_t range (capped outside it). + + DUK_ASSERT(arr_idx != DUK__NO_ARRAY_INDEX); /* index/length check guarantees */ + byte_off = arr_idx << h_bufobj->shift; /* no wrap assuming h_bufobj->length is valid */ + elem_size = 1 << h_bufobj->shift; + + /* Coerce to number before validating pointers etc so that the + * number coercions in duk_hbufferobject_validated_write() are + * guaranteed to be side effect free and not invalidate the + * pointer checks we do here. */ - data[arr_idx] = (duk_uint8_t) duk_to_int(ctx, -1); + duk_push_tval(ctx, tv_val); + duk_to_number(ctx, -1); + + if (h_bufobj->buf != NULL && DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h_bufobj, byte_off + elem_size)) { + data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf) + h_bufobj->offset + byte_off; + duk_hbufferobject_validated_write(ctx, h_bufobj, data, elem_size); + } else { + DUK_D(DUK_DPRINT("bufferobject access out of underlying buffer, ignoring (write skipped)")); + } duk_pop(ctx); goto success_no_arguments_exotic; } @@ -44303,14 +53139,9 @@ DUK_INTERNAL duk_bool_t duk_hobject_putprop(duk_hthread *thr, duk_tval *tv_obj, } if (desc.e_idx >= 0) { - duk_tval tv_tmp; - tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, orig, desc.e_idx); DUK_DDD(DUK_DDDPRINT("previous entry value: %!iT", (duk_tval *) tv)); - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_TVAL(tv, tv_val); - DUK_TVAL_INCREF(thr, tv); - DUK_TVAL_DECREF(thr, &tv_tmp); /* note: may trigger gc and props compaction, must be last */ + DUK_TVAL_SET_TVAL_UPDREF(thr, tv, tv_val); /* side effects */ /* don't touch property attributes or hash part */ DUK_DD(DUK_DDPRINT("put to an existing entry at index %ld -> new value %!iT", (long) desc.e_idx, (duk_tval *) tv)); @@ -44319,15 +53150,11 @@ DUK_INTERNAL duk_bool_t duk_hobject_putprop(duk_hthread *thr, duk_tval *tv_obj, * above is pointless for them. The check could be avoided with some * refactoring but is probably not worth it. */ - duk_tval tv_tmp; DUK_ASSERT(desc.a_idx >= 0); tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, orig, desc.a_idx); DUK_DDD(DUK_DDDPRINT("previous array value: %!iT", (duk_tval *) tv)); - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_TVAL(tv, tv_val); - DUK_TVAL_INCREF(thr, tv); - DUK_TVAL_DECREF(thr, &tv_tmp); /* note: may trigger gc and props compaction, must be last */ + DUK_TVAL_SET_TVAL_UPDREF(thr, tv, tv_val); /* side effects */ DUK_DD(DUK_DDPRINT("put to an existing array entry at index %ld -> new value %!iT", (long) desc.a_idx, (duk_tval *) tv)); } @@ -44484,7 +53311,7 @@ DUK_INTERNAL duk_bool_t duk_hobject_putprop(duk_hthread *thr, duk_tval *tv_obj, tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, orig, arr_idx); /* prev value must be unused, no decref */ - DUK_ASSERT(DUK_TVAL_IS_UNDEFINED_UNUSED(tv)); + DUK_ASSERT(DUK_TVAL_IS_UNUSED(tv)); DUK_TVAL_SET_TVAL(tv, tv_val); DUK_TVAL_INCREF(thr, tv); DUK_DD(DUK_DDPRINT("put to new array entry: %ld -> %!T", @@ -44612,7 +53439,12 @@ DUK_INTERNAL duk_bool_t duk_hobject_putprop(duk_hthread *thr, duk_tval *tv_obj, fail_base_primitive: DUK_DDD(DUK_DDDPRINT("result: error, base primitive")); if (throw_flag) { +#if defined(DUK_USE_PARANOID_ERRORS) DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_BASE); +#else + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "cannot write property %s of %s", + duk_push_string_tval_readable(ctx, tv_key), duk_push_string_tval_readable(ctx, tv_obj)); +#endif } duk_pop(ctx); /* remove key */ return 0; @@ -44665,7 +53497,6 @@ DUK_INTERNAL duk_bool_t duk_hobject_putprop(duk_hthread *thr, duk_tval *tv_obj, DUK_INTERNAL duk_bool_t duk_hobject_delprop_raw(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_small_uint_t flags) { duk_propdesc desc; duk_tval *tv; - duk_tval tv_tmp; duk_uint32_t arr_idx; duk_bool_t throw_flag; duk_bool_t force_flag; @@ -44706,9 +53537,7 @@ DUK_INTERNAL duk_bool_t duk_hobject_delprop_raw(duk_hthread *thr, duk_hobject *o DUK_ASSERT(desc.e_idx < 0); tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, desc.a_idx); - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_UNDEFINED_UNUSED(tv); - DUK_TVAL_DECREF(thr, &tv_tmp); + DUK_TVAL_SET_UNUSED_UPDREF(thr, tv); /* side effects */ goto success; } else { DUK_ASSERT(desc.a_idx < 0); @@ -44739,21 +53568,20 @@ DUK_INTERNAL duk_bool_t duk_hobject_delprop_raw(duk_hthread *thr, duk_hobject *o tmp = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, obj, desc.e_idx); DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, desc.e_idx, NULL); DUK_UNREF(tmp); - DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); + DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); /* side effects */ tmp = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, obj, desc.e_idx); DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, desc.e_idx, NULL); DUK_UNREF(tmp); - DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); + DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); /* side effects */ } else { tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, desc.e_idx); - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_UNDEFINED_UNUSED(tv); - DUK_TVAL_DECREF(thr, &tv_tmp); + DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv); /* side effects */ } - /* this is not strictly necessary because if key == NULL, value MUST be ignored */ +#if 0 + /* Not strictly necessary because if key == NULL, flag MUST be ignored. */ DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, desc.e_idx, 0); - DUK_TVAL_SET_UNDEFINED_UNUSED(DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, desc.e_idx)); +#endif /* remove key */ DUK_DDD(DUK_DDDPRINT("before removing key, e_idx %ld, key %p, key at slot %p", @@ -44761,7 +53589,7 @@ DUK_INTERNAL duk_bool_t duk_hobject_delprop_raw(duk_hthread *thr, duk_hobject *o DUK_DDD(DUK_DDDPRINT("removing key at e_idx %ld", (long) desc.e_idx)); DUK_ASSERT(key == DUK_HOBJECT_E_GET_KEY(thr->heap, obj, desc.e_idx)); DUK_HOBJECT_E_SET_KEY(thr->heap, obj, desc.e_idx, NULL); - DUK_HSTRING_DECREF(thr, key); + DUK_HSTRING_DECREF(thr, key); /* side effects */ goto success; } @@ -44978,7 +53806,12 @@ DUK_INTERNAL duk_bool_t duk_hobject_delprop(duk_hthread *thr, duk_tval *tv_obj, fail_invalid_base_uncond: /* Note: unconditional throw */ DUK_ASSERT(duk_get_top(ctx) == entry_top); +#if defined(DUK_USE_PARANOID_ERRORS) DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_BASE); +#else + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "cannot delete property %s of %s", + duk_push_string_tval_readable(ctx, tv_key), duk_push_string_tval_readable(ctx, tv_obj)); +#endif return 0; fail_proxy_rejected: @@ -45020,7 +53853,6 @@ DUK_INTERNAL void duk_hobject_define_property_internal(duk_hthread *thr, duk_hob duk_propdesc desc; duk_uint32_t arr_idx; duk_int_t e_idx; - duk_tval tv_tmp; duk_tval *tv1 = NULL; duk_tval *tv2 = NULL; duk_small_uint_t propflags = flags & DUK_PROPDESC_FLAGS_MASK; /* mask out flags not actually stored */ @@ -45100,7 +53932,7 @@ DUK_INTERNAL void duk_hobject_define_property_internal(duk_hthread *thr, duk_hob DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, e_idx, propflags); tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, e_idx); /* new entry: previous value is garbage; set to undefined to share write_value */ - DUK_TVAL_SET_UNDEFINED_ACTUAL(tv1); + DUK_TVAL_SET_UNDEFINED(tv1); goto write_value; write_value: @@ -45110,10 +53942,7 @@ DUK_INTERNAL void duk_hobject_define_property_internal(duk_hthread *thr, duk_hob DUK_DDD(DUK_DDDPRINT("writing/updating value: %!T -> %!T", (duk_tval *) tv1, (duk_tval *) tv2)); - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_TVAL(tv1, tv2); - DUK_TVAL_INCREF(thr, tv1); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_TVAL_UPDREF(thr, tv1, tv2); /* side effects */ goto pop_exit; pop_exit: @@ -45139,7 +53968,6 @@ DUK_INTERNAL void duk_hobject_define_property_internal_arridx(duk_hthread *thr, duk_context *ctx = (duk_context *) thr; duk_hstring *key; duk_tval *tv1, *tv2; - duk_tval tv_tmp; DUK_DDD(DUK_DDDPRINT("define new property (internal) arr_idx fast path: thr=%p, obj=%!O, " "arr_idx=%ld, flags=0x%02lx, val=%!T", @@ -45166,10 +53994,7 @@ DUK_INTERNAL void duk_hobject_define_property_internal_arridx(duk_hthread *thr, tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, arr_idx); tv2 = duk_require_tval(ctx, -1); - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_TVAL(tv1, tv2); - DUK_TVAL_INCREF(thr, tv1); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_TVAL_UPDREF(thr, tv1, tv2); /* side effects */ duk_pop(ctx); /* [ ...val ] -> [ ... ] */ return; @@ -45750,7 +54575,7 @@ void duk_hobject_define_property_helper(duk_context *ctx, duk_tval *tv_tmp = duk_require_tval(ctx, idx_value); DUK_TVAL_SET_TVAL(&tv, tv_tmp); } else { - DUK_TVAL_SET_UNDEFINED_ACTUAL(&tv); /* default value */ + DUK_TVAL_SET_UNDEFINED(&tv); /* default value */ } if (arr_idx != DUK__NO_ARRAY_INDEX && DUK_HOBJECT_HAS_ARRAY_PART(obj)) { @@ -45920,7 +54745,6 @@ void duk_hobject_define_property_helper(duk_context *ctx, } } else { duk_bool_t rc; - duk_tval tv_tmp; duk_tval *tv1; /* curr is data, desc is accessor */ @@ -45942,9 +54766,8 @@ void duk_hobject_define_property_helper(duk_context *ctx, DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx)); tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx); - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_UNDEFINED_UNUSED(tv1); - DUK_TVAL_DECREF(thr, &tv_tmp); + /* XXX: just decref */ + DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv1); /* side effects */ DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, curr.e_idx, NULL); DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, curr.e_idx, NULL); @@ -45985,13 +54808,13 @@ void duk_hobject_define_property_helper(duk_context *ctx, tmp = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, obj, curr.e_idx); DUK_UNREF(tmp); DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, curr.e_idx, NULL); - DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); + DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); /* side effects */ tmp = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, obj, curr.e_idx); DUK_UNREF(tmp); DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, curr.e_idx, NULL); - DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); + DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); /* side effects */ - DUK_TVAL_SET_UNDEFINED_ACTUAL(DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx)); + DUK_TVAL_SET_UNDEFINED(DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx)); DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE(thr->heap, obj, curr.e_idx); DUK_HOBJECT_E_SLOT_CLEAR_ACCESSOR(thr->heap, obj, curr.e_idx); @@ -46077,7 +54900,6 @@ void duk_hobject_define_property_helper(duk_context *ctx, if (new_flags == DUK_PROPDESC_FLAGS_WEC) { duk_tval *tv1, *tv2; - duk_tval tv_tmp; DUK_DDD(DUK_DDDPRINT("array index, new property attributes match array defaults, update in-place")); @@ -46087,10 +54909,7 @@ void duk_hobject_define_property_helper(duk_context *ctx, tv2 = duk_require_tval(ctx, idx_value); tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, curr.a_idx); - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_TVAL(tv1, tv2); - DUK_TVAL_INCREF(thr, tv1); - DUK_TVAL_DECREF(thr, &tv_tmp); + DUK_TVAL_SET_TVAL_UPDREF(thr, tv1, tv2); /* side effects */ goto success_exotics; } @@ -46121,7 +54940,7 @@ void duk_hobject_define_property_helper(duk_context *ctx, DUK_UNREF(tmp); DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, curr.e_idx, set); DUK_HOBJECT_INCREF_ALLOWNULL(thr, set); - DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); + DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); /* side effects */ } if (has_get) { duk_hobject *tmp; @@ -46133,21 +54952,17 @@ void duk_hobject_define_property_helper(duk_context *ctx, DUK_UNREF(tmp); DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, curr.e_idx, get); DUK_HOBJECT_INCREF_ALLOWNULL(thr, get); - DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); + DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); /* side effects */ } if (has_value) { duk_tval *tv1, *tv2; - duk_tval tv_tmp; DUK_DDD(DUK_DDDPRINT("update existing property value")); DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx)); tv2 = duk_require_tval(ctx, idx_value); tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx); - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_TVAL(tv1, tv2); - DUK_TVAL_INCREF(thr, tv1); - DUK_TVAL_DECREF(thr, &tv_tmp); + DUK_TVAL_SET_TVAL_UPDREF(thr, tv1, tv2); /* side effects */ } /* @@ -46465,7 +55280,7 @@ DUK_INTERNAL duk_bool_t duk_hobject_object_is_sealed_frozen_helper(duk_hthread * */ for (i = 0; i < DUK_HOBJECT_GET_ASIZE(obj); i++) { duk_tval *tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, i); - if (!DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) { + if (!DUK_TVAL_IS_UNUSED(tv)) { return 0; } } @@ -46516,7 +55331,8 @@ DUK_INTERNAL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr, duk p_end = p_start + DUK_HSTRING_GET_BYTELEN(h); p = p_start + boff; DUK_DDD(DUK_DDDPRINT("p_start=%p, p_end=%p, p=%p", - (void *) p_start, (void *) p_end, (void *) p)); + (const void *) p_start, (const void *) p_end, + (const void *) p)); /* This may throw an error though not for valid E5 strings. */ cp = duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end); @@ -46556,11 +55372,14 @@ DUK_INTERNAL duk_bool_t duk_hthread_init_stacks(duk_heap *heap, duk_hthread *thr } DUK_MEMZERO(thr->valstack, alloc_size); thr->valstack_end = thr->valstack + DUK_VALSTACK_INITIAL_SIZE; +#if !defined(DUK_USE_PREFER_SIZE) + thr->valstack_size = DUK_VALSTACK_INITIAL_SIZE; +#endif thr->valstack_bottom = thr->valstack; thr->valstack_top = thr->valstack; for (i = 0; i < DUK_VALSTACK_INITIAL_SIZE; i++) { - DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->valstack[i]); + DUK_TVAL_SET_UNDEFINED(&thr->valstack[i]); } /* callstack */ @@ -46629,7 +55448,7 @@ DUK_INTERNAL void *duk_hthread_get_catchstack_ptr(duk_heap *heap, void *ud) { */ #define DUK__CLASS_BITS 5 -#define DUK__BIDX_BITS 6 +#define DUK__BIDX_BITS 7 #define DUK__STRIDX_BITS 9 /* XXX: try to optimize to 8 */ #define DUK__NATIDX_BITS 8 #define DUK__NUM_NORMAL_PROPS_BITS 6 @@ -46644,7 +55463,7 @@ DUK_INTERNAL void *duk_hthread_get_catchstack_ptr(duk_heap *heap, void *ud) { #define DUK__NARGS_VARARGS_MARKER 0x07 #define DUK__NO_CLASS_MARKER 0x00 /* 0 = DUK_HOBJECT_CLASS_UNUSED */ -#define DUK__NO_BIDX_MARKER 0x3f +#define DUK__NO_BIDX_MARKER 0x7f #define DUK__NO_STRIDX_MARKER 0xff #define DUK__PROP_TYPE_DOUBLE 0 @@ -46948,9 +55767,6 @@ DUK_INTERNAL void duk_hthread_create_builtin_objects(duk_hthread *thr) { duk_c_function c_func_getter; duk_c_function c_func_setter; - /* XXX: this is a bit awkward because there is no exposed helper - * in the API style, only this internal helper. - */ DUK_DDD(DUK_DDDPRINT("built-in accessor property: objidx=%ld, stridx=%ld, getteridx=%ld, setteridx=%ld, flags=0x%04lx", (long) i, (long) stridx, (long) natidx_getter, (long) natidx_setter, (unsigned long) prop_flags)); @@ -46959,7 +55775,7 @@ DUK_INTERNAL void duk_hthread_create_builtin_objects(duk_hthread *thr) { duk_push_c_function_noconstruct_noexotic(ctx, c_func_getter, 0); /* always 0 args */ duk_push_c_function_noconstruct_noexotic(ctx, c_func_setter, 1); /* always 1 arg */ - /* XXX: magic for getter/setter? */ + /* XXX: magic for getter/setter? use duk_def_prop()? */ prop_flags |= DUK_PROPDESC_FLAG_ACCESSOR; /* accessor flag not encoded explicitly */ duk_hobject_define_accessor_internal(thr, @@ -47154,9 +55970,6 @@ DUK_INTERNAL void duk_hthread_create_builtin_objects(duk_hthread *thr) { "m" #else "?" -#endif -#if defined(DUK_USE_BYTEORDER_FORCED) - "f" #endif " " /* Packed or unpacked tval */ @@ -47220,12 +56033,14 @@ DUK_INTERNAL void duk_hthread_create_builtin_objects(duk_hthread *thr) { #endif " " /* Alignment guarantee */ -#if defined(DUK_USE_ALIGN_4) +#if (DUK_USE_ALIGN_BY == 4) "a4" -#elif defined(DUK_USE_ALIGN_8) +#elif (DUK_USE_ALIGN_BY == 8) "a8" -#else +#elif (DUK_USE_ALIGN_BY == 1) "a1" +#else +#error invalid DUK_USE_ALIGN_BY #endif " " /* Architecture, OS, and compiler strings */ @@ -47335,6 +56150,70 @@ DUK_INTERNAL duk_activation *duk_hthread_get_current_activation(duk_hthread *thr return NULL; } } + +#if defined(DUK_USE_DEBUGGER_SUPPORT) +DUK_INTERNAL duk_uint_fast32_t duk_hthread_get_act_curr_pc(duk_hthread *thr, duk_activation *act) { + duk_instr_t *bcode; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(act != NULL); + DUK_UNREF(thr); + + /* XXX: store 'bcode' pointer to activation for faster lookup? */ + if (act->func && DUK_HOBJECT_IS_COMPILEDFUNCTION(act->func)) { + bcode = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) (act->func)); + return (duk_uint_fast32_t) (act->curr_pc - bcode); + } + return 0; +} +#endif /* DUK_USE_DEBUGGER_SUPPORT */ + +DUK_INTERNAL duk_uint_fast32_t duk_hthread_get_act_prev_pc(duk_hthread *thr, duk_activation *act) { + duk_instr_t *bcode; + duk_uint_fast32_t ret; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(act != NULL); + DUK_UNREF(thr); + + if (act->func && DUK_HOBJECT_IS_COMPILEDFUNCTION(act->func)) { + bcode = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) (act->func)); + ret = (duk_uint_fast32_t) (act->curr_pc - bcode); + if (ret > 0) { + ret--; + } + return ret; + } + return 0; +} + +/* Write bytecode executor's curr_pc back to topmost activation (if any). */ +DUK_INTERNAL void duk_hthread_sync_currpc(duk_hthread *thr) { + duk_activation *act; + + DUK_ASSERT(thr != NULL); + + if (thr->ptr_curr_pc != NULL) { + /* ptr_curr_pc != NULL only when bytecode executor is active. */ + DUK_ASSERT(thr->callstack_top > 0); + act = thr->callstack + thr->callstack_top - 1; + act->curr_pc = *thr->ptr_curr_pc; + } +} + +DUK_INTERNAL void duk_hthread_sync_and_null_currpc(duk_hthread *thr) { + duk_activation *act; + + DUK_ASSERT(thr != NULL); + + if (thr->ptr_curr_pc != NULL) { + /* ptr_curr_pc != NULL only when bytecode executor is active. */ + DUK_ASSERT(thr->callstack_top > 0); + act = thr->callstack + thr->callstack_top - 1; + act->curr_pc = *thr->ptr_curr_pc; + thr->ptr_curr_pc = NULL; + } +} #line 1 "duk_hthread_stacks.c" /* * Manipulation of thread stacks (valstack, callstack, catchstack). @@ -47816,30 +56695,122 @@ DUK_INTERNAL void duk_hthread_catchstack_unwind(duk_hthread *thr, duk_size_t new /* * Call handling. * - * The main work horse functions are: - * - duk_handle_call(): call to a C/Ecmascript functions - * - duk_handle_safe_call(): make a protected C call within current activation - * - duk_handle_ecma_call_setup(): Ecmascript-to-Ecmascript calls, including - * tail calls and coroutine resume + * Main functions are: + * + * - duk_handle_call_unprotected(): unprotected call to Ecmascript or + * Duktape/C function + * - duk_handle_call_protected(): protected call to Ecmascript or + * Duktape/C function + * - duk_handle_safe_call(): make a protected C call within current + * activation + * - duk_handle_ecma_call_setup(): Ecmascript-to-Ecmascript calls + * (not always possible), including tail calls and coroutine resume + * + * See 'execution.rst'. + * + * Note: setjmp() and local variables have a nasty interaction, + * see execution.rst; non-volatile locals modified after setjmp() + * call are not guaranteed to keep their value. */ /* include removed: duk_internal.h */ /* - * Arguments object creation. - * - * Creating arguments objects is a bit finicky, see E5 Section 10.6 for the - * specific requirements. Much of the arguments object exotic behavior is - * implemented in duk_hobject_props.c, and is enabled by the object flag - * DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS. + * Forward declarations. */ -DUK_LOCAL -void duk__create_arguments_object(duk_hthread *thr, - duk_hobject *func, - duk_hobject *varenv, - duk_idx_t idx_argbase, /* idx of first argument on stack */ - duk_idx_t num_stack_args) { /* num args starting from idx_argbase */ +DUK_LOCAL void duk__handle_call_inner(duk_hthread *thr, + duk_idx_t num_stack_args, + duk_small_uint_t call_flags, + duk_idx_t idx_func); +DUK_LOCAL void duk__handle_call_error(duk_hthread *thr, + duk_size_t entry_valstack_bottom_index, + duk_size_t entry_valstack_end, + duk_size_t entry_catchstack_top, + duk_size_t entry_callstack_top, + duk_int_t entry_call_recursion_depth, + duk_hthread *entry_curr_thread, + duk_uint_fast8_t entry_thread_state, + duk_instr_t **entry_ptr_curr_pc, + duk_idx_t idx_func +#if !defined(DUK_USE_CPP_EXCEPTIONS) + , duk_jmpbuf *old_jmpbuf_ptr +#endif + ); +DUK_LOCAL void duk__handle_safe_call_inner(duk_hthread *thr, + duk_safe_call_function func, + duk_idx_t idx_retbase, + duk_idx_t num_stack_rets, + duk_size_t entry_valstack_bottom_index, + duk_size_t entry_callstack_top, + duk_size_t entry_catchstack_top); +DUK_LOCAL void duk__handle_safe_call_error(duk_hthread *thr, + duk_idx_t idx_retbase, + duk_idx_t num_stack_rets, + duk_size_t entry_valstack_bottom_index, + duk_size_t entry_callstack_top, + duk_size_t entry_catchstack_top +#if !defined(DUK_USE_CPP_EXCEPTIONS) + , duk_jmpbuf *old_jmpbuf_ptr +#endif + ); +DUK_LOCAL void duk__handle_safe_call_shared(duk_hthread *thr, + duk_idx_t idx_retbase, + duk_idx_t num_stack_rets, + duk_int_t entry_call_recursion_depth, + duk_hthread *entry_curr_thread, + duk_uint_fast8_t entry_thread_state, + duk_instr_t **entry_ptr_curr_pc); + +/* + * Interrupt counter fixup (for development only). + */ + +#if defined(DUK_USE_INTERRUPT_COUNTER) && defined(DUK_USE_DEBUG) +DUK_LOCAL void duk__interrupt_fixup(duk_hthread *thr, duk_hthread *entry_curr_thread) { + /* Currently the bytecode executor and executor interrupt + * instruction counts are off because we don't execute the + * interrupt handler when we're about to exit from the initial + * user call into Duktape. + * + * If we were to execute the interrupt handler here, the counts + * would match. You can enable this block manually to check + * that this is the case. + */ + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); + +#if defined(DUK_USE_INTERRUPT_DEBUG_FIXUP) + if (entry_curr_thread == NULL) { + thr->interrupt_init = thr->interrupt_init - thr->interrupt_counter; + thr->heap->inst_count_interrupt += thr->interrupt_init; + DUK_DD(DUK_DDPRINT("debug test: updated interrupt count on exit to " + "user code, instruction counts: executor=%ld, interrupt=%ld", + (long) thr->heap->inst_count_exec, (long) thr->heap->inst_count_interrupt)); + DUK_ASSERT(thr->heap->inst_count_exec == thr->heap->inst_count_interrupt); + } +#else + DUK_UNREF(thr); + DUK_UNREF(entry_curr_thread); +#endif +} +#endif + +/* + * Arguments object creation. + * + * Creating arguments objects involves many small details, see E5 Section + * 10.6 for the specific requirements. Much of the arguments object exotic + * behavior is implemented in duk_hobject_props.c, and is enabled by the + * object flag DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS. + */ + +DUK_LOCAL void duk__create_arguments_object(duk_hthread *thr, + duk_hobject *func, + duk_hobject *varenv, + duk_idx_t idx_argbase, /* idx of first argument on stack */ + duk_idx_t num_stack_args) { /* num args starting from idx_argbase */ duk_context *ctx = (duk_context *) thr; duk_hobject *arg; /* 'arguments' */ duk_hobject *formals; /* formals for 'func' (may be NULL if func is a C function) */ @@ -47918,7 +56889,7 @@ void duk__create_arguments_object(duk_hthread *thr, -1); /* no prototype */ DUK_ASSERT(i_mappednames >= 0); - /* [... formals arguments map mappedNames] */ + /* [ ... formals arguments map mappedNames ] */ DUK_DDD(DUK_DDDPRINT("created arguments related objects: " "arguments at index %ld -> %!O " @@ -47960,14 +56931,14 @@ void duk__create_arguments_object(duk_hthread *thr, duk_get_prop_index(ctx, i_formals, idx); DUK_ASSERT(duk_is_string(ctx, -1)); - duk_dup(ctx, -1); /* [... name name] */ + duk_dup(ctx, -1); /* [ ... name name ] */ if (!duk_has_prop(ctx, i_mappednames)) { /* steps 11.c.ii.1 - 11.c.ii.4, but our internal book-keeping * differs from the reference model */ - /* [... name] */ + /* [ ... name ] */ need_map = 1; @@ -47988,7 +56959,7 @@ void duk__create_arguments_object(duk_hthread *thr, /* duk_has_prop() popped the second 'name' */ } - /* [... name] */ + /* [ ... name ] */ duk_pop(ctx); /* pop 'name' */ } @@ -48022,18 +56993,17 @@ void duk__create_arguments_object(duk_hthread *thr, /* steps 13-14 */ if (DUK_HOBJECT_HAS_STRICT(func)) { - /* - * Note: callee/caller are throwers and are not deletable etc. - * They could be implemented as virtual properties, but currently - * there is no support for virtual properties which are accessors - * (only plain virtual properties). This would not be difficult - * to change in duk_hobject_props, but we can make the throwers - * normal, concrete properties just as easily. + /* Callee/caller are throwers and are not deletable etc. They + * could be implemented as virtual properties, but currently + * there is no support for virtual properties which are accessors + * (only plain virtual properties). This would not be difficult + * to change in duk_hobject_props, but we can make the throwers + * normal, concrete properties just as easily. * - * Note that the specification requires that the *same* thrower - * built-in object is used here! See E5 Section 10.6 main - * algoritm, step 14, and Section 13.2.3 which describes the - * thrower. See test case test-arguments-throwers.js. + * Note that the specification requires that the *same* thrower + * built-in object is used here! See E5 Section 10.6 main + * algoritm, step 14, and Section 13.2.3 which describes the + * thrower. See test case test-arguments-throwers.js. */ DUK_DDD(DUK_DDDPRINT("strict function, setting caller/callee to throwers")); @@ -48048,15 +57018,14 @@ void duk__create_arguments_object(duk_hthread *thr, /* set exotic behavior only after we're done */ if (need_map) { - /* - * Note: exotic behaviors are only enabled for arguments - * objects which have a parameter map (see E5 Section 10.6 - * main algorithm, step 12). + /* Exotic behaviors are only enabled for arguments objects + * which have a parameter map (see E5 Section 10.6 main + * algorithm, step 12). * - * In particular, a non-strict arguments object with no - * mapped formals does *NOT* get exotic behavior, even - * for e.g. "caller" property. This seems counterintuitive - * but seems to be the case. + * In particular, a non-strict arguments object with no + * mapped formals does *NOT* get exotic behavior, even + * for e.g. "caller" property. This seems counterintuitive + * but seems to be the case. */ /* cannot be strict (never mapped variables) */ @@ -48068,7 +57037,6 @@ void duk__create_arguments_object(duk_hthread *thr, DUK_DDD(DUK_DDDPRINT("not enabling exotic behavior for arguments object")); } - /* nice log */ DUK_DDD(DUK_DDDPRINT("final arguments related objects: " "arguments at index %ld -> %!O " "map at index %ld -> %!O " @@ -48077,20 +57045,22 @@ void duk__create_arguments_object(duk_hthread *thr, (long) i_map, (duk_heaphdr *) duk_get_hobject(ctx, i_map), (long) i_mappednames, (duk_heaphdr *) duk_get_hobject(ctx, i_mappednames))); - /* [args(n) [crud] formals arguments map mappednames] -> [args [crud] arguments] */ + /* [ args(n) [crud] formals arguments map mappednames ] */ + duk_pop_2(ctx); duk_remove(ctx, -2); + + /* [ args [crud] arguments ] */ } /* Helper for creating the arguments object and adding it to the env record * on top of the value stack. This helper has a very strict dependency on * the shape of the input stack. */ -DUK_LOCAL -void duk__handle_createargs_for_call(duk_hthread *thr, - duk_hobject *func, - duk_hobject *env, - duk_idx_t num_stack_args) { +DUK_LOCAL void duk__handle_createargs_for_call(duk_hthread *thr, + duk_hobject *func, + duk_hobject *env, + duk_idx_t num_stack_args) { duk_context *ctx = (duk_context *) thr; DUK_DDD(DUK_DDDPRINT("creating arguments object for function call")); @@ -48101,7 +57071,7 @@ void duk__handle_createargs_for_call(duk_hthread *thr, DUK_ASSERT(DUK_HOBJECT_HAS_CREATEARGS(func)); DUK_ASSERT(duk_get_top(ctx) >= num_stack_args + 1); - /* [... arg1 ... argN envobj] */ + /* [ ... arg1 ... argN envobj ] */ duk__create_arguments_object(thr, func, @@ -48109,14 +57079,14 @@ void duk__handle_createargs_for_call(duk_hthread *thr, duk_get_top(ctx) - num_stack_args - 1, /* idx_argbase */ num_stack_args); - /* [... arg1 ... argN envobj argobj] */ + /* [ ... arg1 ... argN envobj argobj ] */ duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LC_ARGUMENTS, DUK_HOBJECT_HAS_STRICT(func) ? DUK_PROPDESC_FLAGS_E : /* strict: non-deletable, non-writable */ DUK_PROPDESC_FLAGS_WE); /* non-strict: non-deletable, writable */ - /* [... arg1 ... argN envobj] */ + /* [ ... arg1 ... argN envobj ] */ } /* @@ -48133,11 +57103,10 @@ void duk__handle_createargs_for_call(duk_hthread *thr, * function. This would make call time handling much easier. */ -DUK_LOCAL -void duk__handle_bound_chain_for_call(duk_hthread *thr, - duk_idx_t idx_func, - duk_idx_t *p_num_stack_args, /* may be changed by call */ - duk_bool_t is_constructor_call) { +DUK_LOCAL void duk__handle_bound_chain_for_call(duk_hthread *thr, + duk_idx_t idx_func, + duk_idx_t *p_num_stack_args, /* may be changed by call */ + duk_bool_t is_constructor_call) { duk_context *ctx = (duk_context *) thr; duk_idx_t num_stack_args; duk_tval *tv_func; @@ -48188,7 +57157,7 @@ void duk__handle_bound_chain_for_call(duk_hthread *thr, /* [ ... func this arg1 ... argN ] */ if (is_constructor_call) { - /* See: ecmascript-testcases/test-spec-bound-constructor.js */ + /* See: tests/ecmascript/test-spec-bound-constructor.js */ DUK_DDD(DUK_DDDPRINT("constructor call: don't update this binding")); } else { duk_get_prop_stridx(ctx, idx_func, DUK_STRIDX_INT_THIS); @@ -48230,7 +57199,7 @@ void duk__handle_bound_chain_for_call(duk_hthread *thr, DUK_DDD(DUK_DDDPRINT("final non-bound function is: %!T", duk_get_tval(ctx, idx_func))); -#ifdef DUK_USE_ASSERTIONS +#if defined(DUK_USE_ASSERTIONS) tv_func = duk_require_tval(ctx, idx_func); DUK_ASSERT(DUK_TVAL_IS_LIGHTFUNC(tv_func) || DUK_TVAL_IS_OBJECT(tv_func)); if (DUK_TVAL_IS_OBJECT(tv_func)) { @@ -48251,10 +57220,9 @@ void duk__handle_bound_chain_for_call(duk_hthread *thr, * assuming it does NOT have the DUK_HOBJECT_FLAG_NEWENV flag. */ -DUK_LOCAL -void duk__handle_oldenv_for_call(duk_hthread *thr, - duk_hobject *func, - duk_activation *act) { +DUK_LOCAL void duk__handle_oldenv_for_call(duk_hthread *thr, + duk_hobject *func, + duk_activation *act) { duk_tval *tv; DUK_ASSERT(thr != NULL); @@ -48290,7 +57258,7 @@ void duk__handle_oldenv_for_call(duk_hthread *thr, * Helper for updating callee 'caller' property. */ -#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY +#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY) DUK_LOCAL void duk__update_func_caller_prop(duk_hthread *thr, duk_hobject *func) { duk_tval *tv_caller; duk_hobject *h_tmp; @@ -48310,6 +57278,8 @@ DUK_LOCAL void duk__update_func_caller_prop(duk_hthread *thr, duk_hobject *func) act_callee = thr->callstack + thr->callstack_top - 1; act_caller = (thr->callstack_top >= 2 ? act_callee - 1 : NULL); + /* XXX: check .caller writability? */ + /* Backup 'caller' property and update its value. */ tv_caller = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_CALLER(thr)); if (tv_caller) { @@ -48392,49 +57362,49 @@ DUK_LOCAL void duk__update_func_caller_prop(duk_hthread *thr, duk_hobject *func) * side effects, because ToObject() may be called. */ -DUK_LOCAL -void duk__coerce_effective_this_binding(duk_hthread *thr, - duk_hobject *func, - duk_idx_t idx_this) { +DUK_LOCAL void duk__coerce_effective_this_binding(duk_hthread *thr, + duk_hobject *func, + duk_idx_t idx_this) { duk_context *ctx = (duk_context *) thr; - duk_small_int_t strict; + duk_tval *tv_this; + duk_hobject *obj_global; - if (func) { - strict = DUK_HOBJECT_HAS_STRICT(func); - } else { + if (func == NULL || DUK_HOBJECT_HAS_STRICT(func)) { /* Lightfuncs are always considered strict. */ - strict = 1; + DUK_DDD(DUK_DDDPRINT("this binding: strict -> use directly")); + return; } - if (strict) { - DUK_DDD(DUK_DDDPRINT("this binding: strict -> use directly")); - } else { - duk_tval *tv_this = duk_require_tval(ctx, idx_this); - duk_hobject *obj_global; - - if (DUK_TVAL_IS_OBJECT(tv_this)) { - DUK_DDD(DUK_DDDPRINT("this binding: non-strict, object -> use directly")); - } else if (DUK_TVAL_IS_LIGHTFUNC(tv_this)) { - /* Lightfuncs are treated like objects and not coerced. */ - DUK_DDD(DUK_DDDPRINT("this binding: non-strict, lightfunc -> use directly")); - } else if (DUK_TVAL_IS_UNDEFINED(tv_this) || DUK_TVAL_IS_NULL(tv_this)) { - DUK_DDD(DUK_DDDPRINT("this binding: non-strict, undefined/null -> use global object")); - obj_global = thr->builtins[DUK_BIDX_GLOBAL]; - if (obj_global) { - duk_push_hobject(ctx, obj_global); - } else { - /* - * This may only happen if built-ins are being "torn down". - * This behavior is out of specification scope. - */ - DUK_D(DUK_DPRINT("this binding: wanted to use global object, but it is NULL -> using undefined instead")); - duk_push_undefined(ctx); - } - duk_replace(ctx, idx_this); + /* XXX: byte offset */ + tv_this = thr->valstack_bottom + idx_this; + switch (DUK_TVAL_GET_TAG(tv_this)) { + case DUK_TAG_OBJECT: + case DUK_TAG_LIGHTFUNC: /* lightfuncs are treated like objects and not coerced */ + DUK_DDD(DUK_DDDPRINT("this binding: non-strict, object -> use directly")); + break; + case DUK_TAG_UNDEFINED: + case DUK_TAG_NULL: + DUK_DDD(DUK_DDDPRINT("this binding: non-strict, undefined/null -> use global object")); + obj_global = thr->builtins[DUK_BIDX_GLOBAL]; + /* XXX: avoid this check somehow */ + if (DUK_LIKELY(obj_global != NULL)) { + DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_this)); /* no need to decref previous value */ + DUK_TVAL_SET_OBJECT(tv_this, obj_global); + DUK_HOBJECT_INCREF(thr, obj_global); } else { - DUK_DDD(DUK_DDDPRINT("this binding: non-strict, not object/undefined/null -> use ToObject(value)")); - duk_to_object(ctx, idx_this); /* may have side effects */ + /* This may only happen if built-ins are being "torn down". + * This behavior is out of specification scope. + */ + DUK_D(DUK_DPRINT("this binding: wanted to use global object, but it is NULL -> using undefined instead")); + DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_this)); /* no need to decref previous value */ + DUK_TVAL_SET_UNDEFINED(tv_this); /* nothing to incref */ } + break; + default: + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv_this)); + DUK_DDD(DUK_DDDPRINT("this binding: non-strict, not object/undefined/null -> use ToObject(value)")); + duk_to_object(ctx, idx_this); /* may have side effects */ + break; } } @@ -48444,12 +57414,11 @@ void duk__coerce_effective_this_binding(duk_hthread *thr, * Returns duk_hobject * to the final non-bound function (NULL for lightfunc). */ -DUK_LOCAL -duk_hobject *duk__nonbound_func_lookup(duk_context *ctx, - duk_idx_t idx_func, - duk_idx_t *out_num_stack_args, - duk_tval **out_tv_func, - duk_small_uint_t call_flags) { +DUK_LOCAL duk_hobject *duk__nonbound_func_lookup(duk_context *ctx, + duk_idx_t idx_func, + duk_idx_t *out_num_stack_args, + duk_tval **out_tv_func, + duk_small_uint_t call_flags) { duk_hthread *thr = (duk_hthread *) ctx; duk_tval *tv_func; duk_hobject *func; @@ -48494,25 +57463,34 @@ duk_hobject *duk__nonbound_func_lookup(duk_context *ctx, return func; not_callable_error: + DUK_ASSERT(tv_func != NULL); +#if defined(DUK_USE_PARANOID_ERRORS) DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_CALLABLE); +#else + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "%s not callable", duk_push_string_tval_readable(ctx, tv_func)); +#endif DUK_UNREACHABLE(); return NULL; /* never executed */ } /* - * Value stack resize and stack top adjustment helper + * Value stack resize and stack top adjustment helper. * * XXX: This should all be merged to duk_valstack_resize_raw(). */ -DUK_LOCAL -void duk__adjust_valstack_and_top(duk_hthread *thr, duk_idx_t num_stack_args, duk_idx_t idx_args, duk_idx_t nregs, duk_idx_t nargs, duk_hobject *func) { +DUK_LOCAL void duk__adjust_valstack_and_top(duk_hthread *thr, + duk_idx_t num_stack_args, + duk_idx_t idx_args, + duk_idx_t nregs, + duk_idx_t nargs, + duk_hobject *func) { duk_context *ctx = (duk_context *) thr; duk_size_t vs_min_size; duk_bool_t adjusted_top = 0; - vs_min_size = (thr->valstack_bottom - thr->valstack) + /* bottom of current func */ - idx_args; /* bottom of new func */ + vs_min_size = (thr->valstack_bottom - thr->valstack) + /* bottom of current func */ + idx_args; /* bottom of new func */ if (nregs >= 0) { DUK_ASSERT(nargs >= 0); @@ -48523,15 +57501,17 @@ void duk__adjust_valstack_and_top(duk_hthread *thr, duk_idx_t num_stack_args, du vs_min_size += num_stack_args; /* num entries of new func at entry */ } if (func == NULL || DUK_HOBJECT_IS_NATIVEFUNCTION(func)) { - vs_min_size += DUK_VALSTACK_API_ENTRY_MINIMUM; /* Duktape/C API guaranteed entries (on top of args) */ + vs_min_size += DUK_VALSTACK_API_ENTRY_MINIMUM; /* Duktape/C API guaranteed entries (on top of args) */ } - vs_min_size += DUK_VALSTACK_INTERNAL_EXTRA; /* + spare */ + vs_min_size += DUK_VALSTACK_INTERNAL_EXTRA; /* + spare */ - /* XXX: Awkward fix for GH-107: we can't resize the value stack to - * a size smaller than the current top, so the order of the resize - * and adjusting the stack top depends on the current vs. final size - * of the value stack. Ideally duk_valstack_resize_raw() would have - * a combined algorithm to avoid this. + /* XXX: We can't resize the value stack to a size smaller than the + * current top, so the order of the resize and adjusting the stack + * top depends on the current vs. final size of the value stack. + * The operations could be combined to avoid this, but the proper + * fix is to only grow the value stack on a function call, and only + * shrink it (without throwing if the shrink fails) on function + * return. */ if (vs_min_size < (duk_size_t) (thr->valstack_top - thr->valstack)) { @@ -48558,811 +57538,6 @@ void duk__adjust_valstack_and_top(duk_hthread *thr, duk_idx_t num_stack_args, du } } -/* - * Helper for making various kinds of calls. - * - * Call flags: - * - * DUK_CALL_FLAG_PROTECTED <--> protected call - * DUK_CALL_FLAG_IGNORE_RECLIMIT <--> ignore C recursion limit, - * for errhandler calls - * DUK_CALL_FLAG_CONSTRUCTOR_CALL <--> for 'new Foo()' calls - * - * Input stack: - * - * [ func this arg1 ... argN ] - * - * Output stack: - * - * [ retval ] (DUK_EXEC_SUCCESS) - * [ errobj ] (DUK_EXEC_ERROR (normal error), protected call) - * - * Even when executing a protected call an error may be thrown in rare cases. - * For instance, if we run out of memory when setting up the return stack - * after a caught error, the out of memory is propagated to the caller. - * Similarly, API errors (such as invalid input stack shape and invalid - * indices) cause an error to propagate out of this function. If there is - * no catchpoint for this error, the fatal error handler is called. - * - * See 'execution.txt'. - * - * The allowed thread states for making a call are: - * - thr matches heap->curr_thread, and thr is already RUNNING - * - thr does not match heap->curr_thread (may be NULL or other), - * and thr is INACTIVE (in this case, a setjmp() catchpoint is - * always used for thread book-keeping to work properly) - * - * Like elsewhere, gotos are used to keep indent level minimal and - * avoiding a dozen helpers with awkward plumbing. - * - * Note: setjmp() and local variables have a nasty interaction, - * see execution.txt; non-volatile locals modified after setjmp() - * call are not guaranteed to keep their value. - */ - -DUK_INTERNAL -duk_int_t duk_handle_call(duk_hthread *thr, - duk_idx_t num_stack_args, - duk_small_uint_t call_flags) { - duk_context *ctx = (duk_context *) thr; - duk_size_t entry_valstack_bottom_index; - duk_size_t entry_valstack_end; - duk_size_t entry_callstack_top; - duk_size_t entry_catchstack_top; - duk_int_t entry_call_recursion_depth; - duk_hthread *entry_curr_thread; - duk_uint_fast8_t entry_thread_state; - volatile duk_bool_t need_setjmp; - duk_jmpbuf * volatile old_jmpbuf_ptr = NULL; /* ptr is volatile (not the target) */ - duk_idx_t idx_func; /* valstack index of 'func' and retval (relative to entry valstack_bottom) */ - duk_idx_t idx_args; /* valstack index of start of args (arg1) (relative to entry valstack_bottom) */ - duk_idx_t nargs; /* # argument registers target function wants (< 0 => "as is") */ - duk_idx_t nregs; /* # total registers target function wants on entry (< 0 => "as is") */ - duk_hobject *func; /* 'func' on stack (borrowed reference) */ - duk_tval *tv_func; /* duk_tval ptr for 'func' on stack (borrowed reference) or tv_func_copy */ - duk_tval tv_func_copy; /* to avoid relookups */ - duk_activation *act; - duk_hobject *env; - duk_jmpbuf our_jmpbuf; - duk_tval tv_tmp; - duk_int_t retval = DUK_EXEC_ERROR; - duk_ret_t rc; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT(ctx != NULL); - DUK_ASSERT(num_stack_args >= 0); - - /* XXX: currently NULL allocations are not supported; remove if later allowed */ - DUK_ASSERT(thr->valstack != NULL); - DUK_ASSERT(thr->callstack != NULL); - DUK_ASSERT(thr->catchstack != NULL); - - /* - * Preliminaries, required by setjmp() handler. - * - * Must be careful not to throw an unintended error here. - * - * Note: careful with indices like '-x'; if 'x' is zero, it - * refers to valstack_bottom. - */ - - entry_valstack_bottom_index = (duk_size_t) (thr->valstack_bottom - thr->valstack); - entry_valstack_end = (duk_size_t) (thr->valstack_end - thr->valstack); - entry_callstack_top = thr->callstack_top; - entry_catchstack_top = thr->catchstack_top; - entry_call_recursion_depth = thr->heap->call_recursion_depth; - entry_curr_thread = thr->heap->curr_thread; /* Note: may be NULL if first call */ - entry_thread_state = thr->state; - idx_func = duk_normalize_index(ctx, -num_stack_args - 2); /* idx_func must be valid, note: non-throwing! */ - idx_args = idx_func + 2; /* idx_args is not necessarily valid if num_stack_args == 0 (idx_args then equals top) */ - - /* Need a setjmp() catchpoint if a protected call OR if we need to - * do mandatory cleanup. - */ - need_setjmp = ((call_flags & DUK_CALL_FLAG_PROTECTED) != 0) || (thr->heap->curr_thread != thr); - - DUK_DD(DUK_DDPRINT("duk_handle_call: thr=%p, num_stack_args=%ld, " - "call_flags=0x%08lx (protected=%ld, ignorerec=%ld, constructor=%ld), need_setjmp=%ld, " - "valstack_top=%ld, idx_func=%ld, idx_args=%ld, rec_depth=%ld/%ld, " - "entry_valstack_bottom_index=%ld, entry_callstack_top=%ld, entry_catchstack_top=%ld, " - "entry_call_recursion_depth=%ld, entry_curr_thread=%p, entry_thread_state=%ld", - (void *) thr, - (long) num_stack_args, - (unsigned long) call_flags, - (long) ((call_flags & DUK_CALL_FLAG_PROTECTED) != 0 ? 1 : 0), - (long) ((call_flags & DUK_CALL_FLAG_IGNORE_RECLIMIT) != 0 ? 1 : 0), - (long) ((call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL) != 0 ? 1 : 0), - (long) need_setjmp, - (long) duk_get_top(ctx), - (long) idx_func, - (long) idx_args, - (long) thr->heap->call_recursion_depth, - (long) thr->heap->call_recursion_limit, - (long) entry_valstack_bottom_index, - (long) entry_callstack_top, - (long) entry_catchstack_top, - (long) entry_call_recursion_depth, - (void *) entry_curr_thread, - (long) entry_thread_state)); - - /* XXX: Multiple tv_func lookups are now avoided by making a local - * copy of tv_func. Another approach would be to compute an offset - * for tv_func from valstack bottom and recomputing the tv_func - * pointer quickly as valstack + offset instead of calling duk_get_tval(). - */ - - if (idx_func < 0 || idx_args < 0) { - /* - * Since stack indices are not reliable, we can't do anything useful - * here. Invoke the existing setjmp catcher, or if it doesn't exist, - * call the fatal error handler. - */ - - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); - } - - /* - * Setup a setjmp() catchpoint first because even the call setup - * may fail. - */ - - if (!need_setjmp) { - DUK_DDD(DUK_DDDPRINT("don't need a setjmp catchpoint")); - goto handle_call; - } - - old_jmpbuf_ptr = thr->heap->lj.jmpbuf_ptr; - thr->heap->lj.jmpbuf_ptr = &our_jmpbuf; - - if (DUK_SETJMP(thr->heap->lj.jmpbuf_ptr->jb) == 0) { - DUK_DDD(DUK_DDDPRINT("setjmp catchpoint setup complete")); - goto handle_call; - } - - /* - * Error during setup, call, or postprocessing of the call. - * The error value is in heap->lj.value1. - * - * Note: any local variables accessed here must have their value - * assigned *before* the setjmp() call, OR they must be declared - * volatile. Otherwise their value is not guaranteed to be correct. - * - * The following are such variables: - * - duk_handle_call() parameters - * - entry_* - * - idx_func - * - idx_args - * - * The very first thing we do is restore the previous setjmp catcher. - * This means that any error in error handling will propagate outwards - * instead of causing a setjmp() re-entry above. The *only* actual - * errors that should happen here are allocation errors. - */ - - DUK_DDD(DUK_DDDPRINT("error caught during protected duk_handle_call(): %!T", - (duk_tval *) &thr->heap->lj.value1)); - - DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_THROW); - DUK_ASSERT(thr->callstack_top >= entry_callstack_top); - DUK_ASSERT(thr->catchstack_top >= entry_catchstack_top); - - /* - * Restore previous setjmp catchpoint - */ - - /* Note: either pointer may be NULL (at entry), so don't assert */ - DUK_DDD(DUK_DDDPRINT("restore jmpbuf_ptr: %p -> %p", - (void *) (thr && thr->heap ? thr->heap->lj.jmpbuf_ptr : NULL), - (void *) old_jmpbuf_ptr)); - - thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr; - - if (!(call_flags & DUK_CALL_FLAG_PROTECTED)) { - /* - * Caller did not request a protected call but a setjmp - * catchpoint was set up to allow cleanup. So, clean up - * and rethrow. - * - * We must restore curr_thread here to ensure that its - * current value doesn't end up pointing to a thread object - * which has been freed. This is now a problem because some - * call sites (namely duk_safe_call()) *first* unwind stacks - * and only then deal with curr_thread. If those call sites - * were fixed, this wouldn't matter here. - * - * Note: this case happens e.g. when heap->curr_thread is - * NULL on entry. - */ - - DUK_DDD(DUK_DDDPRINT("call is not protected -> clean up and rethrow")); - - DUK_HEAP_SWITCH_THREAD(thr->heap, entry_curr_thread); /* may be NULL */ - thr->state = entry_thread_state; - DUK_ASSERT((thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread == NULL) || /* first call */ - (thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread != NULL) || /* other call */ - (thr->state == DUK_HTHREAD_STATE_RUNNING && thr->heap->curr_thread == thr)); /* current thread */ - - /* XXX: should setjmp catcher be responsible for this instead? */ - thr->heap->call_recursion_depth = entry_call_recursion_depth; - duk_err_longjmp(thr); - DUK_UNREACHABLE(); - } - - duk_hthread_catchstack_unwind(thr, entry_catchstack_top); - duk_hthread_callstack_unwind(thr, entry_callstack_top); - thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index; - - /* [ ... func this (crud) errobj ] */ - - /* XXX: is there space? better implementation: write directly over - * 'func' slot to avoid valstack grow issues. - */ - duk_push_tval(ctx, &thr->heap->lj.value1); - - /* [ ... func this (crud) errobj ] */ - - duk_replace(ctx, idx_func); - duk_set_top(ctx, idx_func + 1); - - /* [ ... errobj ] */ - - /* Ensure there is internal valstack spare before we exit; this may - * throw an alloc error. The same guaranteed size must be available - * as before the call. This is not optimal now: we store the valstack - * allocated size during entry; this value may be higher than the - * minimal guarantee for an application. - */ - - (void) duk_valstack_resize_raw((duk_context *) thr, - entry_valstack_end, /* same as during entry */ - DUK_VSRESIZE_FLAG_SHRINK | /* flags */ - DUK_VSRESIZE_FLAG_COMPACT | - DUK_VSRESIZE_FLAG_THROW); - - /* Note: currently a second setjmp restoration is done at the target; - * this is OK, but could be refactored away. - */ - retval = DUK_EXEC_ERROR; - goto shrink_and_finished; - - handle_call: - /* - * Thread state check and book-keeping. - */ - - if (thr == thr->heap->curr_thread) { - /* same thread */ - if (thr->state != DUK_HTHREAD_STATE_RUNNING) { - /* should actually never happen, but check anyway */ - goto thread_state_error; - } - } else { - /* different thread */ - DUK_ASSERT(thr->heap->curr_thread == NULL || - thr->heap->curr_thread->state == DUK_HTHREAD_STATE_RUNNING); - if (thr->state != DUK_HTHREAD_STATE_INACTIVE) { - goto thread_state_error; - } - DUK_HEAP_SWITCH_THREAD(thr->heap, thr); - thr->state = DUK_HTHREAD_STATE_RUNNING; - - /* Note: multiple threads may be simultaneously in the RUNNING - * state, but not in the same "resume chain". - */ - } - - DUK_ASSERT(thr->heap->curr_thread == thr); - DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING); - - /* - * C call recursion depth check, which provides a reasonable upper - * bound on maximum C stack size (arbitrary C stack growth is only - * possible by recursive handle_call / handle_safe_call calls). - */ - - DUK_ASSERT(thr->heap->call_recursion_depth >= 0); - DUK_ASSERT(thr->heap->call_recursion_depth <= thr->heap->call_recursion_limit); - - if (call_flags & DUK_CALL_FLAG_IGNORE_RECLIMIT) { - DUK_DD(DUK_DDPRINT("ignoring reclimit for this call (probably an errhandler call)")); - } else { - if (thr->heap->call_recursion_depth >= thr->heap->call_recursion_limit) { - /* XXX: error message is a bit misleading: we reached a recursion - * limit which is also essentially the same as a C callstack limit - * (except perhaps with some relaxed threading assumptions). - */ - DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_C_CALLSTACK_LIMIT); - } - thr->heap->call_recursion_depth++; - } - - /* - * Check the function type, handle bound function chains, and prepare - * parameters for the rest of the call handling. Also figure out the - * effective 'this' binding, which replaces the current value at - * idx_func + 1. - * - * If the target function is a 'bound' one, follow the chain of 'bound' - * functions until a non-bound function is found. During this process, - * bound arguments are 'prepended' to existing ones, and the "this" - * binding is overridden. See E5 Section 15.3.4.5.1. - * - * Lightfunc detection happens here too. Note that lightweight functions - * can be wrapped by (non-lightweight) bound functions so we must resolve - * the bound function chain first. - */ - - func = duk__nonbound_func_lookup(ctx, idx_func, &num_stack_args, &tv_func, call_flags); - DUK_TVAL_SET_TVAL(&tv_func_copy, tv_func); - tv_func = &tv_func_copy; /* local copy to avoid relookups */ - - DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func)); - DUK_ASSERT(func == NULL || (DUK_HOBJECT_IS_COMPILEDFUNCTION(func) || - DUK_HOBJECT_IS_NATIVEFUNCTION(func))); - - duk__coerce_effective_this_binding(thr, func, idx_func + 1); - DUK_DDD(DUK_DDDPRINT("effective 'this' binding is: %!T", - (duk_tval *) duk_get_tval(ctx, idx_func + 1))); - - /* These base values are never used, but if the compiler doesn't know - * that DUK_ERROR() won't return, these are needed to silence warnings. - * On the other hand, scan-build will warn about the values not being - * used, so add a DUK_UNREF. - */ - nargs = 0; DUK_UNREF(nargs); - nregs = 0; DUK_UNREF(nregs); - - if (func == NULL) { - duk_small_uint_t lf_flags; - - DUK_DDD(DUK_DDDPRINT("lightfunc call handling")); - DUK_ASSERT(DUK_TVAL_IS_LIGHTFUNC(tv_func)); - lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv_func); - nargs = DUK_LFUNC_FLAGS_GET_NARGS(lf_flags); - if (nargs == DUK_LFUNC_NARGS_VARARGS) { - nargs = -1; /* vararg */ - } - nregs = nargs; - } else if (DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) { - nargs = ((duk_hcompiledfunction *) func)->nargs; - nregs = ((duk_hcompiledfunction *) func)->nregs; - DUK_ASSERT(nregs >= nargs); - } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(func)) { - /* Note: nargs (and nregs) may be negative for a native, - * function, which indicates that the function wants the - * input stack "as is" (i.e. handles "vararg" arguments). - */ - nargs = ((duk_hnativefunction *) func)->nargs; - nregs = nargs; - } else { - /* XXX: this should be an assert */ - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_CALLABLE); - } - - /* [ ... func this arg1 ... argN ] */ - - /* - * Setup a preliminary activation. - * - * Don't touch valstack_bottom or valstack_top yet so that Duktape API - * calls work normally. - */ - - duk_hthread_callstack_grow(thr); - - if (thr->callstack_top > 0) { - /* - * Update idx_retval of current activation. - * - * Although it might seem this is not necessary (bytecode executor - * does this for Ecmascript-to-Ecmascript calls; other calls are - * handled here), this turns out to be necessary for handling yield - * and resume. For them, an Ecmascript-to-native call happens, and - * the Ecmascript call's idx_retval must be set for things to work. - */ - - (thr->callstack + thr->callstack_top - 1)->idx_retval = entry_valstack_bottom_index + idx_func; - } - - DUK_ASSERT(thr->callstack_top < thr->callstack_size); - act = thr->callstack + thr->callstack_top; - thr->callstack_top++; - DUK_ASSERT(thr->callstack_top <= thr->callstack_size); - DUK_ASSERT(thr->valstack_top > thr->valstack_bottom); /* at least effective 'this' */ - DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func)); - - act->flags = 0; - if (func == NULL || DUK_HOBJECT_HAS_STRICT(func)) { - act->flags |= DUK_ACT_FLAG_STRICT; - } - if (call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL) { - act->flags |= DUK_ACT_FLAG_CONSTRUCT; - /*act->flags |= DUK_ACT_FLAG_PREVENT_YIELD;*/ - } - if (func == NULL || DUK_HOBJECT_IS_NATIVEFUNCTION(func)) { - /*act->flags |= DUK_ACT_FLAG_PREVENT_YIELD;*/ - } - if (call_flags & DUK_CALL_FLAG_DIRECT_EVAL) { - act->flags |= DUK_ACT_FLAG_DIRECT_EVAL; - } - - /* As a first approximation, all calls except Ecmascript-to-Ecmascript - * calls prevent a yield. - */ - act->flags |= DUK_ACT_FLAG_PREVENT_YIELD; - - act->func = func; /* NULL for lightfunc */ - act->var_env = NULL; - act->lex_env = NULL; -#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY - act->prev_caller = NULL; -#endif - act->pc = 0; -#if defined(DUK_USE_DEBUGGER_SUPPORT) - act->prev_line = 0; -#endif - act->idx_bottom = entry_valstack_bottom_index + idx_args; -#if 0 /* topmost activation idx_retval is considered garbage, no need to init */ - act->idx_retval = 0; -#endif - DUK_TVAL_SET_TVAL(&act->tv_func, tv_func); /* borrowed, no refcount */ - - if (act->flags & DUK_ACT_FLAG_PREVENT_YIELD) { - /* duk_hthread_callstack_unwind() will decrease this on unwind */ - thr->callstack_preventcount++; - } - - /* XXX: Is this INCREF necessary? 'func' is always a borrowed - * reference reachable through the value stack? If changed, stack - * unwind code also needs to be fixed to match. - */ - DUK_HOBJECT_INCREF_ALLOWNULL(thr, func); /* act->func */ - -#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY - if (func) { - duk__update_func_caller_prop(thr, func); - } - act = thr->callstack + thr->callstack_top - 1; -#endif - - /* [... func this arg1 ... argN] */ - - /* - * Environment record creation and 'arguments' object creation. - * Named function expression name binding is handled by the - * compiler; the compiled function's parent env will contain - * the (immutable) binding already. - * - * This handling is now identical for C and Ecmascript functions. - * C functions always have the 'NEWENV' flag set, so their - * environment record initialization is delayed (which is good). - * - * Delayed creation (on demand) is handled in duk_js_var.c. - */ - - DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func)); /* bound function chain has already been resolved */ - - if (func != NULL && !DUK_HOBJECT_HAS_NEWENV(func)) { - /* use existing env (e.g. for non-strict eval); cannot have - * an own 'arguments' object (but can refer to the existing one) - */ - - DUK_ASSERT(!DUK_HOBJECT_HAS_CREATEARGS(func)); - - duk__handle_oldenv_for_call(thr, func, act); - - DUK_ASSERT(act->lex_env != NULL); - DUK_ASSERT(act->var_env != NULL); - goto env_done; - } - - DUK_ASSERT(func == NULL || DUK_HOBJECT_HAS_NEWENV(func)); - - if (func == NULL || !DUK_HOBJECT_HAS_CREATEARGS(func)) { - /* no need to create environment record now; leave as NULL */ - DUK_ASSERT(act->lex_env == NULL); - DUK_ASSERT(act->var_env == NULL); - goto env_done; - } - - /* third arg: absolute index (to entire valstack) of idx_bottom of new activation */ - env = duk_create_activation_environment_record(thr, func, act->idx_bottom); - DUK_ASSERT(env != NULL); - - /* [... func this arg1 ... argN envobj] */ - - DUK_ASSERT(DUK_HOBJECT_HAS_CREATEARGS(func)); - duk__handle_createargs_for_call(thr, func, env, num_stack_args); - - /* [... func this arg1 ... argN envobj] */ - - act->lex_env = env; - act->var_env = env; - DUK_HOBJECT_INCREF(thr, env); - DUK_HOBJECT_INCREF(thr, env); /* XXX: incref by count (2) directly */ - duk_pop(ctx); - - env_done: - /* [... func this arg1 ... argN] */ - - /* - * Setup value stack: clamp to 'nargs', fill up to 'nregs' - * - * Value stack may either grow or shrink, depending on the - * number of func registers and the number of actual arguments. - * If nregs >= 0, func wants args clamped to 'nargs'; else it - * wants all args (= 'num_stack_args'). - */ - - duk__adjust_valstack_and_top(thr, - num_stack_args, - idx_args, - nregs, - nargs, - func); - - /* - * Determine call type; then setup activation and call - */ - - if (func != NULL && DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) { - goto ecmascript_call; - } else { - goto native_call; - } - DUK_UNREACHABLE(); - - /* - * Native (C) call - */ - - native_call: - /* - * Shift to new valstack_bottom. - */ - - thr->valstack_bottom = thr->valstack_bottom + idx_args; - /* keep current valstack_top */ - DUK_ASSERT(thr->valstack_bottom >= thr->valstack); - DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); - DUK_ASSERT(thr->valstack_end >= thr->valstack_top); - DUK_ASSERT(func == NULL || ((duk_hnativefunction *) func)->func != NULL); - - /* [... func this | arg1 ... argN] ('this' must precede new bottom) */ - - /* - * Actual function call and return value check. - * - * Return values: - * 0 success, no return value (default to 'undefined') - * 1 success, one return value on top of stack - * < 0 error, throw a "magic" error - * other invalid - */ - - if (func) { - rc = ((duk_hnativefunction *) func)->func((duk_context *) thr); - } else { - duk_c_function funcptr = DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv_func); - rc = funcptr((duk_context *) thr); - } - - if (rc < 0) { - duk_error_throw_from_negative_rc(thr, rc); - DUK_UNREACHABLE(); - } else if (rc > 1) { - DUK_ERROR(thr, DUK_ERR_API_ERROR, "c function returned invalid rc"); - } - DUK_ASSERT(rc == 0 || rc == 1); - - /* - * Unwind stack(s) and shift back to old valstack_bottom. - */ - - DUK_ASSERT(thr->catchstack_top == entry_catchstack_top); - DUK_ASSERT(thr->callstack_top == entry_callstack_top + 1); - -#if 0 /* should be no need to unwind */ - duk_hthread_catchstack_unwind(thr, entry_catchstack_top); -#endif - duk_hthread_callstack_unwind(thr, entry_callstack_top); - - thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index; - /* keep current valstack_top */ - - DUK_ASSERT(thr->valstack_bottom >= thr->valstack); - DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); - DUK_ASSERT(thr->valstack_end >= thr->valstack_top); - DUK_ASSERT(thr->valstack_top - thr->valstack_bottom >= idx_func + 1); - - /* - * Manipulate value stack so that return value is on top - * (pushing an 'undefined' if necessary). - */ - - /* XXX: should this happen in the callee's activation or after unwinding? */ - if (rc == 0) { - duk_require_stack(ctx, 1); - duk_push_undefined(ctx); - } - /* [... func this (crud) retval] */ - - DUK_DDD(DUK_DDDPRINT("native call retval -> %!T (rc=%ld)", - (duk_tval *) duk_get_tval(ctx, -1), (long) rc)); - - duk_replace(ctx, idx_func); - duk_set_top(ctx, idx_func + 1); - - /* [... retval] */ - - /* Ensure there is internal valstack spare before we exit; this may - * throw an alloc error. The same guaranteed size must be available - * as before the call. This is not optimal now: we store the valstack - * allocated size during entry; this value may be higher than the - * minimal guarantee for an application. - */ - - (void) duk_valstack_resize_raw((duk_context *) thr, - entry_valstack_end, /* same as during entry */ - DUK_VSRESIZE_FLAG_SHRINK | /* flags */ - DUK_VSRESIZE_FLAG_COMPACT | - DUK_VSRESIZE_FLAG_THROW); - - - /* - * Shrink checks and return with success. - */ - - retval = DUK_EXEC_SUCCESS; - goto shrink_and_finished; - - /* - * Ecmascript call - */ - - ecmascript_call: - - /* - * Shift to new valstack_bottom. - */ - - thr->valstack_bottom = thr->valstack_bottom + idx_args; - /* keep current valstack_top */ - DUK_ASSERT(thr->valstack_bottom >= thr->valstack); - DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); - DUK_ASSERT(thr->valstack_end >= thr->valstack_top); - - /* [... func this | arg1 ... argN] ('this' must precede new bottom) */ - - /* - * Bytecode executor call. - * - * Execute bytecode, handling any recursive function calls and - * thread resumptions. Returns when execution would return from - * the entry level activation. When the executor returns, a - * single return value is left on the stack top. - * - * The only possible longjmp() is an error (DUK_LJ_TYPE_THROW), - * other types are handled internally by the executor. - * - */ - - DUK_DDD(DUK_DDDPRINT("entering bytecode execution")); - duk_js_execute_bytecode(thr); - DUK_DDD(DUK_DDDPRINT("returned from bytecode execution")); - - /* - * Unwind stack(s) and shift back to old valstack_bottom. - */ - - DUK_ASSERT(thr->callstack_top == entry_callstack_top + 1); - - duk_hthread_catchstack_unwind(thr, entry_catchstack_top); - duk_hthread_callstack_unwind(thr, entry_callstack_top); - - thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index; - /* keep current valstack_top */ - - DUK_ASSERT(thr->valstack_bottom >= thr->valstack); - DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); - DUK_ASSERT(thr->valstack_end >= thr->valstack_top); - DUK_ASSERT(thr->valstack_top - thr->valstack_bottom >= idx_func + 1); - - /* - * Manipulate value stack so that return value is on top. - */ - - /* [... func this (crud) retval] */ - - duk_replace(ctx, idx_func); - duk_set_top(ctx, idx_func + 1); - - /* [... retval] */ - - /* Ensure there is internal valstack spare before we exit; this may - * throw an alloc error. The same guaranteed size must be available - * as before the call. This is not optimal now: we store the valstack - * allocated size during entry; this value may be higher than the - * minimal guarantee for an application. - */ - - (void) duk_valstack_resize_raw((duk_context *) thr, - entry_valstack_end, /* same as during entry */ - DUK_VSRESIZE_FLAG_SHRINK | /* flags */ - DUK_VSRESIZE_FLAG_COMPACT | - DUK_VSRESIZE_FLAG_THROW); - - /* - * Shrink checks and return with success. - */ - - retval = DUK_EXEC_SUCCESS; - goto shrink_and_finished; - - shrink_and_finished: -#if defined(DUK_OPT_FASTINT) - /* Explicit check for fastint downgrade. */ - { - duk_tval *tv_fi; - tv_fi = duk_get_tval(ctx, -1); - DUK_ASSERT(tv_fi != NULL); - DUK_TVAL_CHKFAST_INPLACE(tv_fi); - } -#endif - - /* these are "soft" shrink checks, whose failures are ignored */ - /* XXX: would be nice if fast path was inlined */ - duk_hthread_catchstack_shrink_check(thr); - duk_hthread_callstack_shrink_check(thr); - goto finished; - - finished: - if (need_setjmp) { - /* Note: either pointer may be NULL (at entry), so don't assert; - * this is now done potentially twice, which is OK - */ - DUK_DDD(DUK_DDDPRINT("restore jmpbuf_ptr: %p -> %p (possibly already done)", - (void *) (thr && thr->heap ? thr->heap->lj.jmpbuf_ptr : NULL), - (void *) old_jmpbuf_ptr)); - thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr; - - /* These are just convenience "wiping" of state */ - thr->heap->lj.type = DUK_LJ_TYPE_UNKNOWN; - thr->heap->lj.iserror = 0; - - /* Side effects should not be an issue here: tv_tmp is local and - * thr->heap (and thr->heap->lj) have a stable pointer. Finalizer - * runs etc capture even out-of-memory errors so nothing should - * throw here. - */ - DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1); - DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->heap->lj.value1); - DUK_TVAL_DECREF(thr, &tv_tmp); - - DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value2); - DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->heap->lj.value2); - DUK_TVAL_DECREF(thr, &tv_tmp); - - DUK_DDD(DUK_DDDPRINT("setjmp catchpoint torn down")); - } - - DUK_HEAP_SWITCH_THREAD(thr->heap, entry_curr_thread); /* may be NULL */ - thr->state = (duk_uint8_t) entry_thread_state; - - DUK_ASSERT((thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread == NULL) || /* first call */ - (thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread != NULL) || /* other call */ - (thr->state == DUK_HTHREAD_STATE_RUNNING && thr->heap->curr_thread == thr)); /* current thread */ - - thr->heap->call_recursion_depth = entry_call_recursion_depth; - - return retval; - - thread_state_error: - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid thread state for call (%ld)", (long) thr->state); - DUK_UNREACHABLE(); - return DUK_EXEC_ERROR; /* never executed */ -} - /* * Manipulate value stack so that exactly 'num_stack_rets' return * values are at 'idx_retbase' in every case, assuming there are @@ -49391,14 +57566,14 @@ DUK_LOCAL void duk__safe_call_adjust_valstack(duk_hthread *thr, duk_idx_t idx_re DUK_ASSERT(idx_rcbase >= 0); /* caller must check */ - /* ensure space for final configuration (idx_retbase + num_stack_rets) and - * intermediate configurations + /* Ensure space for final configuration (idx_retbase + num_stack_rets) + * and intermediate configurations. */ duk_require_stack_top(ctx, (idx_rcbase > idx_retbase ? idx_rcbase : idx_retbase) + num_stack_rets); - /* chop extra retvals away / extend with undefined */ + /* Chop extra retvals away / extend with undefined. */ duk_set_top(ctx, idx_rcbase + num_stack_rets); if (idx_rcbase >= idx_retbase) { @@ -49440,33 +57615,973 @@ DUK_LOCAL void duk__safe_call_adjust_valstack(duk_hthread *thr, duk_idx_t idx_re } /* - * Make a "C protected call" within the current activation. + * Misc shared helpers. + */ + +/* Get valstack index for the func argument or throw if insane stack. */ +DUK_LOCAL duk_idx_t duk__get_idx_func(duk_hthread *thr, duk_idx_t num_stack_args) { + duk_size_t off_stack_top; + duk_size_t off_stack_args; + duk_size_t off_stack_all; + duk_idx_t idx_func; /* valstack index of 'func' and retval (relative to entry valstack_bottom) */ + + /* Argument validation and func/args offset. */ + off_stack_top = (duk_size_t) ((duk_uint8_t *) thr->valstack_top - (duk_uint8_t *) thr->valstack_bottom); + off_stack_args = (duk_size_t) ((duk_size_t) num_stack_args * sizeof(duk_tval)); + off_stack_all = off_stack_args + 2 * sizeof(duk_tval); + if (DUK_UNLIKELY(off_stack_all > off_stack_top)) { + /* Since stack indices are not reliable, we can't do anything useful + * here. Invoke the existing setjmp catcher, or if it doesn't exist, + * call the fatal error handler. + */ + DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS); + return 0; + } + idx_func = (duk_idx_t) ((off_stack_top - off_stack_all) / sizeof(duk_tval)); + return idx_func; +} + +/* + * duk_handle_call_protected() and duk_handle_call_unprotected(): + * call into a Duktape/C or an Ecmascript function from any state. + * + * Input stack (thr): + * + * [ func this arg1 ... argN ] + * + * Output stack (thr): + * + * [ retval ] (DUK_EXEC_SUCCESS) + * [ errobj ] (DUK_EXEC_ERROR (normal error), protected call) + * + * Even when executing a protected call an error may be thrown in rare cases + * such as an insane num_stack_args argument. If there is no catchpoint for + * such errors, the fatal error handler is called. + * + * The error handling path should be error free, even for out-of-memory + * errors, to ensure safe sandboxing. (As of Duktape 1.4.0 this is not + * yet the case, see XXX notes below.) + */ + +DUK_INTERNAL duk_int_t duk_handle_call_protected(duk_hthread *thr, + duk_idx_t num_stack_args, + duk_small_uint_t call_flags) { + duk_context *ctx; + duk_size_t entry_valstack_bottom_index; + duk_size_t entry_valstack_end; + duk_size_t entry_callstack_top; + duk_size_t entry_catchstack_top; + duk_int_t entry_call_recursion_depth; + duk_hthread *entry_curr_thread; + duk_uint_fast8_t entry_thread_state; + duk_instr_t **entry_ptr_curr_pc; +#if !defined(DUK_USE_CPP_EXCEPTIONS) + duk_jmpbuf *old_jmpbuf_ptr = NULL; + duk_jmpbuf our_jmpbuf; +#endif + duk_idx_t idx_func; /* valstack index of 'func' and retval (relative to entry valstack_bottom) */ + + /* XXX: Multiple tv_func lookups are now avoided by making a local + * copy of tv_func. Another approach would be to compute an offset + * for tv_func from valstack bottom and recomputing the tv_func + * pointer quickly as valstack + offset instead of calling duk_get_tval(). + */ + + ctx = (duk_context *) thr; + DUK_UNREF(ctx); + DUK_ASSERT(thr != NULL); + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(num_stack_args >= 0); + /* XXX: currently NULL allocations are not supported; remove if later allowed */ + DUK_ASSERT(thr->valstack != NULL); + DUK_ASSERT(thr->callstack != NULL); + DUK_ASSERT(thr->catchstack != NULL); + + /* Argument validation and func/args offset. */ + idx_func = duk__get_idx_func(thr, num_stack_args); + + /* Preliminaries, required by setjmp() handler. Must be careful not + * to throw an unintended error here. + */ + + entry_valstack_bottom_index = (duk_size_t) (thr->valstack_bottom - thr->valstack); +#if defined(DUK_USE_PREFER_SIZE) + entry_valstack_end = (duk_size_t) (thr->valstack_end - thr->valstack); +#else + DUK_ASSERT((duk_size_t) (thr->valstack_end - thr->valstack) == thr->valstack_size); + entry_valstack_end = thr->valstack_size; +#endif + entry_callstack_top = thr->callstack_top; + entry_catchstack_top = thr->catchstack_top; + entry_call_recursion_depth = thr->heap->call_recursion_depth; + entry_curr_thread = thr->heap->curr_thread; /* Note: may be NULL if first call */ + entry_thread_state = thr->state; + entry_ptr_curr_pc = thr->ptr_curr_pc; /* may be NULL */ + + DUK_DD(DUK_DDPRINT("duk_handle_call_protected: thr=%p, num_stack_args=%ld, " + "call_flags=0x%08lx (ignorerec=%ld, constructor=%ld), " + "valstack_top=%ld, idx_func=%ld, idx_args=%ld, rec_depth=%ld/%ld, " + "entry_valstack_bottom_index=%ld, entry_callstack_top=%ld, entry_catchstack_top=%ld, " + "entry_call_recursion_depth=%ld, entry_curr_thread=%p, entry_thread_state=%ld", + (void *) thr, + (long) num_stack_args, + (unsigned long) call_flags, + (long) ((call_flags & DUK_CALL_FLAG_IGNORE_RECLIMIT) != 0 ? 1 : 0), + (long) ((call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL) != 0 ? 1 : 0), + (long) duk_get_top(ctx), + (long) idx_func, + (long) (idx_func + 2), + (long) thr->heap->call_recursion_depth, + (long) thr->heap->call_recursion_limit, + (long) entry_valstack_bottom_index, + (long) entry_callstack_top, + (long) entry_catchstack_top, + (long) entry_call_recursion_depth, + (void *) entry_curr_thread, + (long) entry_thread_state)); + +#if !defined(DUK_USE_CPP_EXCEPTIONS) + old_jmpbuf_ptr = thr->heap->lj.jmpbuf_ptr; + thr->heap->lj.jmpbuf_ptr = &our_jmpbuf; +#endif + +#if defined(DUK_USE_CPP_EXCEPTIONS) + try { +#else + if (DUK_LIKELY(DUK_SETJMP(thr->heap->lj.jmpbuf_ptr->jb) == 0)) { +#endif + /* Call handling and success path. Success path exit cleans + * up almost all state. + */ + duk__handle_call_inner(thr, num_stack_args, call_flags, idx_func); + + /* Success path handles */ + DUK_ASSERT(thr->heap->call_recursion_depth == entry_call_recursion_depth); + DUK_ASSERT(thr->ptr_curr_pc == entry_ptr_curr_pc); + + /* Longjmp state is kept clean in success path */ + DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_UNKNOWN); + DUK_ASSERT(thr->heap->lj.iserror == 0); + DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value1)); + DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value2)); + +#if !defined(DUK_USE_CPP_EXCEPTIONS) + thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr; +#endif + + return DUK_EXEC_SUCCESS; +#if defined(DUK_USE_CPP_EXCEPTIONS) + } catch (duk_internal_exception &exc) { +#else + } else { +#endif + /* Error; error value is in heap->lj.value1. */ + +#if defined(DUK_USE_CPP_EXCEPTIONS) + DUK_UNREF(exc); +#endif + + duk__handle_call_error(thr, + entry_valstack_bottom_index, + entry_valstack_end, + entry_catchstack_top, + entry_callstack_top, + entry_call_recursion_depth, + entry_curr_thread, + entry_thread_state, + entry_ptr_curr_pc, + idx_func +#if !defined(DUK_USE_CPP_EXCEPTIONS) + , old_jmpbuf_ptr +#endif + ); + + /* Longjmp state is cleaned up by error handling */ + DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_UNKNOWN); + DUK_ASSERT(thr->heap->lj.iserror == 0); + DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value1)); + DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value2)); + return DUK_EXEC_ERROR; + } +#if defined(DUK_USE_CPP_EXCEPTIONS) + catch (std::exception &exc) { + const char *what = exc.what(); + if (!what) { + what = "unknown"; + } + DUK_D(DUK_DPRINT("unexpected c++ std::exception (perhaps thrown by user code)")); + try { + DUK_ERROR(thr, DUK_ERR_API_ERROR, "caught invalid c++ std::exception '%s' (perhaps thrown by user code)", what); + } catch (duk_internal_exception exc) { + DUK_D(DUK_DPRINT("caught api error thrown from unexpected c++ std::exception")); + duk__handle_call_error(thr, + entry_valstack_bottom_index, + entry_valstack_end, + entry_catchstack_top, + entry_callstack_top, + entry_call_recursion_depth, + entry_curr_thread, + entry_thread_state, + entry_ptr_curr_pc, + idx_func); + return DUK_EXEC_ERROR; + } + } catch (...) { + DUK_D(DUK_DPRINT("unexpected c++ exception (perhaps thrown by user code)")); + try { + DUK_ERROR(thr, DUK_ERR_API_ERROR, "caught invalid c++ exception (perhaps thrown by user code)"); + } catch (duk_internal_exception exc) { + DUK_D(DUK_DPRINT("caught api error thrown from unexpected c++ exception")); + duk__handle_call_error(thr, + entry_valstack_bottom_index, + entry_valstack_end, + entry_catchstack_top, + entry_callstack_top, + entry_call_recursion_depth, + entry_curr_thread, + entry_thread_state, + entry_ptr_curr_pc, + idx_func); + return DUK_EXEC_ERROR; + } + } +#endif +} + +DUK_INTERNAL void duk_handle_call_unprotected(duk_hthread *thr, + duk_idx_t num_stack_args, + duk_small_uint_t call_flags) { + duk_idx_t idx_func; /* valstack index of 'func' and retval (relative to entry valstack_bottom) */ + + /* Argument validation and func/args offset. */ + idx_func = duk__get_idx_func(thr, num_stack_args); + + duk__handle_call_inner(thr, num_stack_args, call_flags, idx_func); +} + +DUK_LOCAL void duk__handle_call_inner(duk_hthread *thr, + duk_idx_t num_stack_args, + duk_small_uint_t call_flags, + duk_idx_t idx_func) { + duk_context *ctx; + duk_size_t entry_valstack_bottom_index; + duk_size_t entry_valstack_end; + duk_size_t entry_callstack_top; + duk_size_t entry_catchstack_top; + duk_int_t entry_call_recursion_depth; + duk_hthread *entry_curr_thread; + duk_uint_fast8_t entry_thread_state; + duk_instr_t **entry_ptr_curr_pc; + duk_idx_t nargs; /* # argument registers target function wants (< 0 => "as is") */ + duk_idx_t nregs; /* # total registers target function wants on entry (< 0 => "as is") */ + duk_hobject *func; /* 'func' on stack (borrowed reference) */ + duk_tval *tv_func; /* duk_tval ptr for 'func' on stack (borrowed reference) or tv_func_copy */ + duk_tval tv_func_copy; /* to avoid relookups */ + duk_activation *act; + duk_hobject *env; + duk_ret_t rc; + + ctx = (duk_context *) thr; + DUK_ASSERT(thr != NULL); + DUK_ASSERT_CTX_VALID(ctx); + DUK_ASSERT(ctx != NULL); + DUK_ASSERT(num_stack_args >= 0); + /* XXX: currently NULL allocations are not supported; remove if later allowed */ + DUK_ASSERT(thr->valstack != NULL); + DUK_ASSERT(thr->callstack != NULL); + DUK_ASSERT(thr->catchstack != NULL); + + DUK_DD(DUK_DDPRINT("duk__handle_call_inner: num_stack_args=%ld, call_flags=0x%08lx, top=%ld", + (long) num_stack_args, (long) call_flags, (long) duk_get_top(ctx))); + + /* + * Store entry state. + */ + + entry_valstack_bottom_index = (duk_size_t) (thr->valstack_bottom - thr->valstack); +#if defined(DUK_USE_PREFER_SIZE) + entry_valstack_end = (duk_size_t) (thr->valstack_end - thr->valstack); +#else + DUK_ASSERT((duk_size_t) (thr->valstack_end - thr->valstack) == thr->valstack_size); + entry_valstack_end = thr->valstack_size; +#endif + entry_callstack_top = thr->callstack_top; + entry_catchstack_top = thr->catchstack_top; + entry_call_recursion_depth = thr->heap->call_recursion_depth; + entry_curr_thread = thr->heap->curr_thread; /* Note: may be NULL if first call */ + entry_thread_state = thr->state; + entry_ptr_curr_pc = thr->ptr_curr_pc; /* may be NULL */ + + /* If thr->ptr_curr_pc is set, sync curr_pc to act->pc. Then NULL + * thr->ptr_curr_pc so that it's not accidentally used with an incorrect + * activation when side effects occur. + */ + duk_hthread_sync_and_null_currpc(thr); + + DUK_DD(DUK_DDPRINT("duk__handle_call_inner: thr=%p, num_stack_args=%ld, " + "call_flags=0x%08lx (ignorerec=%ld, constructor=%ld), " + "valstack_top=%ld, idx_func=%ld, idx_args=%ld, rec_depth=%ld/%ld, " + "entry_valstack_bottom_index=%ld, entry_callstack_top=%ld, entry_catchstack_top=%ld, " + "entry_call_recursion_depth=%ld, entry_curr_thread=%p, entry_thread_state=%ld", + (void *) thr, + (long) num_stack_args, + (unsigned long) call_flags, + (long) ((call_flags & DUK_CALL_FLAG_IGNORE_RECLIMIT) != 0 ? 1 : 0), + (long) ((call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL) != 0 ? 1 : 0), + (long) duk_get_top(ctx), + (long) idx_func, + (long) (idx_func + 2), + (long) thr->heap->call_recursion_depth, + (long) thr->heap->call_recursion_limit, + (long) entry_valstack_bottom_index, + (long) entry_callstack_top, + (long) entry_catchstack_top, + (long) entry_call_recursion_depth, + (void *) entry_curr_thread, + (long) entry_thread_state)); + + + /* + * Thread state check and book-keeping. + */ + + if (thr == thr->heap->curr_thread) { + /* same thread */ + if (thr->state != DUK_HTHREAD_STATE_RUNNING) { + /* should actually never happen, but check anyway */ + goto thread_state_error; + } + } else { + /* different thread */ + DUK_ASSERT(thr->heap->curr_thread == NULL || + thr->heap->curr_thread->state == DUK_HTHREAD_STATE_RUNNING); + if (thr->state != DUK_HTHREAD_STATE_INACTIVE) { + goto thread_state_error; + } + DUK_HEAP_SWITCH_THREAD(thr->heap, thr); + thr->state = DUK_HTHREAD_STATE_RUNNING; + + /* Note: multiple threads may be simultaneously in the RUNNING + * state, but not in the same "resume chain". + */ + } + DUK_ASSERT(thr->heap->curr_thread == thr); + DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING); + + /* + * C call recursion depth check, which provides a reasonable upper + * bound on maximum C stack size (arbitrary C stack growth is only + * possible by recursive handle_call / handle_safe_call calls). + */ + + /* XXX: remove DUK_CALL_FLAG_IGNORE_RECLIMIT flag: there's now the + * reclimit bump? + */ + + DUK_ASSERT(thr->heap->call_recursion_depth >= 0); + DUK_ASSERT(thr->heap->call_recursion_depth <= thr->heap->call_recursion_limit); + if (call_flags & DUK_CALL_FLAG_IGNORE_RECLIMIT) { + DUK_DD(DUK_DDPRINT("ignoring reclimit for this call (probably an errhandler call)")); + } else { + if (thr->heap->call_recursion_depth >= thr->heap->call_recursion_limit) { + /* XXX: error message is a bit misleading: we reached a recursion + * limit which is also essentially the same as a C callstack limit + * (except perhaps with some relaxed threading assumptions). + */ + DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_C_CALLSTACK_LIMIT); + } + thr->heap->call_recursion_depth++; + } + + /* + * Check the function type, handle bound function chains, and prepare + * parameters for the rest of the call handling. Also figure out the + * effective 'this' binding, which replaces the current value at + * idx_func + 1. + * + * If the target function is a 'bound' one, follow the chain of 'bound' + * functions until a non-bound function is found. During this process, + * bound arguments are 'prepended' to existing ones, and the "this" + * binding is overridden. See E5 Section 15.3.4.5.1. + * + * Lightfunc detection happens here too. Note that lightweight functions + * can be wrapped by (non-lightweight) bound functions so we must resolve + * the bound function chain first. + */ + + func = duk__nonbound_func_lookup(ctx, idx_func, &num_stack_args, &tv_func, call_flags); + DUK_TVAL_SET_TVAL(&tv_func_copy, tv_func); + tv_func = &tv_func_copy; /* local copy to avoid relookups */ + + DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func)); + DUK_ASSERT(func == NULL || (DUK_HOBJECT_IS_COMPILEDFUNCTION(func) || + DUK_HOBJECT_IS_NATIVEFUNCTION(func))); + + duk__coerce_effective_this_binding(thr, func, idx_func + 1); + DUK_DDD(DUK_DDDPRINT("effective 'this' binding is: %!T", + (duk_tval *) duk_get_tval(ctx, idx_func + 1))); + + /* [ ... func this arg1 ... argN ] */ + + /* + * Setup a preliminary activation and figure out nargs/nregs. + * + * Don't touch valstack_bottom or valstack_top yet so that Duktape API + * calls work normally. + */ + + duk_hthread_callstack_grow(thr); + + if (thr->callstack_top > 0) { + /* + * Update idx_retval of current activation. + * + * Although it might seem this is not necessary (bytecode executor + * does this for Ecmascript-to-Ecmascript calls; other calls are + * handled here), this turns out to be necessary for handling yield + * and resume. For them, an Ecmascript-to-native call happens, and + * the Ecmascript call's idx_retval must be set for things to work. + */ + + (thr->callstack + thr->callstack_top - 1)->idx_retval = entry_valstack_bottom_index + idx_func; + } + + DUK_ASSERT(thr->callstack_top < thr->callstack_size); + act = thr->callstack + thr->callstack_top; + thr->callstack_top++; + DUK_ASSERT(thr->callstack_top <= thr->callstack_size); + DUK_ASSERT(thr->valstack_top > thr->valstack_bottom); /* at least effective 'this' */ + DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func)); + + act->flags = 0; + + /* For now all calls except Ecma-to-Ecma calls prevent a yield. */ + act->flags |= DUK_ACT_FLAG_PREVENT_YIELD; + if (call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL) { + act->flags |= DUK_ACT_FLAG_CONSTRUCT; + } + if (call_flags & DUK_CALL_FLAG_DIRECT_EVAL) { + act->flags |= DUK_ACT_FLAG_DIRECT_EVAL; + } + + /* These base values are never used, but if the compiler doesn't know + * that DUK_ERROR() won't return, these are needed to silence warnings. + * On the other hand, scan-build will warn about the values not being + * used, so add a DUK_UNREF. + */ + nargs = 0; DUK_UNREF(nargs); + nregs = 0; DUK_UNREF(nregs); + + if (DUK_LIKELY(func != NULL)) { + if (DUK_HOBJECT_HAS_STRICT(func)) { + act->flags |= DUK_ACT_FLAG_STRICT; + } + if (DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) { + nargs = ((duk_hcompiledfunction *) func)->nargs; + nregs = ((duk_hcompiledfunction *) func)->nregs; + DUK_ASSERT(nregs >= nargs); + } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(func)) { + /* Note: nargs (and nregs) may be negative for a native, + * function, which indicates that the function wants the + * input stack "as is" (i.e. handles "vararg" arguments). + */ + nargs = ((duk_hnativefunction *) func)->nargs; + nregs = nargs; + } else { + /* XXX: this should be an assert */ + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_CALLABLE); + } + } else { + duk_small_uint_t lf_flags; + + DUK_ASSERT(DUK_TVAL_IS_LIGHTFUNC(tv_func)); + lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv_func); + nargs = DUK_LFUNC_FLAGS_GET_NARGS(lf_flags); + if (nargs == DUK_LFUNC_NARGS_VARARGS) { + nargs = -1; /* vararg */ + } + nregs = nargs; + + act->flags |= DUK_ACT_FLAG_STRICT; + } + + act->func = func; /* NULL for lightfunc */ + act->var_env = NULL; + act->lex_env = NULL; +#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY) + act->prev_caller = NULL; +#endif + act->curr_pc = NULL; +#if defined(DUK_USE_DEBUGGER_SUPPORT) + act->prev_line = 0; +#endif + act->idx_bottom = entry_valstack_bottom_index + idx_func + 2; +#if 0 /* topmost activation idx_retval is considered garbage, no need to init */ + act->idx_retval = 0; +#endif + DUK_TVAL_SET_TVAL(&act->tv_func, tv_func); /* borrowed, no refcount */ + + /* XXX: remove the preventcount and make yield walk the callstack? + * Or perhaps just use a single flag, not a counter, faster to just + * set and restore? + */ + if (act->flags & DUK_ACT_FLAG_PREVENT_YIELD) { + /* duk_hthread_callstack_unwind() will decrease this on unwind */ + thr->callstack_preventcount++; + } + + /* XXX: Is this INCREF necessary? 'func' is always a borrowed + * reference reachable through the value stack? If changed, stack + * unwind code also needs to be fixed to match. + */ + DUK_HOBJECT_INCREF_ALLOWNULL(thr, func); /* act->func */ + +#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY) + if (func) { + duk__update_func_caller_prop(thr, func); + } + act = thr->callstack + thr->callstack_top - 1; +#endif + + /* [ ... func this arg1 ... argN ] */ + + /* + * Environment record creation and 'arguments' object creation. + * Named function expression name binding is handled by the + * compiler; the compiled function's parent env will contain + * the (immutable) binding already. + * + * This handling is now identical for C and Ecmascript functions. + * C functions always have the 'NEWENV' flag set, so their + * environment record initialization is delayed (which is good). + * + * Delayed creation (on demand) is handled in duk_js_var.c. + */ + + DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func)); /* bound function chain has already been resolved */ + + if (DUK_LIKELY(func != NULL)) { + if (DUK_LIKELY(DUK_HOBJECT_HAS_NEWENV(func))) { + if (DUK_LIKELY(!DUK_HOBJECT_HAS_CREATEARGS(func))) { + /* Use a new environment but there's no 'arguments' object; + * delayed environment initialization. This is the most + * common case. + */ + DUK_ASSERT(act->lex_env == NULL); + DUK_ASSERT(act->var_env == NULL); + } else { + /* Use a new environment and there's an 'arguments' object. + * We need to initialize it right now. + */ + + /* third arg: absolute index (to entire valstack) of idx_bottom of new activation */ + env = duk_create_activation_environment_record(thr, func, act->idx_bottom); + DUK_ASSERT(env != NULL); + + /* [ ... func this arg1 ... argN envobj ] */ + + DUK_ASSERT(DUK_HOBJECT_HAS_CREATEARGS(func)); + duk__handle_createargs_for_call(thr, func, env, num_stack_args); + + /* [ ... func this arg1 ... argN envobj ] */ + + act = thr->callstack + thr->callstack_top - 1; + act->lex_env = env; + act->var_env = env; + DUK_HOBJECT_INCREF(thr, env); + DUK_HOBJECT_INCREF(thr, env); /* XXX: incref by count (2) directly */ + duk_pop(ctx); + } + } else { + /* Use existing env (e.g. for non-strict eval); cannot have + * an own 'arguments' object (but can refer to an existing one). + */ + + DUK_ASSERT(!DUK_HOBJECT_HAS_CREATEARGS(func)); + + duk__handle_oldenv_for_call(thr, func, act); + + DUK_ASSERT(act->lex_env != NULL); + DUK_ASSERT(act->var_env != NULL); + } + } else { + /* Lightfuncs are always native functions and have "newenv". */ + DUK_ASSERT(act->lex_env == NULL); + DUK_ASSERT(act->var_env == NULL); + } + + /* [ ... func this arg1 ... argN ] */ + + /* + * Setup value stack: clamp to 'nargs', fill up to 'nregs' + * + * Value stack may either grow or shrink, depending on the + * number of func registers and the number of actual arguments. + * If nregs >= 0, func wants args clamped to 'nargs'; else it + * wants all args (= 'num_stack_args'). + */ + + /* XXX: optimize value stack operation */ + /* XXX: don't want to shrink allocation here */ + + duk__adjust_valstack_and_top(thr, + num_stack_args, + idx_func + 2, + nregs, + nargs, + func); + + /* + * Determine call type, then finalize activation, shift to + * new value stack bottom, and call the target. + */ + + if (func != NULL && DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) { + /* + * Ecmascript call + */ + + duk_tval *tv_ret; + duk_tval *tv_funret; + + DUK_ASSERT(func != NULL); + DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(func)); + act->curr_pc = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) func); + + thr->valstack_bottom = thr->valstack_bottom + idx_func + 2; + /* keep current valstack_top */ + DUK_ASSERT(thr->valstack_bottom >= thr->valstack); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + DUK_ASSERT(thr->valstack_end >= thr->valstack_top); + + /* [ ... func this | arg1 ... argN ] ('this' must precede new bottom) */ + + /* + * Bytecode executor call. + * + * Execute bytecode, handling any recursive function calls and + * thread resumptions. Returns when execution would return from + * the entry level activation. When the executor returns, a + * single return value is left on the stack top. + * + * The only possible longjmp() is an error (DUK_LJ_TYPE_THROW), + * other types are handled internally by the executor. + */ + + /* thr->ptr_curr_pc is set by bytecode executor early on entry */ + DUK_ASSERT(thr->ptr_curr_pc == NULL); + DUK_DDD(DUK_DDDPRINT("entering bytecode execution")); + duk_js_execute_bytecode(thr); + DUK_DDD(DUK_DDDPRINT("returned from bytecode execution")); + + /* Unwind. */ + + DUK_ASSERT(thr->catchstack_top >= entry_catchstack_top); /* may need unwind */ + DUK_ASSERT(thr->callstack_top == entry_callstack_top + 1); + DUK_ASSERT(thr->callstack_top == entry_callstack_top + 1); + duk_hthread_catchstack_unwind(thr, entry_catchstack_top); + duk_hthread_catchstack_shrink_check(thr); + duk_hthread_callstack_unwind(thr, entry_callstack_top); + duk_hthread_callstack_shrink_check(thr); + + thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index; + /* keep current valstack_top */ + DUK_ASSERT(thr->valstack_bottom >= thr->valstack); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + DUK_ASSERT(thr->valstack_end >= thr->valstack_top); + DUK_ASSERT(thr->valstack_top - thr->valstack_bottom >= idx_func + 1); + + /* Return value handling. */ + + /* [ ... func this (crud) retval ] */ + + tv_ret = thr->valstack_bottom + idx_func; + tv_funret = thr->valstack_top - 1; +#if defined(DUK_USE_FASTINT) + /* Explicit check for fastint downgrade. */ + DUK_TVAL_CHKFAST_INPLACE(tv_funret); +#endif + DUK_TVAL_SET_TVAL_UPDREF(thr, tv_ret, tv_funret); /* side effects */ + } else { + /* + * Native call. + */ + + duk_tval *tv_ret; + duk_tval *tv_funret; + + thr->valstack_bottom = thr->valstack_bottom + idx_func + 2; + /* keep current valstack_top */ + DUK_ASSERT(thr->valstack_bottom >= thr->valstack); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + DUK_ASSERT(thr->valstack_end >= thr->valstack_top); + DUK_ASSERT(func == NULL || ((duk_hnativefunction *) func)->func != NULL); + + /* [ ... func this | arg1 ... argN ] ('this' must precede new bottom) */ + + /* For native calls must be NULL so we don't sync back */ + DUK_ASSERT(thr->ptr_curr_pc == NULL); + + if (func) { + rc = ((duk_hnativefunction *) func)->func((duk_context *) thr); + } else { + duk_c_function funcptr = DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv_func); + rc = funcptr((duk_context *) thr); + } + + /* Automatic error throwing, retval check. */ + + if (rc < 0) { + duk_error_throw_from_negative_rc(thr, rc); + DUK_UNREACHABLE(); + } else if (rc > 1) { + DUK_ERROR(thr, DUK_ERR_API_ERROR, "c function returned invalid rc"); + } + DUK_ASSERT(rc == 0 || rc == 1); + + /* Unwind. */ + + DUK_ASSERT(thr->catchstack_top == entry_catchstack_top); /* no need to unwind */ + DUK_ASSERT(thr->callstack_top == entry_callstack_top + 1); + duk_hthread_callstack_unwind(thr, entry_callstack_top); + duk_hthread_callstack_shrink_check(thr); + + thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index; + /* keep current valstack_top */ + DUK_ASSERT(thr->valstack_bottom >= thr->valstack); + DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom); + DUK_ASSERT(thr->valstack_end >= thr->valstack_top); + DUK_ASSERT(thr->valstack_top - thr->valstack_bottom >= idx_func + 1); + + /* Return value handling. */ + + /* XXX: should this happen in the callee's activation or after unwinding? */ + tv_ret = thr->valstack_bottom + idx_func; + if (rc == 0) { + DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv_ret); /* side effects */ + } else { + /* [ ... func this (crud) retval ] */ + tv_funret = thr->valstack_top - 1; +#if defined(DUK_USE_FASTINT) + /* Explicit check for fastint downgrade. */ + DUK_TVAL_CHKFAST_INPLACE(tv_funret); +#endif + DUK_TVAL_SET_TVAL_UPDREF(thr, tv_ret, tv_funret); /* side effects */ + } + } + + duk_set_top(ctx, idx_func + 1); /* XXX: unnecessary, handle in adjust */ + + /* [ ... retval ] */ + + /* Ensure there is internal valstack spare before we exit; this may + * throw an alloc error. The same guaranteed size must be available + * as before the call. This is not optimal now: we store the valstack + * allocated size during entry; this value may be higher than the + * minimal guarantee for an application. + */ + + /* XXX: we should never shrink here; when we error out later, we'd + * need to potentially grow the value stack in error unwind which could + * cause another error. + */ + + (void) duk_valstack_resize_raw((duk_context *) thr, + entry_valstack_end, /* same as during entry */ + DUK_VSRESIZE_FLAG_SHRINK | /* flags */ + DUK_VSRESIZE_FLAG_COMPACT | + DUK_VSRESIZE_FLAG_THROW); + + /* Restore entry thread executor curr_pc stack frame pointer. */ + thr->ptr_curr_pc = entry_ptr_curr_pc; + + DUK_HEAP_SWITCH_THREAD(thr->heap, entry_curr_thread); /* may be NULL */ + thr->state = (duk_uint8_t) entry_thread_state; + + DUK_ASSERT((thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread == NULL) || /* first call */ + (thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread != NULL) || /* other call */ + (thr->state == DUK_HTHREAD_STATE_RUNNING && thr->heap->curr_thread == thr)); /* current thread */ + + thr->heap->call_recursion_depth = entry_call_recursion_depth; + + /* If the debugger is active we need to force an interrupt so that + * debugger breakpoints are rechecked. This is important for function + * calls caused by side effects (e.g. when doing a DUK_OP_GETPROP), see + * GH-303. Only needed for success path, error path always causes a + * breakpoint recheck in the executor. It would be enough to set this + * only when returning to an Ecmascript activation, but setting the flag + * on every return should have no ill effect. + */ +#if defined(DUK_USE_DEBUGGER_SUPPORT) + if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) { + DUK_DD(DUK_DDPRINT("returning with debugger enabled, force interrupt")); + DUK_ASSERT(thr->interrupt_counter <= thr->interrupt_init); + thr->interrupt_init -= thr->interrupt_counter; + thr->interrupt_counter = 0; + thr->heap->dbg_force_restart = 1; + } +#endif + +#if defined(DUK_USE_INTERRUPT_COUNTER) && defined(DUK_USE_DEBUG) + duk__interrupt_fixup(thr, entry_curr_thread); +#endif + + return; + + thread_state_error: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid thread state for call (%ld)", (long) thr->state); + DUK_UNREACHABLE(); + return; /* never executed */ +} + +DUK_LOCAL void duk__handle_call_error(duk_hthread *thr, + duk_size_t entry_valstack_bottom_index, + duk_size_t entry_valstack_end, + duk_size_t entry_catchstack_top, + duk_size_t entry_callstack_top, + duk_int_t entry_call_recursion_depth, + duk_hthread *entry_curr_thread, + duk_uint_fast8_t entry_thread_state, + duk_instr_t **entry_ptr_curr_pc, + duk_idx_t idx_func +#if !defined(DUK_USE_CPP_EXCEPTIONS) + , duk_jmpbuf *old_jmpbuf_ptr +#endif + ) { + duk_context *ctx; + duk_tval *tv_ret; + + ctx = (duk_context *) thr; + + DUK_DDD(DUK_DDDPRINT("error caught during duk__handle_call_inner(): %!T", + (duk_tval *) &thr->heap->lj.value1)); + + /* Other longjmp types are handled by executor before propagating + * the error here. + */ + DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_THROW); + DUK_ASSERT(thr->callstack_top >= entry_callstack_top); + DUK_ASSERT(thr->catchstack_top >= entry_catchstack_top); + + /* We don't need to sync back thr->ptr_curr_pc here because + * the bytecode executor always has a setjmp catchpoint which + * does that before errors propagate to here. + */ + DUK_ASSERT(thr->ptr_curr_pc == NULL); + +#if !defined(DUK_USE_CPP_EXCEPTIONS) + /* Restore the previous setjmp catcher so that any error in + * error handling will propagate outwards rather than re-enter + * the same handler. However, the error handling path must be + * designed to be error free so that sandboxing guarantees are + * reliable, see e.g. https://github.com/svaarala/duktape/issues/476. + */ + thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr; +#endif + + /* XXX: callstack unwind may now throw an error when closing + * scopes; this is a sandboxing issue, described in: + * https://github.com/svaarala/duktape/issues/476 + */ + duk_hthread_catchstack_unwind(thr, entry_catchstack_top); + duk_hthread_catchstack_shrink_check(thr); + duk_hthread_callstack_unwind(thr, entry_callstack_top); + duk_hthread_callstack_shrink_check(thr); + + thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index; + tv_ret = thr->valstack_bottom + idx_func; /* XXX: byte offset? */ + DUK_TVAL_SET_TVAL_UPDREF(thr, tv_ret, &thr->heap->lj.value1); /* side effects */ +#if defined(DUK_USE_FASTINT) + /* Explicit check for fastint downgrade. */ + DUK_TVAL_CHKFAST_INPLACE(tv_ret); +#endif + duk_set_top(ctx, idx_func + 1); /* XXX: could be eliminated with valstack adjust */ + + /* [ ... errobj ] */ + + /* Ensure there is internal valstack spare before we exit; this may + * throw an alloc error. The same guaranteed size must be available + * as before the call. This is not optimal now: we store the valstack + * allocated size during entry; this value may be higher than the + * minimal guarantee for an application. + */ + + /* XXX: this needs to be reworked so that we never shrink the value + * stack on function entry so that we never need to grow it here. + * Needing to grow here is a sandboxing issue because we need to + * allocate which may cause an error in the error handling path + * and thus propagate an error out of a protected call. + */ + + (void) duk_valstack_resize_raw((duk_context *) thr, + entry_valstack_end, /* same as during entry */ + DUK_VSRESIZE_FLAG_SHRINK | /* flags */ + DUK_VSRESIZE_FLAG_COMPACT | + DUK_VSRESIZE_FLAG_THROW); + + + /* These are just convenience "wiping" of state. Side effects should + * not be an issue here: thr->heap and thr->heap->lj have a stable + * pointer. Finalizer runs etc capture even out-of-memory errors so + * nothing should throw here. + */ + thr->heap->lj.type = DUK_LJ_TYPE_UNKNOWN; + thr->heap->lj.iserror = 0; + DUK_TVAL_SET_UNDEFINED_UPDREF(thr, &thr->heap->lj.value1); /* side effects */ + DUK_TVAL_SET_UNDEFINED_UPDREF(thr, &thr->heap->lj.value2); /* side effects */ + + /* Restore entry thread executor curr_pc stack frame pointer. */ + thr->ptr_curr_pc = entry_ptr_curr_pc; + + DUK_HEAP_SWITCH_THREAD(thr->heap, entry_curr_thread); /* may be NULL */ + thr->state = (duk_uint8_t) entry_thread_state; + + DUK_ASSERT((thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread == NULL) || /* first call */ + (thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread != NULL) || /* other call */ + (thr->state == DUK_HTHREAD_STATE_RUNNING && thr->heap->curr_thread == thr)); /* current thread */ + + thr->heap->call_recursion_depth = entry_call_recursion_depth; + + /* If the debugger is active we need to force an interrupt so that + * debugger breakpoints are rechecked. This is important for function + * calls caused by side effects (e.g. when doing a DUK_OP_GETPROP), see + * GH-303. Only needed for success path, error path always causes a + * breakpoint recheck in the executor. It would be enough to set this + * only when returning to an Ecmascript activation, but setting the flag + * on every return should have no ill effect. + */ +#if defined(DUK_USE_DEBUGGER_SUPPORT) + if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) { + DUK_DD(DUK_DDPRINT("returning with debugger enabled, force interrupt")); + DUK_ASSERT(thr->interrupt_counter <= thr->interrupt_init); + thr->interrupt_init -= thr->interrupt_counter; + thr->interrupt_counter = 0; + thr->heap->dbg_force_restart = 1; + } +#endif + +#if defined(DUK_USE_INTERRUPT_COUNTER) && defined(DUK_USE_DEBUG) + duk__interrupt_fixup(thr, entry_curr_thread); +#endif +} + +/* + * duk_handle_safe_call(): make a "C protected call" within the + * current activation. * * The allowed thread states for making a call are the same as for - * duk_handle_call(). + * duk_handle_call_xxx(). * - * Note that like duk_handle_call(), even if this call is protected, - * there are a few situations where the current (pre-entry) setjmp - * catcher (or a fatal error handler if no such catcher exists) is - * invoked: - * - * - Blatant API argument errors (e.g. num_stack_args is invalid, - * so we can't form a reasonable return stack) - * - * - Errors during error handling, e.g. failure to reallocate - * space in the value stack due to an alloc error - * - * Such errors propagate outwards, ultimately to the fatal error - * handler if nothing else. + * Error handling is similar to duk_handle_call_xxx(); errors may be thrown + * (and result in a fatal error) for insane arguments. */ /* XXX: bump preventcount by one for the duration of this call? */ -DUK_INTERNAL -duk_int_t duk_handle_safe_call(duk_hthread *thr, - duk_safe_call_function func, - duk_idx_t num_stack_args, - duk_idx_t num_stack_rets) { +DUK_INTERNAL duk_int_t duk_handle_safe_call(duk_hthread *thr, + duk_safe_call_function func, + duk_idx_t num_stack_args, + duk_idx_t num_stack_rets) { duk_context *ctx = (duk_context *) thr; duk_size_t entry_valstack_bottom_index; duk_size_t entry_callstack_top; @@ -49474,12 +58589,13 @@ duk_int_t duk_handle_safe_call(duk_hthread *thr, duk_int_t entry_call_recursion_depth; duk_hthread *entry_curr_thread; duk_uint_fast8_t entry_thread_state; + duk_instr_t **entry_ptr_curr_pc; +#if !defined(DUK_USE_CPP_EXCEPTIONS) duk_jmpbuf *old_jmpbuf_ptr = NULL; duk_jmpbuf our_jmpbuf; - duk_tval tv_tmp; +#endif duk_idx_t idx_retbase; duk_int_t retval; - duk_ret_t rc; DUK_ASSERT(thr != NULL); DUK_ASSERT(ctx != NULL); @@ -49491,6 +58607,7 @@ duk_int_t duk_handle_safe_call(duk_hthread *thr, entry_call_recursion_depth = thr->heap->call_recursion_depth; entry_curr_thread = thr->heap->curr_thread; /* Note: may be NULL if first call */ entry_thread_state = thr->state; + entry_ptr_curr_pc = thr->ptr_curr_pc; /* may be NULL */ idx_retbase = duk_get_top(ctx) - num_stack_args; /* Note: not a valid stack index if num_stack_args == 0 */ /* Note: cannot portably debug print a function pointer, hence 'func' not printed! */ @@ -49513,85 +58630,146 @@ duk_int_t duk_handle_safe_call(duk_hthread *thr, (long) entry_thread_state)); if (idx_retbase < 0) { - /* - * Since stack indices are not reliable, we can't do anything useful - * here. Invoke the existing setjmp catcher, or if it doesn't exist, - * call the fatal error handler. + /* Since stack indices are not reliable, we can't do anything useful + * here. Invoke the existing setjmp catcher, or if it doesn't exist, + * call the fatal error handler. */ - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); + DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS); } /* setjmp catchpoint setup */ +#if !defined(DUK_USE_CPP_EXCEPTIONS) old_jmpbuf_ptr = thr->heap->lj.jmpbuf_ptr; thr->heap->lj.jmpbuf_ptr = &our_jmpbuf; +#endif - if (DUK_SETJMP(thr->heap->lj.jmpbuf_ptr->jb) == 0) { - goto handle_call; +#if defined(DUK_USE_CPP_EXCEPTIONS) + try { +#else + if (DUK_LIKELY(DUK_SETJMP(thr->heap->lj.jmpbuf_ptr->jb) == 0)) { + /* Success path. */ +#endif + DUK_DDD(DUK_DDDPRINT("safe_call setjmp catchpoint setup complete")); + + duk__handle_safe_call_inner(thr, + func, + idx_retbase, + num_stack_rets, + entry_valstack_bottom_index, + entry_callstack_top, + entry_catchstack_top); + + /* Longjmp state is kept clean in success path */ + DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_UNKNOWN); + DUK_ASSERT(thr->heap->lj.iserror == 0); + DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value1)); + DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value2)); + +#if !defined(DUK_USE_CPP_EXCEPTIONS) + /* Note: either pointer may be NULL (at entry), so don't assert */ + thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr; +#endif + + retval = DUK_EXEC_SUCCESS; +#if defined(DUK_USE_CPP_EXCEPTIONS) + } catch (duk_internal_exception &exc) { +#else + } else { + /* Error path. */ +#endif + +#if defined(DUK_USE_CPP_EXCEPTIONS) + DUK_UNREF(exc); +#endif + + duk__handle_safe_call_error(thr, + idx_retbase, + num_stack_rets, + entry_valstack_bottom_index, + entry_callstack_top, + entry_catchstack_top +#if !defined(DUK_USE_CPP_EXCEPTIONS) + , old_jmpbuf_ptr +#endif + ); + + /* Longjmp state is cleaned up by error handling */ + DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_UNKNOWN); + DUK_ASSERT(thr->heap->lj.iserror == 0); + DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value1)); + DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&thr->heap->lj.value2)); + + retval = DUK_EXEC_ERROR; } +#if defined(DUK_USE_CPP_EXCEPTIONS) + catch (std::exception &exc) { + const char *what = exc.what(); + if (!what) { + what = "unknown"; + } + DUK_D(DUK_DPRINT("unexpected c++ std::exception (perhaps thrown by user code)")); + try { + DUK_ERROR(thr, DUK_ERR_API_ERROR, "caught invalid c++ std::exception '%s' (perhaps thrown by user code)", what); + } catch (duk_internal_exception exc) { + DUK_D(DUK_DPRINT("caught api error thrown from unexpected c++ std::exception")); + duk__handle_safe_call_error(thr, + idx_retbase, + num_stack_rets, + entry_valstack_bottom_index, + entry_callstack_top, + entry_catchstack_top); + retval = DUK_EXEC_ERROR; + } + } catch (...) { + DUK_D(DUK_DPRINT("unexpected c++ exception (perhaps thrown by user code)")); + try { + DUK_ERROR(thr, DUK_ERR_API_ERROR, "caught invalid c++ exception (perhaps thrown by user code)"); + } catch (duk_internal_exception exc) { + DUK_D(DUK_DPRINT("caught api error thrown from unexpected c++ exception")); + duk__handle_safe_call_error(thr, + idx_retbase, + num_stack_rets, + entry_valstack_bottom_index, + entry_callstack_top, + entry_catchstack_top); + retval = DUK_EXEC_ERROR; + } + } +#endif - /* - * Error during call. The error value is at heap->lj.value1. - * - * Careful with variable accesses here; must be assigned to before - * setjmp() or be declared volatile. See duk_handle_call(). - * - * The following are such variables: - * - duk_handle_safe_call() parameters - * - entry_* - * - idx_retbase - * - * The very first thing we do is restore the previous setjmp catcher. - * This means that any error in error handling will propagate outwards - * instead of causing a setjmp() re-entry above. The *only* actual - * errors that should happen here are allocation errors. - */ +#if !defined(DUK_USE_CPP_EXCEPTIONS) + DUK_ASSERT(thr->heap->lj.jmpbuf_ptr == old_jmpbuf_ptr); /* success/error path both do this */ +#endif - DUK_DDD(DUK_DDDPRINT("error caught during protected duk_handle_safe_call()")); + duk__handle_safe_call_shared(thr, + idx_retbase, + num_stack_rets, + entry_call_recursion_depth, + entry_curr_thread, + entry_thread_state, + entry_ptr_curr_pc); - DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_THROW); - DUK_ASSERT(thr->callstack_top >= entry_callstack_top); - DUK_ASSERT(thr->catchstack_top >= entry_catchstack_top); + return retval; +} - /* Note: either pointer may be NULL (at entry), so don't assert; - * these are now restored twice which is OK. - */ - thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr; +DUK_LOCAL void duk__handle_safe_call_inner(duk_hthread *thr, + duk_safe_call_function func, + duk_idx_t idx_retbase, + duk_idx_t num_stack_rets, + duk_size_t entry_valstack_bottom_index, + duk_size_t entry_callstack_top, + duk_size_t entry_catchstack_top) { + duk_context *ctx; + duk_ret_t rc; - duk_hthread_catchstack_unwind(thr, entry_catchstack_top); - duk_hthread_callstack_unwind(thr, entry_callstack_top); - thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index; - - /* [ ... | (crud) ] */ - - /* XXX: space in valstack? see discussion in duk_handle_call. */ - duk_push_tval(ctx, &thr->heap->lj.value1); - - /* [ ... | (crud) errobj ] */ - - DUK_ASSERT(duk_get_top(ctx) >= 1); /* at least errobj must be on stack */ - - /* check that the valstack has space for the final amount and any - * intermediate space needed; this is unoptimal but should be safe - */ - duk_require_stack_top(ctx, idx_retbase + num_stack_rets); /* final configuration */ - duk_require_stack(ctx, num_stack_rets); - - duk__safe_call_adjust_valstack(thr, idx_retbase, num_stack_rets, 1); /* 1 = num actual 'return values' */ - - /* [ ... | ] or [ ... | errobj (M * undefined)] where M = num_stack_rets - 1 */ - - retval = DUK_EXEC_ERROR; - goto shrink_and_finished; - - /* - * Handle call (inside setjmp) - */ - - handle_call: - - DUK_DDD(DUK_DDDPRINT("safe_call setjmp catchpoint setup complete")); + DUK_ASSERT(thr != NULL); + ctx = (duk_context *) thr; + DUK_ASSERT_CTX_VALID(ctx); + DUK_UNREF(entry_valstack_bottom_index); + DUK_UNREF(entry_callstack_top); + DUK_UNREF(entry_catchstack_top); /* * Thread state check and book-keeping. @@ -49654,7 +58832,7 @@ duk_int_t duk_handle_safe_call(duk_hthread *thr, DUK_DDD(DUK_DDDPRINT("safe_call, func rc=%ld", (long) rc)); /* - * Valstack manipulation for results + * Valstack manipulation for results. */ /* we're running inside the caller's activation, so no change in call/catch stack or valstack bottom */ @@ -49671,44 +58849,114 @@ duk_int_t duk_handle_safe_call(duk_hthread *thr, DUK_ASSERT(rc >= 0); if (duk_get_top(ctx) < rc) { - DUK_ERROR(thr, DUK_ERR_API_ERROR, "not enough stack values for safe_call rc"); + DUK_ERROR_API(thr, "not enough stack values for safe_call rc"); } + DUK_ASSERT(thr->catchstack_top == entry_catchstack_top); /* no need to unwind */ + DUK_ASSERT(thr->callstack_top == entry_callstack_top); + duk__safe_call_adjust_valstack(thr, idx_retbase, num_stack_rets, rc); + return; - /* Note: no need from callstack / catchstack shrink check */ - retval = DUK_EXEC_SUCCESS; - goto finished; + thread_state_error: + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid thread state for safe_call (%ld)", (long) thr->state); + DUK_UNREACHABLE(); +} - shrink_and_finished: - /* these are "soft" shrink checks, whose failures are ignored */ - /* XXX: would be nice if fast path was inlined */ - duk_hthread_catchstack_shrink_check(thr); - duk_hthread_callstack_shrink_check(thr); - goto finished; +DUK_LOCAL void duk__handle_safe_call_error(duk_hthread *thr, + duk_idx_t idx_retbase, + duk_idx_t num_stack_rets, + duk_size_t entry_valstack_bottom_index, + duk_size_t entry_callstack_top, + duk_size_t entry_catchstack_top +#if !defined(DUK_USE_CPP_EXCEPTIONS) + , duk_jmpbuf *old_jmpbuf_ptr +#endif + ) { + duk_context *ctx; - finished: - /* Note: either pointer may be NULL (at entry), so don't assert */ + DUK_ASSERT(thr != NULL); + ctx = (duk_context *) thr; + DUK_ASSERT_CTX_VALID(ctx); + + /* + * Error during call. The error value is at heap->lj.value1. + * + * The very first thing we do is restore the previous setjmp catcher. + * This means that any error in error handling will propagate outwards + * instead of causing a setjmp() re-entry above. + */ + + DUK_DDD(DUK_DDDPRINT("error caught during protected duk_handle_safe_call()")); + + /* Other longjmp types are handled by executor before propagating + * the error here. + */ + DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_THROW); + DUK_ASSERT(thr->callstack_top >= entry_callstack_top); + DUK_ASSERT(thr->catchstack_top >= entry_catchstack_top); + + /* Note: either pointer may be NULL (at entry), so don't assert. */ +#if !defined(DUK_USE_CPP_EXCEPTIONS) thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr; +#endif - /* These are just convenience "wiping" of state */ + DUK_ASSERT(thr->catchstack_top >= entry_catchstack_top); + DUK_ASSERT(thr->callstack_top >= entry_callstack_top); + duk_hthread_catchstack_unwind(thr, entry_catchstack_top); + duk_hthread_catchstack_shrink_check(thr); + duk_hthread_callstack_unwind(thr, entry_callstack_top); + duk_hthread_callstack_shrink_check(thr); + thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index; + + /* [ ... | (crud) ] */ + + /* XXX: space in valstack? see discussion in duk_handle_call_xxx(). */ + duk_push_tval(ctx, &thr->heap->lj.value1); + + /* [ ... | (crud) errobj ] */ + + DUK_ASSERT(duk_get_top(ctx) >= 1); /* at least errobj must be on stack */ + + /* check that the valstack has space for the final amount and any + * intermediate space needed; this is unoptimal but should be safe + */ + duk_require_stack_top(ctx, idx_retbase + num_stack_rets); /* final configuration */ + duk_require_stack(ctx, num_stack_rets); + + duk__safe_call_adjust_valstack(thr, idx_retbase, num_stack_rets, 1); /* 1 = num actual 'return values' */ + + /* [ ... | ] or [ ... | errobj (M * undefined)] where M = num_stack_rets - 1 */ + + /* These are just convenience "wiping" of state. Side effects should + * not be an issue here: thr->heap and thr->heap->lj have a stable + * pointer. Finalizer runs etc capture even out-of-memory errors so + * nothing should throw here. + */ thr->heap->lj.type = DUK_LJ_TYPE_UNKNOWN; thr->heap->lj.iserror = 0; + DUK_TVAL_SET_UNDEFINED_UPDREF(thr, &thr->heap->lj.value1); /* side effects */ + DUK_TVAL_SET_UNDEFINED_UPDREF(thr, &thr->heap->lj.value2); /* side effects */ +} - /* Side effects should not be an issue here: tv_tmp is local and - * thr->heap (and thr->heap->lj) have a stable pointer. Finalizer - * runs etc capture even out-of-memory errors so nothing should - * throw here. - */ - DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1); - DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->heap->lj.value1); - DUK_TVAL_DECREF(thr, &tv_tmp); +DUK_LOCAL void duk__handle_safe_call_shared(duk_hthread *thr, + duk_idx_t idx_retbase, + duk_idx_t num_stack_rets, + duk_int_t entry_call_recursion_depth, + duk_hthread *entry_curr_thread, + duk_uint_fast8_t entry_thread_state, + duk_instr_t **entry_ptr_curr_pc) { + duk_context *ctx; - DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value2); - DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->heap->lj.value2); - DUK_TVAL_DECREF(thr, &tv_tmp); + DUK_ASSERT(thr != NULL); + ctx = (duk_context *) thr; + DUK_ASSERT_CTX_VALID(ctx); + DUK_UNREF(ctx); + DUK_UNREF(idx_retbase); + DUK_UNREF(num_stack_rets); - DUK_DDD(DUK_DDDPRINT("setjmp catchpoint torn down")); + /* Restore entry thread executor curr_pc stack frame pointer. */ + thr->ptr_curr_pc = entry_ptr_curr_pc; /* XXX: because we unwind stacks above, thr->heap->curr_thread is at * risk of pointing to an already freed thread. This was indeed the @@ -49728,12 +58976,13 @@ duk_int_t duk_handle_safe_call(duk_hthread *thr, /* stack discipline consistency check */ DUK_ASSERT(duk_get_top(ctx) == idx_retbase + num_stack_rets); - return retval; + /* A debugger forced interrupt check is not needed here, as + * problematic safe calls are not caused by side effects. + */ - thread_state_error: - DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid thread state for safe_call (%ld)", (long) thr->state); - DUK_UNREACHABLE(); - return DUK_EXEC_ERROR; /* never executed */ +#if defined(DUK_USE_INTERRUPT_COUNTER) && defined(DUK_USE_DEBUG) + duk__interrupt_fixup(thr, entry_curr_thread); +#endif } /* @@ -49762,10 +59011,9 @@ duk_int_t duk_handle_safe_call(duk_hthread *thr, * return an error so caller can fall back to a normal call path. */ -DUK_INTERNAL -duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, - duk_idx_t num_stack_args, - duk_small_uint_t call_flags) { +DUK_INTERNAL duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, + duk_idx_t num_stack_args, + duk_small_uint_t call_flags) { duk_context *ctx = (duk_context *) thr; duk_size_t entry_valstack_bottom_index; duk_idx_t idx_func; /* valstack index of 'func' and retval (relative to entry valstack_bottom) */ @@ -49777,6 +59025,7 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, duk_activation *act; duk_hobject *env; duk_bool_t use_tailcall; + duk_instr_t **entry_ptr_curr_pc; DUK_ASSERT(thr != NULL); DUK_ASSERT(ctx != NULL); @@ -49792,11 +59041,19 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, (thr->state == DUK_HTHREAD_STATE_RUNNING && thr->heap->curr_thread == thr)); - /* if a tailcall: + /* If thr->ptr_curr_pc is set, sync curr_pc to act->pc. Then NULL + * thr->ptr_curr_pc so that it's not accidentally used with an incorrect + * activation when side effects occur. If we end up not making the + * call we must restore the value. + */ + entry_ptr_curr_pc = thr->ptr_curr_pc; + duk_hthread_sync_and_null_currpc(thr); + + /* if a tail call: * - an Ecmascript activation must be on top of the callstack * - there cannot be any active catchstack entries */ -#ifdef DUK_USE_ASSERTIONS +#if defined(DUK_USE_ASSERTIONS) if (call_flags & DUK_CALL_FLAG_IS_TAILCALL) { duk_size_t our_callstack_index; duk_size_t i; @@ -49822,6 +59079,7 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, #endif /* DUK_USE_ASSERTIONS */ entry_valstack_bottom_index = (duk_size_t) (thr->valstack_bottom - thr->valstack); + /* XXX: rework */ idx_func = duk_normalize_index(thr, -num_stack_args - 2); idx_args = idx_func + 2; @@ -49837,9 +59095,9 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, (long) idx_args, (long) entry_valstack_bottom_index)); - if (idx_func < 0 || idx_args < 0) { + if (DUK_UNLIKELY(idx_func < 0 || idx_args < 0)) { /* XXX: assert? compiler is responsible for this never happening */ - DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS); + DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS); } /* @@ -49862,6 +59120,7 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, func = duk__nonbound_func_lookup(ctx, idx_func, &num_stack_args, &tv_func, call_flags); if (func == NULL || !DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) { DUK_DDD(DUK_DDDPRINT("final target is a lightfunc/nativefunc, cannot do ecma-to-ecma call")); + thr->ptr_curr_pc = entry_ptr_curr_pc; return 0; } /* XXX: tv_func is not actually needed */ @@ -49883,7 +59142,7 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, /* * Preliminary activation record and valstack manipulation. * The concrete actions depend on whether the we're dealing - * with a tailcall (reuse an existing activation), a resume, + * with a tail call (reuse an existing activation), a resume, * or a normal call. * * The basic actions, in varying order, are: @@ -49914,17 +59173,16 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, act = thr->callstack + thr->callstack_top - 1; if (act->flags & DUK_ACT_FLAG_PREVENT_YIELD) { /* See: test-bug-tailcall-preventyield-assert.c. */ - DUK_DDD(DUK_DDDPRINT("tailcall prevented by current activation having DUK_ACT_FLAG_PREVENTYIELD")); + DUK_DDD(DUK_DDDPRINT("tail call prevented by current activation having DUK_ACT_FLAG_PREVENTYIELD")); use_tailcall = 0; } else if (DUK_HOBJECT_HAS_NOTAIL(func)) { - DUK_D(DUK_DPRINT("tailcall prevented by function having a notail flag")); + DUK_D(DUK_DPRINT("tail call prevented by function having a notail flag")); use_tailcall = 0; } } if (use_tailcall) { duk_tval *tv1, *tv2; - duk_tval tv_tmp; duk_size_t cs_index; duk_int_t i_stk; /* must be signed for loop structure */ duk_idx_t i_arg; @@ -49936,10 +59194,10 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, * the current activation (or simulate an unwind). In particular, the * current activation must be closed, otherwise something like * test-bug-reduce-judofyr.js results. Also catchstack needs be unwound - * because there may be non-error-catching label entries in valid tailcalls. + * because there may be non-error-catching label entries in valid tail calls. */ - DUK_DDD(DUK_DDDPRINT("is tailcall, reusing activation at callstack top, at index %ld", + DUK_DDD(DUK_DDDPRINT("is tail call, reusing activation at callstack top, at index %ld", (long) (thr->callstack_top - 1))); /* 'act' already set above */ @@ -49972,22 +59230,25 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, /* Start filling in the activation */ act->func = func; /* don't want an intermediate exposed state with func == NULL */ -#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY +#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY) act->prev_caller = NULL; #endif - act->pc = 0; /* don't want an intermediate exposed state with invalid pc */ + DUK_ASSERT(func != NULL); + DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(func)); + /* don't want an intermediate exposed state with invalid pc */ + act->curr_pc = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) func); #if defined(DUK_USE_DEBUGGER_SUPPORT) act->prev_line = 0; #endif DUK_TVAL_SET_OBJECT(&act->tv_func, func); /* borrowed, no refcount */ -#ifdef DUK_USE_REFERENCE_COUNTING +#if defined(DUK_USE_REFERENCE_COUNTING) DUK_HOBJECT_INCREF(thr, func); act = thr->callstack + thr->callstack_top - 1; /* side effects (currently none though) */ #endif -#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY -#ifdef DUK_USE_TAILCALL -#error incorrect options: tailcalls enabled with function caller property +#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY) +#if defined(DUK_USE_TAILCALL) +#error incorrect options: tail calls enabled with function caller property #endif /* XXX: this doesn't actually work properly for tail calls, so * tail calls are disabled when DUK_USE_NONSTD_FUNC_CALLER_PROPERTY @@ -50004,7 +59265,6 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, DUK_ASSERT(DUK_ACT_GET_FUNC(act) == func); /* already updated */ DUK_ASSERT(act->var_env == NULL); /* already NULLed (by unwind) */ DUK_ASSERT(act->lex_env == NULL); /* already NULLed (by unwind) */ - DUK_ASSERT(act->pc == 0); /* already zeroed */ act->idx_bottom = entry_valstack_bottom_index; /* tail call -> reuse current "frame" */ DUK_ASSERT(nregs >= 0); #if 0 /* topmost activation idx_retval is considered garbage, no need to init */ @@ -50019,7 +59279,7 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, * [ ... this_old | (crud) func this_new arg1 ... argN ] * --> [ ... this_new | arg1 ... argN ] * - * For tailcalling to work properly, the valstack bottom must not grow + * For tail calling to work properly, the valstack bottom must not grow * here; otherwise crud would accumulate on the valstack. */ @@ -50027,10 +59287,7 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, tv2 = thr->valstack_bottom + idx_func + 1; DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top); /* tv1 is -below- valstack_bottom */ DUK_ASSERT(tv2 >= thr->valstack_bottom && tv2 < thr->valstack_top); - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_TVAL(tv1, tv2); - DUK_TVAL_INCREF(thr, tv1); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_TVAL_UPDREF(thr, tv1, tv2); /* side effects */ for (i_arg = 0; i_arg < idx_args; i_arg++) { /* XXX: block removal API primitive */ @@ -50044,7 +59301,7 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, /* [ ... this_new | arg1 ... argN ] */ } else { - DUK_DDD(DUK_DDDPRINT("not a tailcall, pushing a new activation to callstack, to index %ld", + DUK_DDD(DUK_DDDPRINT("not a tail call, pushing a new activation to callstack, to index %ld", (long) (thr->callstack_top))); duk_hthread_callstack_grow(thr); @@ -50076,10 +59333,12 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, act->func = func; act->var_env = NULL; act->lex_env = NULL; -#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY +#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY) act->prev_caller = NULL; #endif - act->pc = 0; + DUK_ASSERT(func != NULL); + DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(func)); + act->curr_pc = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) func); #if defined(DUK_USE_DEBUGGER_SUPPORT) act->prev_line = 0; #endif @@ -50092,14 +59351,14 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, DUK_HOBJECT_INCREF(thr, func); /* act->func */ -#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY +#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY) duk__update_func_caller_prop(thr, func); act = thr->callstack + thr->callstack_top - 1; #endif } - /* [... func this arg1 ... argN] (not tail call) - * [this | arg1 ... argN] (tail call) + /* [ ... func this arg1 ... argN ] (not tail call) + * [ this | arg1 ... argN ] (tail call) * * idx_args updated to match */ @@ -50113,6 +59372,8 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, * Delayed creation (on demand) is handled in duk_js_var.c. */ + /* XXX: unify handling with native call. */ + DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func)); /* bound function chain has already been resolved */ if (!DUK_HOBJECT_HAS_NEWENV(func)) { @@ -50140,7 +59401,7 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, env = duk_create_activation_environment_record(thr, func, act->idx_bottom); DUK_ASSERT(env != NULL); - /* [... arg1 ... argN envobj] */ + /* [ ... arg1 ... argN envobj ] */ /* original input stack before nargs/nregs handling must be * intact for 'arguments' object @@ -50148,8 +59409,9 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, DUK_ASSERT(DUK_HOBJECT_HAS_CREATEARGS(func)); duk__handle_createargs_for_call(thr, func, env, num_stack_args); - /* [... arg1 ... argN envobj] */ + /* [ ... arg1 ... argN envobj ] */ + act = thr->callstack + thr->callstack_top - 1; act->lex_env = env; act->var_env = env; DUK_HOBJECT_INCREF(thr, act->lex_env); @@ -50157,7 +59419,7 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, duk_pop(ctx); env_done: - /* [... arg1 ... argN] */ + /* [ ... arg1 ... argN ] */ /* * Setup value stack: clamp to 'nargs', fill up to 'nregs' @@ -50207,7 +59469,7 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, * Recursion limits are in key functions to prevent arbitrary C recursion: * function body parsing, statement parsing, and expression parsing. * - * See doc/compiler.txt for discussion on the design. + * See doc/compiler.rst for discussion on the design. * * A few typing notes: * @@ -50235,6 +59497,9 @@ duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, #define DUK__MAX_FUNCS DUK_BC_BC_MAX #define DUK__MAX_TEMPS 0xffffL +/* Initial bytecode size allocation. */ +#define DUK__BC_INITIAL_INSTS 256 + #define DUK__RECURSION_INCREASE(comp_ctx,thr) do { \ DUK_DDD(DUK_DDDPRINT("RECURSION INCREASE: %s:%ld", (const char *) DUK_FILE_MACRO, (long) DUK_LINE_MACRO)); \ duk__recursion_increase((comp_ctx)); \ @@ -50304,7 +59569,7 @@ DUK_LOCAL_DECL duk_int_t duk__emit_jump_empty(duk_compiler_ctx *comp_ctx); DUK_LOCAL_DECL void duk__insert_jump_entry(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc); DUK_LOCAL_DECL void duk__patch_jump(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc, duk_int_t target_pc); DUK_LOCAL_DECL void duk__patch_jump_here(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc); -DUK_LOCAL_DECL void duk__patch_trycatch(duk_compiler_ctx *comp_ctx, duk_int_t trycatch_pc, duk_regconst_t reg_catch, duk_regconst_t const_varname, duk_small_uint_t flags); +DUK_LOCAL_DECL void duk__patch_trycatch(duk_compiler_ctx *comp_ctx, duk_int_t ldconst_pc, duk_int_t trycatch_pc, duk_regconst_t reg_catch, duk_regconst_t const_varname, duk_small_uint_t flags); DUK_LOCAL_DECL void duk__emit_if_false_skip(duk_compiler_ctx *comp_ctx, duk_regconst_t regconst); DUK_LOCAL_DECL void duk__emit_if_true_skip(duk_compiler_ctx *comp_ctx, duk_regconst_t regconst); DUK_LOCAL_DECL void duk__emit_invalid(duk_compiler_ctx *comp_ctx); @@ -50333,10 +59598,11 @@ duk_regconst_t duk__ivalue_toregconst_raw(duk_compiler_ctx *comp_ctx, duk_small_uint_t flags); DUK_LOCAL_DECL duk_reg_t duk__ivalue_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x); #if 0 /* unused */ -DUK_LOCAL_DECL duk_reg_t duk__ivalue_totempreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x); +DUK_LOCAL_DECL duk_reg_t duk__ivalue_totemp(duk_compiler_ctx *comp_ctx, duk_ivalue *x); #endif DUK_LOCAL_DECL void duk__ivalue_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x, duk_int_t forced_reg); DUK_LOCAL_DECL duk_regconst_t duk__ivalue_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *x); +DUK_LOCAL_DECL duk_regconst_t duk__ivalue_totempconst(duk_compiler_ctx *comp_ctx, duk_ivalue *x); /* identifier handling */ DUK_LOCAL_DECL duk_reg_t duk__lookup_active_register_binding(duk_compiler_ctx *comp_ctx); @@ -50359,19 +59625,24 @@ DUK_LOCAL_DECL void duk__expr(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_s DUK_LOCAL_DECL void duk__exprtop(duk_compiler_ctx *ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); /* convenience helpers */ -DUK_LOCAL_DECL duk_reg_t duk__expr_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); #if 0 /* unused */ -DUK_LOCAL_DECL duk_reg_t duk__expr_totempreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); +DUK_LOCAL_DECL duk_reg_t duk__expr_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); +#endif +#if 0 /* unused */ +DUK_LOCAL_DECL duk_reg_t duk__expr_totemp(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); #endif DUK_LOCAL_DECL void duk__expr_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags, duk_reg_t forced_reg); DUK_LOCAL_DECL duk_regconst_t duk__expr_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); +#if 0 /* unused */ +DUK_LOCAL_DECL duk_regconst_t duk__expr_totempconst(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); +#endif DUK_LOCAL_DECL void duk__expr_toplain(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); DUK_LOCAL_DECL void duk__expr_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); DUK_LOCAL_DECL duk_reg_t duk__exprtop_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); #if 0 /* unused */ -DUK_LOCAL_DECL duk_reg_t duk__exprtop_totempreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); -DUK_LOCAL_DECL void duk__exprtop_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags, duk_reg_t forced_reg); +DUK_LOCAL_DECL duk_reg_t duk__exprtop_totemp(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); #endif +DUK_LOCAL_DECL void duk__exprtop_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags, duk_reg_t forced_reg); DUK_LOCAL_DECL duk_regconst_t duk__exprtop_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); #if 0 /* unused */ DUK_LOCAL_DECL void duk__exprtop_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags); @@ -50385,7 +59656,7 @@ DUK_LOCAL_DECL duk_bool_t duk__nud_object_literal_key_check(duk_compiler_ctx *co /* statement parsing */ DUK_LOCAL_DECL void duk__parse_var_decl(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t expr_flags, duk_reg_t *out_reg_varbind, duk_regconst_t *out_rc_varname); -DUK_LOCAL_DECL void duk__parse_var_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res); +DUK_LOCAL_DECL void duk__parse_var_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t expr_flags); DUK_LOCAL_DECL void duk__parse_for_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site); DUK_LOCAL_DECL void duk__parse_switch_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site); DUK_LOCAL_DECL void duk__parse_if_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res); @@ -50419,7 +59690,7 @@ DUK_LOCAL_DECL duk_int_t duk__parse_func_like_fnum(duk_compiler_ctx *comp_ctx, d /* XXX: actually single step levels would work just fine, clean up */ -/* binding power "levels" (see doc/compiler.txt) */ +/* binding power "levels" (see doc/compiler.rst) */ #define DUK__BP_INVALID 0 /* always terminates led() */ #define DUK__BP_EOF 2 #define DUK__BP_CLOSING 4 /* token closes expression, e.g. ')', ']' */ @@ -50453,8 +59724,6 @@ DUK_LOCAL_DECL duk_int_t duk__parse_func_like_fnum(duk_compiler_ctx *comp_ctx, d DUK_LOCAL const duk_uint8_t duk__token_lbp[] = { DUK__MK_LBP(DUK__BP_EOF), /* DUK_TOK_EOF */ - DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_LINETERM */ - DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_COMMENT */ DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP), /* DUK_TOK_IDENTIFIER */ DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_BREAK */ DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_CASE */ @@ -50479,11 +59748,11 @@ DUK_LOCAL const duk_uint8_t duk__token_lbp[] = { DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_TRY */ DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_TYPEOF */ DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_VAR */ + DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_CONST */ DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_VOID */ DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_WHILE */ DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_WITH */ DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_CLASS */ - DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_CONST */ DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_ENUM */ DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_EXPORT */ DUK__MK_LBP(DUK__BP_INVALID), /* DUK_TOK_EXTENDS */ @@ -50608,7 +59877,7 @@ DUK_LOCAL void duk__advance_helper(duk_compiler_ctx *comp_ctx, duk_small_int_t e * We can use either 't' or 't_nores'; the latter would not * recognize keywords. Some keywords can be followed by a * RegExp (e.g. "return"), so using 't' is better. This is - * not trivial, see doc/compiler.txt. + * not trivial, see doc/compiler.rst. */ regexp = 1; @@ -50679,7 +59948,6 @@ DUK_LOCAL void duk__init_func_valstack_slots(duk_compiler_ctx *comp_ctx) { DUK_MEMZERO(func, sizeof(*func)); /* intentional overlap with earlier memzero */ #ifdef DUK_USE_EXPLICIT_NULL_INIT func->h_name = NULL; - func->h_code = NULL; func->h_consts = NULL; func->h_funcs = NULL; func->h_decls = NULL; @@ -50691,13 +59959,8 @@ DUK_LOCAL void duk__init_func_valstack_slots(duk_compiler_ctx *comp_ctx) { duk_require_stack(ctx, DUK__FUNCTION_INIT_REQUIRE_SLOTS); - /* XXX: getter for dynamic buffer */ - - duk_push_dynamic_buffer(ctx, 0); - func->code_idx = entry_top + 0; - func->h_code = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, entry_top + 0); - DUK_ASSERT(func->h_code != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(func->h_code)); + DUK_BW_INIT_PUSHBUF(thr, &func->bw_code, DUK__BC_INITIAL_INSTS * sizeof(duk_compiler_instr)); + /* code_idx = entry_top + 0 */ duk_push_array(ctx); func->consts_idx = entry_top + 1; @@ -50724,7 +59987,7 @@ DUK_LOCAL void duk__init_func_valstack_slots(duk_compiler_ctx *comp_ctx) { func->labelinfos_idx = entry_top + 5; func->h_labelinfos = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, entry_top + 5); DUK_ASSERT(func->h_labelinfos != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(func->h_labelinfos)); + DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(func->h_labelinfos) && !DUK_HBUFFER_HAS_EXTERNAL(func->h_labelinfos)); duk_push_array(ctx); func->argnames_idx = entry_top + 6; @@ -50743,9 +60006,11 @@ DUK_LOCAL void duk__reset_func_for_pass2(duk_compiler_ctx *comp_ctx) { duk_hthread *thr = comp_ctx->thr; duk_context *ctx = (duk_context *) thr; - /* XXX: reset buffers while keeping existing spare */ + /* reset bytecode buffer but keep current size; pass 2 will + * require same amount or more. + */ + DUK_BW_RESET_SIZE(thr, &func->bw_code); - duk_hbuffer_reset(thr, func->h_code); duk_hobject_set_length_zero(thr, func->h_consts); /* keep func->h_funcs; inner functions are not reparsed to avoid O(depth^2) parsing */ func->fnum_next = 0; @@ -50798,9 +60063,9 @@ DUK_LOCAL duk_int_t duk__cleanup_varmap(duk_compiler_ctx *comp_ctx) { tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, h_varmap, i); if (!DUK_TVAL_IS_NUMBER(tv)) { DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv)); - DUK_TVAL_SET_UNDEFINED_UNUSED(tv); DUK_HOBJECT_E_SET_KEY(thr->heap, h_varmap, i, NULL); DUK_HSTRING_DECREF(thr, h_key); + /* when key is NULL, value is garbage so no need to set */ } else { ret++; } @@ -50834,10 +60099,6 @@ DUK_LOCAL void duk__convert_to_func_template(duk_compiler_ctx *comp_ctx, duk_boo duk_tval *tv; DUK_DDD(DUK_DDDPRINT("converting duk_compiler_func to function/template")); - DUK_DD(DUK_DDPRINT("code=%!xO consts=%!O funcs=%!O", - (duk_heaphdr *) func->h_code, - (duk_heaphdr *) func->h_consts, - (duk_heaphdr *) func->h_funcs)); /* * Push result object and init its flags @@ -50904,9 +60165,9 @@ DUK_LOCAL void duk__convert_to_func_template(duk_compiler_ctx *comp_ctx, duk_boo * so the building process is atomic. */ - consts_count = duk_hobject_get_length(comp_ctx->thr, func->h_consts); - funcs_count = duk_hobject_get_length(comp_ctx->thr, func->h_funcs) / 3; - code_count = DUK_HBUFFER_GET_SIZE(func->h_code) / sizeof(duk_compiler_instr); + consts_count = duk_hobject_get_length(thr, func->h_consts); + funcs_count = duk_hobject_get_length(thr, func->h_funcs) / 3; + code_count = DUK_BW_GET_SIZE(thr, &func->bw_code) / sizeof(duk_compiler_instr); code_size = code_count * sizeof(duk_instr_t); data_size = consts_count * sizeof(duk_tval) + @@ -50927,7 +60188,7 @@ DUK_LOCAL void duk__convert_to_func_template(duk_compiler_ctx *comp_ctx, duk_boo DUK_HCOMPILEDFUNCTION_SET_DATA(thr->heap, h_res, (duk_hbuffer *) h_data); DUK_HEAPHDR_INCREF(thr, h_data); - p_const = (duk_tval *) DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, h_data); + p_const = (duk_tval *) (void *) DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, h_data); for (i = 0; i < consts_count; i++) { DUK_ASSERT(i <= DUK_UARRIDX_MAX); /* const limits */ tv = duk_hobject_find_existing_array_entry_tval_ptr(thr->heap, func->h_consts, (duk_uarridx_t) i); @@ -50961,8 +60222,7 @@ DUK_LOCAL void duk__convert_to_func_template(duk_compiler_ctx *comp_ctx, duk_boo DUK_HCOMPILEDFUNCTION_SET_BYTECODE(thr->heap, h_res, p_instr); /* copy bytecode instructions one at a time */ - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(func->h_code)); - q_instr = (duk_compiler_instr *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, func->h_code); + q_instr = (duk_compiler_instr *) (void *) DUK_BW_GET_BASEPTR(thr, &func->bw_code); for (i = 0; i < code_count; i++) { p_instr[i] = q_instr[i].ins; } @@ -51112,8 +60372,8 @@ DUK_LOCAL void duk__convert_to_func_template(duk_compiler_ctx *comp_ctx, duk_boo */ DUK_ASSERT(func->temp_max >= 0); - h_res->nregs = func->temp_max; - h_res->nargs = duk_hobject_get_length(thr, func->h_argnames); + h_res->nregs = (duk_uint16_t) func->temp_max; + h_res->nargs = (duk_uint16_t) duk_hobject_get_length(thr, func->h_argnames); DUK_ASSERT(h_res->nregs >= h_res->nargs); /* pass2 allocation handles this */ #if defined(DUK_USE_DEBUGGER_SUPPORT) h_res->start_line = (duk_uint32_t) func->min_line; @@ -51207,34 +60467,25 @@ DUK_LOCAL void duk__convert_to_func_template(duk_compiler_ctx *comp_ctx, duk_boo /* XXX: macro smaller than call? */ DUK_LOCAL duk_int_t duk__get_current_pc(duk_compiler_ctx *comp_ctx) { - return (duk_int_t) (DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_code) / sizeof(duk_compiler_instr)); + duk_compiler_func *func; + func = &comp_ctx->curr_func; + return (duk_int_t) (DUK_BW_GET_SIZE(comp_ctx->thr, &func->bw_code) / sizeof(duk_compiler_instr)); } DUK_LOCAL duk_compiler_instr *duk__get_instr_ptr(duk_compiler_ctx *comp_ctx, duk_int_t pc) { - duk_compiler_func *f = &comp_ctx->curr_func; - duk_uint8_t *p; - duk_compiler_instr *code_begin, *code_end; - - p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(comp_ctx->thr->heap, f->h_code); - code_begin = (duk_compiler_instr *) p; - code_end = (duk_compiler_instr *) (p + DUK_HBUFFER_GET_SIZE(f->h_code)); - DUK_UNREF(code_end); - DUK_ASSERT(pc >= 0); - DUK_ASSERT((duk_size_t) pc < (duk_size_t) (code_end - code_begin)); - - return code_begin + pc; + DUK_ASSERT((duk_size_t) pc < (duk_size_t) (DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) / sizeof(duk_compiler_instr))); + return ((duk_compiler_instr *) (void *) DUK_BW_GET_BASEPTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code)) + pc; } /* emit instruction; could return PC but that's not needed in the majority * of cases. */ DUK_LOCAL void duk__emit(duk_compiler_ctx *comp_ctx, duk_instr_t ins) { - duk_hbuffer_dynamic *h; #if defined(DUK_USE_PC2LINE) duk_int_t line; #endif - duk_compiler_instr instr; + duk_compiler_instr *instr; DUK_DDD(DUK_DDDPRINT("duk__emit: 0x%08lx curr_token.start_line=%ld prev_token.start_line=%ld pc=%ld --> %!I", (unsigned long) ins, @@ -51243,7 +60494,9 @@ DUK_LOCAL void duk__emit(duk_compiler_ctx *comp_ctx, duk_instr_t ins) { (long) duk__get_current_pc(comp_ctx), (duk_instr_t) ins)); - h = comp_ctx->curr_func.h_code; + instr = (duk_compiler_instr *) (void *) DUK_BW_ENSURE_GETPTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code, sizeof(duk_compiler_instr)); + DUK_BW_ADD_PTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code, sizeof(duk_compiler_instr)); + #if defined(DUK_USE_PC2LINE) /* The line number tracking is a bit inconsistent right now, which * affects debugger accuracy. Mostly call sites emit opcodes when @@ -51260,9 +60513,9 @@ DUK_LOCAL void duk__emit(duk_compiler_ctx *comp_ctx, duk_instr_t ins) { } #endif - instr.ins = ins; + instr->ins = ins; #if defined(DUK_USE_PC2LINE) - instr.line = line; + instr->line = line; #endif #if defined(DUK_USE_DEBUGGER_SUPPORT) if (line < comp_ctx->curr_func.min_line) { @@ -51274,21 +60527,26 @@ DUK_LOCAL void duk__emit(duk_compiler_ctx *comp_ctx, duk_instr_t ins) { #endif /* Limit checks for bytecode byte size and line number. */ + if (DUK_UNLIKELY(DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) > DUK_USE_ESBC_MAX_BYTES)) { + goto fail_bc_limit; + } #if defined(DUK_USE_PC2LINE) && defined(DUK_USE_ESBC_LIMITS) #if defined(DUK_USE_BUFLEN16) /* Buffer length is bounded to 0xffff automatically, avoid compile warning. */ if (DUK_UNLIKELY(line > DUK_USE_ESBC_MAX_LINENUMBER)) { - DUK_ERROR(comp_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_BYTECODE_LIMIT); + goto fail_bc_limit; } #else - if (DUK_UNLIKELY(line > DUK_USE_ESBC_MAX_LINENUMBER || - DUK_HBUFFER_GET_SIZE((duk_hbuffer *) h) > DUK_USE_ESBC_MAX_BYTES)) { - DUK_ERROR(comp_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_BYTECODE_LIMIT); + if (DUK_UNLIKELY(line > DUK_USE_ESBC_MAX_LINENUMBER)) { + goto fail_bc_limit; } #endif #endif - duk_hbuffer_append_bytes(comp_ctx->thr, h, (duk_uint8_t *) &instr, sizeof(instr)); + return; + + fail_bc_limit: + DUK_ERROR(comp_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_BYTECODE_LIMIT); } /* Update function min/max line from current token. Needed to improve @@ -51750,12 +61008,10 @@ DUK_LOCAL void duk__emit_load_int32_noshuffle(duk_compiler_ctx *comp_ctx, duk_re #endif DUK_LOCAL void duk__emit_jump(duk_compiler_ctx *comp_ctx, duk_int_t target_pc) { - duk_hbuffer_dynamic *h; duk_int_t curr_pc; duk_int_t offset; - h = comp_ctx->curr_func.h_code; - curr_pc = (duk_int_t) (DUK_HBUFFER_GET_SIZE(h) / sizeof(duk_compiler_instr)); + curr_pc = (duk_int_t) (DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) / sizeof(duk_compiler_instr)); offset = (duk_int_t) target_pc - (duk_int_t) curr_pc - 1; DUK_ASSERT(offset + DUK_BC_JUMP_BIAS >= DUK_BC_ABC_MIN); DUK_ASSERT(offset + DUK_BC_JUMP_BIAS <= DUK_BC_ABC_MAX); @@ -51774,26 +61030,35 @@ DUK_LOCAL duk_int_t duk__emit_jump_empty(duk_compiler_ctx *comp_ctx) { * currently needed for compiling for-in. */ DUK_LOCAL void duk__insert_jump_entry(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc) { - duk_hbuffer_dynamic *h; #if defined(DUK_USE_PC2LINE) duk_int_t line; #endif - duk_compiler_instr instr; + duk_compiler_instr *instr; duk_size_t offset; - h = comp_ctx->curr_func.h_code; + offset = jump_pc * sizeof(duk_compiler_instr), + instr = (duk_compiler_instr *) (void *) + DUK_BW_INSERT_ENSURE_AREA(comp_ctx->thr, + &comp_ctx->curr_func.bw_code, + offset, + sizeof(duk_compiler_instr)); + #if defined(DUK_USE_PC2LINE) line = comp_ctx->curr_token.start_line; /* approximation, close enough */ #endif - - instr.ins = DUK_ENC_OP_ABC(DUK_OP_JUMP, 0); + instr->ins = DUK_ENC_OP_ABC(DUK_OP_JUMP, 0); #if defined(DUK_USE_PC2LINE) - instr.line = line; + instr->line = line; #endif - offset = jump_pc * sizeof(duk_compiler_instr); + DUK_BW_ADD_PTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code, sizeof(duk_compiler_instr)); + if (DUK_UNLIKELY(DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) > DUK_USE_ESBC_MAX_BYTES)) { + goto fail_bc_limit; + } + return; - duk_hbuffer_insert_bytes(comp_ctx->thr, h, offset, (duk_uint8_t *) &instr, sizeof(instr)); + fail_bc_limit: + DUK_ERROR(comp_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_BYTECODE_LIMIT); } /* Does not assume that jump_pc contains a DUK_OP_JUMP previously; this is intentional @@ -51827,31 +61092,42 @@ DUK_LOCAL void duk__patch_jump_here(duk_compiler_ctx *comp_ctx, duk_int_t jump_p duk__patch_jump(comp_ctx, jump_pc, duk__get_current_pc(comp_ctx)); } -DUK_LOCAL void duk__patch_trycatch(duk_compiler_ctx *comp_ctx, duk_int_t trycatch_pc, duk_regconst_t reg_catch, duk_regconst_t const_varname, duk_small_uint_t flags) { +DUK_LOCAL void duk__patch_trycatch(duk_compiler_ctx *comp_ctx, duk_int_t ldconst_pc, duk_int_t trycatch_pc, duk_regconst_t reg_catch, duk_regconst_t const_varname, duk_small_uint_t flags) { duk_compiler_instr *instr; + DUK_ASSERT((reg_catch & DUK__CONST_MARKER) == 0); + + instr = duk__get_instr_ptr(comp_ctx, ldconst_pc); + DUK_ASSERT(DUK_DEC_OP(instr->ins) == DUK_OP_LDCONST); + DUK_ASSERT(instr != NULL); + if (const_varname & DUK__CONST_MARKER) { + /* Have a catch variable. */ + const_varname = const_varname & (~DUK__CONST_MARKER); + if (reg_catch > DUK_BC_BC_MAX || const_varname > DUK_BC_BC_MAX) { + /* Catch attempts to use out-of-range reg/const. Without this + * check Duktape 0.12.0 could generate invalid code which caused + * an assert failure on execution. This error is triggered e.g. + * for functions with a lot of constants and a try-catch statement. + * Shuffling or opcode semantics change is needed to fix the issue. + * See: test-bug-trycatch-many-constants.js. + */ + DUK_D(DUK_DPRINT("failed to patch trycatch: flags=%ld, reg_catch=%ld, const_varname=%ld (0x%08lx)", + (long) flags, (long) reg_catch, (long) const_varname, (long) const_varname)); + DUK_ERROR(comp_ctx->thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_REG_LIMIT); + } + instr->ins |= DUK_ENC_OP_A_BC(0, 0, const_varname); + } else { + /* No catch variable, e.g. a try-finally; replace LDCONST with + * NOP to avoid a bogus LDCONST. + */ + instr->ins = DUK_ENC_OP_A(DUK_OP_EXTRA, DUK_EXTRAOP_NOP); + } + instr = duk__get_instr_ptr(comp_ctx, trycatch_pc); DUK_ASSERT(instr != NULL); - DUK_ASSERT_DISABLE(flags >= DUK_BC_A_MIN); DUK_ASSERT(flags <= DUK_BC_A_MAX); - - DUK_ASSERT((reg_catch & DUK__CONST_MARKER) == 0); - const_varname = const_varname & (~DUK__CONST_MARKER); - if (reg_catch > DUK_BC_B_MAX || const_varname > DUK_BC_C_MAX) { - /* Catch attempts to use out-of-range reg/const. Without this - * check Duktape 0.12.0 could generate invalid code which caused - * an assert failure on execution. This error is triggered e.g. - * for functions with a lot of constants and a try-catch statement. - * Shuffling or opcode semantics change is needed to fix the issue. - * See: test-bug-trycatch-many-constants.js. - */ - DUK_D(DUK_DPRINT("failed to patch trycatch: flags=%ld, reg_catch=%ld, const_varname=%ld (0x%08lx)", - (long) flags, (long) reg_catch, (long) const_varname, (long) const_varname)); - DUK_ERROR(comp_ctx->thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_REG_LIMIT); - } - - instr->ins = DUK_ENC_OP_A_B_C(DUK_OP_TRYCATCH, flags, reg_catch, const_varname); + instr->ins = DUK_ENC_OP_A_BC(DUK_OP_TRYCATCH, flags, reg_catch); } DUK_LOCAL void duk__emit_if_false_skip(duk_compiler_ctx *comp_ctx, duk_regconst_t regconst) { @@ -51882,23 +61158,18 @@ DUK_LOCAL void duk__emit_invalid(duk_compiler_ctx *comp_ctx) { */ DUK_LOCAL void duk__peephole_optimize_bytecode(duk_compiler_ctx *comp_ctx) { - duk_hbuffer_dynamic *h; duk_compiler_instr *bc; duk_small_uint_t iter; duk_int_t i, n; duk_int_t count_opt; - h = comp_ctx->curr_func.h_code; - DUK_ASSERT(h != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(h)); - - bc = (duk_compiler_instr *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(comp_ctx->thr->heap, h); + bc = (duk_compiler_instr *) (void *) DUK_BW_GET_BASEPTR(comp_ctx->thr, &comp_ctx->curr_func.bw_code); #if defined(DUK_USE_BUFLEN16) /* No need to assert, buffer size maximum is 0xffff. */ #else - DUK_ASSERT(DUK_HBUFFER_GET_SIZE(h) / sizeof(duk_compiler_instr) <= DUK_INT_MAX); /* bytecode limits */ + DUK_ASSERT((duk_size_t) DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) / sizeof(duk_compiler_instr) <= (duk_size_t) DUK_INT_MAX); /* bytecode limits */ #endif - n = (duk_int_t) (DUK_HBUFFER_GET_SIZE(h) / sizeof(duk_compiler_instr)); + n = (duk_int_t) (DUK_BW_GET_SIZE(comp_ctx->thr, &comp_ctx->curr_func.bw_code) / sizeof(duk_compiler_instr)); for (iter = 0; iter < DUK_COMPILER_PEEPHOLE_MAXITER; iter++) { count_opt = 0; @@ -51964,11 +61235,35 @@ DUK_LOCAL void duk__peephole_optimize_bytecode(duk_compiler_ctx *comp_ctx) { * code (it is checked as it is used). */ #define DUK__IVAL_FLAG_ALLOW_CONST (1 << 0) /* allow a constant to be returned */ -#define DUK__IVAL_FLAG_REQUIRE_TEMP (1 << 1) /* require a (mutable) temporary as a result */ +#define DUK__IVAL_FLAG_REQUIRE_TEMP (1 << 1) /* require a (mutable) temporary as a result (or a const if allowed) */ #define DUK__IVAL_FLAG_REQUIRE_SHORT (1 << 2) /* require a short (8-bit) reg/const which fits into bytecode B/C slot */ /* XXX: some code might benefit from DUK__SETTEMP_IFTEMP(ctx,x) */ +#if 0 /* enable manually for dumping */ +#define DUK__DUMP_ISPEC(compctx,ispec) do { duk__dump_ispec((compctx), (ispec)); } while (0) +#define DUK__DUMP_IVALUE(compctx,ivalue) do { duk__dump_ivalue((compctx), (ivalue)); } while (0) + +DUK_LOCAL void duk__dump_ispec(duk_compiler_ctx *comp_ctx, duk_ispec *x) { + DUK_D(DUK_DPRINT("ispec dump: t=%ld regconst=0x%08lx, valstack_idx=%ld, value=%!T", + (long) x->t, (unsigned long) x->regconst, (long) x->valstack_idx, + duk_get_tval((duk_context *) comp_ctx->thr, x->valstack_idx))); +} +DUK_LOCAL void duk__dump_ivalue(duk_compiler_ctx *comp_ctx, duk_ivalue *x) { + DUK_D(DUK_DPRINT("ivalue dump: t=%ld op=%ld " + "x1={t=%ld regconst=0x%08lx valstack_idx=%ld value=%!T} " + "x2={t=%ld regconst=0x%08lx valstack_idx=%ld value=%!T}", + (long) x->t, (long) x->op, + (long) x->x1.t, (unsigned long) x->x1.regconst, (long) x->x1.valstack_idx, + duk_get_tval((duk_context *) comp_ctx->thr, x->x1.valstack_idx), + (long) x->x2.t, (unsigned long) x->x2.regconst, (long) x->x2.valstack_idx, + duk_get_tval((duk_context *) comp_ctx->thr, x->x2.valstack_idx))); +} +#else +#define DUK__DUMP_ISPEC(comp_ctx,x) do {} while (0) +#define DUK__DUMP_IVALUE(comp_ctx,x) do {} while (0) +#endif + DUK_LOCAL void duk__copy_ispec(duk_compiler_ctx *comp_ctx, duk_ispec *src, duk_ispec *dst) { duk_context *ctx = (duk_context *) comp_ctx->thr; @@ -52204,6 +61499,7 @@ duk_regconst_t duk__ispec_toregconst_raw(duk_compiler_ctx *comp_ctx, duk_double_t dval; duk_int32_t ival; + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv)); DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv)); dval = DUK_TVAL_GET_NUMBER(tv); @@ -52235,26 +61531,34 @@ duk_regconst_t duk__ispec_toregconst_raw(duk_compiler_ctx *comp_ctx, } /* end switch */ } case DUK_ISPEC_REGCONST: { - if ((x->regconst & DUK__CONST_MARKER) && !(flags & DUK__IVAL_FLAG_ALLOW_CONST)) { - duk_reg_t dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx)); - duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, (duk_regconst_t) dest, x->regconst); - return (duk_regconst_t) dest; - } else { - if (forced_reg >= 0) { - if (x->regconst != (duk_regconst_t) forced_reg) { - duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, forced_reg, x->regconst); - } - return (duk_regconst_t) forced_reg; + if (forced_reg >= 0) { + if (x->regconst & DUK__CONST_MARKER) { + duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, forced_reg, x->regconst); + } else if (x->regconst != (duk_regconst_t) forced_reg) { + duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, forced_reg, x->regconst); } else { - if ((flags & DUK__IVAL_FLAG_REQUIRE_TEMP) && !DUK__ISTEMP(comp_ctx, x->regconst)) { - duk_reg_t dest = DUK__ALLOCTEMP(comp_ctx); - duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, (duk_regconst_t) dest, x->regconst); - return (duk_regconst_t) dest; - } else { - return x->regconst; - } + ; /* already in correct reg */ } + return (duk_regconst_t) forced_reg; } + + DUK_ASSERT(forced_reg < 0); + if (x->regconst & DUK__CONST_MARKER) { + if (!(flags & DUK__IVAL_FLAG_ALLOW_CONST)) { + duk_reg_t dest = DUK__ALLOCTEMP(comp_ctx); + duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, (duk_regconst_t) dest, x->regconst); + return (duk_regconst_t) dest; + } + return x->regconst; + } + + DUK_ASSERT(forced_reg < 0 && !(x->regconst & DUK__CONST_MARKER)); + if ((flags & DUK__IVAL_FLAG_REQUIRE_TEMP) && !DUK__ISTEMP(comp_ctx, x->regconst)) { + duk_reg_t dest = DUK__ALLOCTEMP(comp_ctx); + duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, (duk_regconst_t) dest, x->regconst); + return (duk_regconst_t) dest; + } + return x->regconst; } default: { break; @@ -52553,7 +61857,7 @@ DUK_LOCAL duk_reg_t duk__ivalue_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x) } #if 0 /* unused */ -DUK_LOCAL duk_reg_t duk__ivalue_totempreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x) { +DUK_LOCAL duk_reg_t duk__ivalue_totemp(duk_compiler_ctx *comp_ctx, duk_ivalue *x) { return duk__ivalue_toregconst_raw(comp_ctx, x, -1, DUK__IVAL_FLAG_REQUIRE_TEMP /*flags*/); } #endif @@ -52567,6 +61871,10 @@ DUK_LOCAL duk_regconst_t duk__ivalue_toregconst(duk_compiler_ctx *comp_ctx, duk_ return duk__ivalue_toregconst_raw(comp_ctx, x, -1, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/); } +DUK_LOCAL duk_regconst_t duk__ivalue_totempconst(duk_compiler_ctx *comp_ctx, duk_ivalue *x) { + return duk__ivalue_toregconst_raw(comp_ctx, x, -1, DUK__IVAL_FLAG_ALLOW_CONST | DUK__IVAL_FLAG_REQUIRE_TEMP /*flags*/); +} + /* The issues below can be solved with better flags */ /* XXX: many operations actually want toforcedtemp() -- brand new temp? */ @@ -52695,8 +62003,8 @@ DUK_LOCAL void duk__add_label(duk_compiler_ctx *comp_ctx, duk_hstring *h_label, */ p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, comp_ctx->curr_func.h_labelinfos); - li_start = (duk_labelinfo *) p; - li = (duk_labelinfo *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos)); + li_start = (duk_labelinfo *) (void *) p; + li = (duk_labelinfo *) (void *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos)); n = (duk_size_t) (li - li_start); while (li > li_start) { @@ -52712,14 +62020,14 @@ DUK_LOCAL void duk__add_label(duk_compiler_ctx *comp_ctx, duk_hstring *h_label, (void) duk_put_prop_index(ctx, comp_ctx->curr_func.labelnames_idx, (duk_uarridx_t) n); new_size = (n + 1) * sizeof(duk_labelinfo); - duk_hbuffer_resize(thr, comp_ctx->curr_func.h_labelinfos, new_size, new_size); + duk_hbuffer_resize(thr, comp_ctx->curr_func.h_labelinfos, new_size); /* XXX: spare handling, slow now */ /* relookup after possible realloc */ p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, comp_ctx->curr_func.h_labelinfos); - li_start = (duk_labelinfo *) p; + li_start = (duk_labelinfo *) (void *) p; DUK_UNREF(li_start); /* silence scan-build warning */ - li = (duk_labelinfo *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos)); + li = (duk_labelinfo *) (void *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos)); li--; /* Labels can be used for iteration statements but also for other statements, @@ -52746,8 +62054,8 @@ DUK_LOCAL void duk__update_label_flags(duk_compiler_ctx *comp_ctx, duk_int_t lab duk_labelinfo *li_start, *li; p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(comp_ctx->thr->heap, comp_ctx->curr_func.h_labelinfos); - li_start = (duk_labelinfo *) p; - li = (duk_labelinfo *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos)); + li_start = (duk_labelinfo *) (void *) p; + li = (duk_labelinfo *) (void *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos)); /* Match labels starting from latest; once label_id no longer matches, we can * safely exit without checking the rest of the labels (only the topmost labels @@ -52795,8 +62103,8 @@ DUK_LOCAL void duk__lookup_active_label(duk_compiler_ctx *comp_ctx, duk_hstring DUK_UNREF(ctx); p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, comp_ctx->curr_func.h_labelinfos); - li_start = (duk_labelinfo *) p; - li_end = (duk_labelinfo *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos)); + li_start = (duk_labelinfo *) (void *) p; + li_end = (duk_labelinfo *) (void *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos)); li = li_end; /* Match labels starting from latest label because there can be duplicate empty @@ -52864,7 +62172,7 @@ DUK_LOCAL void duk__reset_labels_to_length(duk_compiler_ctx *comp_ctx, duk_int_t new_size = sizeof(duk_labelinfo) * (duk_size_t) len; duk_push_int(ctx, len); duk_put_prop_stridx(ctx, comp_ctx->curr_func.labelnames_idx, DUK_STRIDX_LENGTH); - duk_hbuffer_resize(thr, comp_ctx->curr_func.h_labelinfos, new_size, new_size); /* XXX: spare handling */ + duk_hbuffer_resize(thr, comp_ctx->curr_func.h_labelinfos, new_size); } /* @@ -53531,7 +62839,7 @@ DUK_LOCAL void duk__expr_nud(duk_compiler_ctx *comp_ctx, duk_ivalue *res) { * such that parsing ends at an LPAREN (CallExpression) but not at * a PERIOD or LBRACKET (MemberExpression). * - * See doc/compiler.txt for discussion on the parsing approach, + * See doc/compiler.rst for discussion on the parsing approach, * and testcases/test-dev-new.js for a bunch of documented tests. */ @@ -53936,9 +63244,17 @@ DUK_LOCAL void duk__expr_led(duk_compiler_ctx *comp_ctx, duk_ivalue *left, duk_i case DUK_TOK_PERIOD: { /* Property access expressions are critical for correct LHS ordering, * see comments in duk__expr()! + * + * A conservative approach would be to use duk__ivalue_totempconst() + * for 'left'. However, allowing a reg-bound variable seems safe here + * and is nice because "foo.bar" is a common expression. If the ivalue + * is used in an expression a GETPROP will occur before any changes to + * the base value can occur. If the ivalue is used as an assignment + * LHS, the assignment code will ensure the base value is safe from + * RHS mutation. */ - /* XXX: this now coerces an identifier into a GETVAR to a temp, which + /* XXX: This now coerces an identifier into a GETVAR to a temp, which * causes an extra LDREG in call setup. It's sufficient to coerce to a * unary ivalue? */ @@ -53969,13 +63285,22 @@ DUK_LOCAL void duk__expr_led(duk_compiler_ctx *comp_ctx, duk_ivalue *left, duk_i /* XXX: optimize temp reg use */ /* XXX: similar coercion issue as in DUK_TOK_PERIOD */ - /* XXX: coerce to regs? it might be better for enumeration use, where the * same PROP ivalue is used multiple times. Or perhaps coerce PROP further * there? */ + /* XXX: for simple cases like x['y'] an unnecessary LDREG is + * emitted for the base value; could avoid it if we knew that + * the key expression is safe (e.g. just a single literal). + */ - duk__ivalue_toplain(comp_ctx, left); + /* The 'left' value must not be a register bound variable + * because it may be mutated during the rest of the expression + * and E5.1 Section 11.2.1 specifies the order of evaluation + * so that the base value is evaluated first. + * See: test-bug-nested-prop-mutate.js. + */ + duk__ivalue_totempconst(comp_ctx, left); duk__expr_toplain(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/); /* Expression, ']' terminates */ duk__advance_expect(comp_ctx, DUK_TOK_RBRACKET); @@ -54380,7 +63705,7 @@ DUK_LOCAL void duk__expr_led(duk_compiler_ctx *comp_ctx, duk_ivalue *left, duk_i * Truthval determines when to skip right-hand-side. * For logical AND truthval=1, for logical OR truthval=0. * - * See doc/compiler.txt for discussion on compiling logical + * See doc/compiler.rst for discussion on compiling logical * AND and OR expressions. The approach here is very simplistic, * generating extra jumps and multiple evaluations of truth values, * but generates code on-the-fly with only local back-patching. @@ -54426,11 +63751,21 @@ DUK_LOCAL void duk__expr_led(duk_compiler_ctx *comp_ctx, duk_ivalue *left, duk_i * Syntactically valid left-hand-side forms which are not accepted as * left-hand-side values (e.g. as in "f() = 1") must NOT cause a * SyntaxError, but rather a run-time ReferenceError. + * + * Assignment expression value is conceptually the LHS/RHS value + * copied into a fresh temporary so that it won't change even if + * LHS/RHS values change (e.g. when they're identifiers). Doing this + * concretely produces inefficient bytecode, so we try to avoid the + * extra temporary for some known-to-be-safe cases. Currently the + * only safe case we detect is a "top level assignment", for example + * "x = y + z;", where the assignment expression value is ignored. + * See: test-dev-assign-expr.js and test-bug-assign-mutate-gh381.js. */ { duk_small_uint_t args_op = args >> 8; duk_small_uint_t args_rbp = args & 0xff; + duk_bool_t toplevel_assign; /* XXX: here we need to know if 'left' is left-hand-side compatible. * That information is no longer available from current expr parsing @@ -54438,44 +63773,89 @@ DUK_LOCAL void duk__expr_led(duk_compiler_ctx *comp_ctx, duk_ivalue *left, duk_i * some other means. */ + /* A top-level assignment is e.g. "x = y;". For these it's safe + * to use the RHS as-is as the expression value, even if the RHS + * is a reg-bound identifier. The RHS ('res') is right associative + * so it has consumed all other assignment level operations; the + * only relevant lower binding power construct is comma operator + * which will ignore the expression value provided here. + */ + toplevel_assign = (comp_ctx->curr_func.nud_count == 1 && /* one token before */ + comp_ctx->curr_func.led_count == 1); /* one operator (= assign) */ + DUK_DDD(DUK_DDDPRINT("assignment: nud_count=%ld, led_count=%ld, toplevel_assign=%ld", + (long) comp_ctx->curr_func.nud_count, + (long) comp_ctx->curr_func.led_count, + (long) toplevel_assign)); + if (left->t == DUK_IVAL_VAR) { duk_hstring *h_varname; duk_reg_t reg_varbind; duk_regconst_t rc_varname; - duk_regconst_t rc_res; - duk_reg_t reg_temp; - /* already in fluly evaluated form */ - DUK_ASSERT(left->x1.t == DUK_ISPEC_VALUE); + DUK_ASSERT(left->x1.t == DUK_ISPEC_VALUE); /* LHS is already side effect free */ - duk__expr_toreg(comp_ctx, res, args_rbp /*rbp_flags*/); - DUK_ASSERT(res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_REGCONST); + /* Keep the RHS as an unresolved ivalue for now, so it + * can be a plain value or a unary/binary operation here. + * We resolve it before finishing but doing it later allows + * better bytecode in some cases. + */ + duk__expr(comp_ctx, res, args_rbp /*rbp_flags*/); h_varname = duk_get_hstring(ctx, left->x1.valstack_idx); DUK_ASSERT(h_varname != NULL); - - /* E5 Section 11.13.1 (and others for other assignments), step 4 */ if (duk__hstring_is_eval_or_arguments_in_strict_mode(comp_ctx, h_varname)) { + /* E5 Section 11.13.1 (and others for other assignments), step 4 */ goto syntax_error_lvalue; } - duk_dup(ctx, left->x1.valstack_idx); (void) duk__lookup_lhs(comp_ctx, ®_varbind, &rc_varname); - DUK_DDD(DUK_DDDPRINT("assign to '%!O' -> reg_varbind=%ld, rc_varname=%ld", - (duk_heaphdr *) h_varname, (long) reg_varbind, (long) rc_varname)); - if (args_op == DUK_OP_NONE) { - rc_res = res->x1.regconst; + if (toplevel_assign) { + /* Any 'res' will do. */ + DUK_DDD(DUK_DDDPRINT("plain assignment, toplevel assign, use as is")); + } else { + /* 'res' must be a plain ivalue, and not register-bound variable. */ + DUK_DDD(DUK_DDDPRINT("plain assignment, not toplevel assign, ensure not a reg-bound identifier")); + if (res->t != DUK_IVAL_PLAIN || (res->x1.t == DUK_ISPEC_REGCONST && + (res->x1.regconst & DUK__CONST_MARKER) == 0 && + !DUK__ISTEMP(comp_ctx, res->x1.regconst))) { + duk__ivalue_totempconst(comp_ctx, res); + } + } } else { - reg_temp = DUK__ALLOCTEMP(comp_ctx); + duk__ivalue_toregconst(comp_ctx, res); + DUK_ASSERT(res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_REGCONST); + if (reg_varbind >= 0) { + duk_reg_t reg_res; + + if (toplevel_assign) { + /* 'reg_varbind' is the operation result and can also + * become the expression value for top level assignments + * such as: "var x; x += y;". + */ + reg_res = reg_varbind; + } else { + /* Not safe to use 'reg_varbind' as assignment expression + * value, so go through a temp. + */ + reg_res = DUK__ALLOCTEMP(comp_ctx); + } + duk__emit_a_b_c(comp_ctx, args_op, - (duk_regconst_t) reg_temp, + (duk_regconst_t) reg_res, (duk_regconst_t) reg_varbind, res->x1.regconst); + res->x1.regconst = (duk_regconst_t) reg_res; } else { + /* When LHS is not register bound, always go through a + * temporary. No optimization for top level assignment. + */ + duk_reg_t reg_temp; + reg_temp = DUK__ALLOCTEMP(comp_ctx); + duk__emit_a_bc(comp_ctx, DUK_OP_GETVAR, (duk_regconst_t) reg_temp, @@ -54485,40 +63865,57 @@ DUK_LOCAL void duk__expr_led(duk_compiler_ctx *comp_ctx, duk_ivalue *left, duk_i (duk_regconst_t) reg_temp, (duk_regconst_t) reg_temp, res->x1.regconst); + res->x1.regconst = (duk_regconst_t) reg_temp; } - rc_res = (duk_regconst_t) reg_temp; + + DUK_ASSERT(res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_REGCONST); } + /* At this point 'res' holds the potential expression value. + * It can be basically any ivalue here, including a reg-bound + * identifier (if code above deems it safe) or a unary/binary + * operation. Operations must be resolved to a side effect free + * plain value, and the side effects must happen exactly once. + */ + if (reg_varbind >= 0) { - duk__emit_a_bc(comp_ctx, - DUK_OP_LDREG, - (duk_regconst_t) reg_varbind, - rc_res); + if (res->t != DUK_IVAL_PLAIN) { + /* Resolve 'res' directly into the LHS binding, and use + * that as the expression value if safe. If not safe, + * resolve to a temp/const and copy to LHS. + */ + if (toplevel_assign) { + duk__ivalue_toforcedreg(comp_ctx, res, (duk_int_t) reg_varbind); + } else { + duk__ivalue_totempconst(comp_ctx, res); + duk__copy_ivalue(comp_ctx, res, left); /* use 'left' as a temp */ + duk__ivalue_toforcedreg(comp_ctx, left, (duk_int_t) reg_varbind); + } + } else { + /* Use 'res' as the expression value (it's side effect + * free and may be a plain value, a register, or a + * constant) and write it to the LHS binding too. + */ + duk__copy_ivalue(comp_ctx, res, left); /* use 'left' as a temp */ + duk__ivalue_toforcedreg(comp_ctx, left, (duk_int_t) reg_varbind); + } } else { - /* Only a reg fits into 'A' and reg_res may be a const in - * straight assignment. + /* Only a reg fits into 'A' so coerce 'res' into a register + * for PUTVAR. * * XXX: here the current A/B/C split is suboptimal: we could * just use 9 bits for reg_res (and support constants) and 17 * instead of 18 bits for the varname const index. */ - if (DUK__ISCONST(comp_ctx, rc_res)) { - reg_temp = DUK__ALLOCTEMP(comp_ctx); - duk__emit_a_bc(comp_ctx, - DUK_OP_LDCONST, - (duk_regconst_t) reg_temp, - rc_res); - rc_res = (duk_regconst_t) reg_temp; - } + + duk__ivalue_toreg(comp_ctx, res); duk__emit_a_bc(comp_ctx, DUK_OP_PUTVAR | DUK__EMIT_FLAG_A_IS_SOURCE, - rc_res, + res->x1.regconst, rc_varname); } - res->t = DUK_IVAL_PLAIN; - res->x1.t = DUK_ISPEC_REGCONST; - res->x1.regconst = rc_res; + /* 'res' contains expression value */ } else if (left->t == DUK_IVAL_PROP) { /* E5 Section 11.13.1 (and others) step 4 never matches for prop writes -> no check */ duk_reg_t reg_obj; @@ -54741,8 +64138,9 @@ DUK_LOCAL duk_small_uint_t duk__expr_lbp(duk_compiler_ctx *comp_ctx) { */ #define DUK__EXPR_RBP_MASK 0xff -#define DUK__EXPR_FLAG_REJECT_IN (1 << 8) -#define DUK__EXPR_FLAG_ALLOW_EMPTY (1 << 9) +#define DUK__EXPR_FLAG_REJECT_IN (1 << 8) /* reject 'in' token (used for for-in) */ +#define DUK__EXPR_FLAG_ALLOW_EMPTY (1 << 9) /* allow empty expression */ +#define DUK__EXPR_FLAG_REQUIRE_INIT (1 << 10) /* require initializer for var/const */ /* main expression parser function */ DUK_LOCAL void duk__expr(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { @@ -54832,15 +64230,17 @@ DUK_LOCAL void duk__exprtop(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_sma * Each helper needs at least 2-3 calls to make it worth while to wrap. */ +#if 0 /* unused */ DUK_LOCAL duk_reg_t duk__expr_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { duk__expr(comp_ctx, res, rbp_flags); return duk__ivalue_toreg(comp_ctx, res); } +#endif #if 0 /* unused */ -DUK_LOCAL duk_reg_t duk__expr_totempreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { +DUK_LOCAL duk_reg_t duk__expr_totemp(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { duk__expr(comp_ctx, res, rbp_flags); - return duk__ivalue_totempreg(comp_ctx, res); + return duk__ivalue_totemp(comp_ctx, res); } #endif @@ -54855,6 +64255,13 @@ DUK_LOCAL duk_regconst_t duk__expr_toregconst(duk_compiler_ctx *comp_ctx, duk_iv return duk__ivalue_toregconst(comp_ctx, res); } +#if 0 /* unused */ +DUK_LOCAL duk_regconst_t duk__expr_totempconst(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { + duk__expr(comp_ctx, res, rbp_flags); + return duk__ivalue_totempconst(comp_ctx, res); +} +#endif + DUK_LOCAL void duk__expr_toplain(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { duk__expr(comp_ctx, res, rbp_flags); duk__ivalue_toplain(comp_ctx, res); @@ -54871,19 +64278,17 @@ DUK_LOCAL duk_reg_t duk__exprtop_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *r } #if 0 /* unused */ -DUK_LOCAL duk_reg_t duk__exprtop_totempreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { +DUK_LOCAL duk_reg_t duk__exprtop_totemp(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { duk__exprtop(comp_ctx, res, rbp_flags); - return duk__ivalue_totempreg(comp_ctx, res); + return duk__ivalue_totemp(comp_ctx, res); } #endif -#if 0 /* unused */ DUK_LOCAL void duk__exprtop_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags, duk_reg_t forced_reg) { DUK_ASSERT(forced_reg >= 0); duk__exprtop(comp_ctx, res, rbp_flags); duk__ivalue_toforcedreg(comp_ctx, res, forced_reg); } -#endif DUK_LOCAL duk_regconst_t duk__exprtop_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) { duk__exprtop(comp_ctx, res, rbp_flags); @@ -55009,6 +64414,11 @@ DUK_LOCAL void duk__parse_var_decl(duk_compiler_ctx *comp_ctx, duk_ivalue *res, (duk_regconst_t) reg_val, rc_varname); } + } else { + if (expr_flags & DUK__EXPR_FLAG_REQUIRE_INIT) { + /* Used for minimal 'const': initializer required. */ + goto syntax_error; + } } duk_pop(ctx); /* pop varname */ @@ -55022,7 +64432,7 @@ DUK_LOCAL void duk__parse_var_decl(duk_compiler_ctx *comp_ctx, duk_ivalue *res, DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_VAR_DECLARATION); } -DUK_LOCAL void duk__parse_var_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) { +DUK_LOCAL void duk__parse_var_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t expr_flags) { duk_reg_t reg_varbind; duk_regconst_t rc_varname; @@ -55030,7 +64440,7 @@ DUK_LOCAL void duk__parse_var_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) for (;;) { /* rc_varname and reg_varbind are ignored here */ - duk__parse_var_decl(comp_ctx, res, 0, ®_varbind, &rc_varname); + duk__parse_var_decl(comp_ctx, res, 0 | expr_flags, ®_varbind, &rc_varname); if (comp_ctx->curr_token.t != DUK_TOK_COMMA) { break; @@ -55042,7 +64452,7 @@ DUK_LOCAL void duk__parse_var_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) DUK_LOCAL void duk__parse_for_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site) { duk_hthread *thr = comp_ctx->thr; duk_context *ctx = (duk_context *) thr; - duk_int_t pc_v34_lhs; /* start variant 3/4 left-hand-side code (L1 in doc/compiler.txt example) */ + duk_int_t pc_v34_lhs; /* start variant 3/4 left-hand-side code (L1 in doc/compiler.rst example) */ duk_reg_t temp_reset; /* knock back "next temp" to this whenever possible */ duk_reg_t reg_temps; /* preallocated temporaries (2) for variants 3 and 4 */ @@ -55069,7 +64479,7 @@ DUK_LOCAL void duk__parse_for_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, * Parsing these without arbitrary lookahead or backtracking is relatively * tricky but we manage to do so for now. * - * See doc/compiler.txt for a detailed discussion of control flow + * See doc/compiler.rst for a detailed discussion of control flow * issues, evaluation order issues, etc. */ @@ -55296,7 +64706,7 @@ DUK_LOCAL void duk__parse_for_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, * * Variables set before entering here: * - * pc_v34_lhs: insert a "JUMP L2" here (see doc/compiler.txt example). + * pc_v34_lhs: insert a "JUMP L2" here (see doc/compiler.rst example). * reg_temps + 0: iteration target value (written to LHS) * reg_temps + 1: enumerator object */ @@ -55311,7 +64721,7 @@ DUK_LOCAL void duk__parse_for_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, /* First we need to insert a jump in the middle of previously * emitted code to get the control flow right. No jumps can - * cross the position where the jump is inserted. See doc/compiler.txt + * cross the position where the jump is inserted. See doc/compiler.rst * for discussion on the intricacies of control flow and side effects * for variants 3 and 4. */ @@ -55426,7 +64836,7 @@ DUK_LOCAL void duk__parse_switch_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *re * only process the first match before switching to a "propagation" mode * where case values are no longer evaluated * - * See E5 Section 12.11. Also see doc/compiler.txt for compilation + * See E5 Section 12.11. Also see doc/compiler.rst for compilation * discussion. */ @@ -55769,12 +65179,6 @@ DUK_LOCAL void duk__parse_return_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *re DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_RETURN); } - /* Use a fast return when possible. A fast return does not cause a longjmp() - * unnecessarily. A fast return can be done when no TCF catchers are active - * (this includes 'try' and 'with' statements). Active label catches do not - * prevent a fast return; they're unwound on return automatically. - */ - ret_flags = 0; if (comp_ctx->curr_token.t == DUK_TOK_SEMICOLON || /* explicit semi follows */ @@ -55796,10 +65200,10 @@ DUK_LOCAL void duk__parse_return_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *re pc_after_expr = duk__get_current_pc(comp_ctx); /* Tail call check: if last opcode emitted was CALL(I), and - * the context allows it, change the CALL(I) to a tailcall. - * This doesn't guarantee that a tailcall will be allowed at + * the context allows it, change the CALL(I) to a tail call. + * This doesn't guarantee that a tail call will be allowed at * runtime, so the RETURN must still be emitted. (Duktape - * 0.10.0 avoided this and simulated a RETURN if a tailcall + * 0.10.0 avoided this and simulated a RETURN if a tail call * couldn't be used at runtime; but this didn't work * correctly with a thread yield/resume, see * test-bug-tailcall-thread-yield-resume.js for discussion.) @@ -55810,7 +65214,7 @@ DUK_LOCAL void duk__parse_return_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *re * { return 1; }), 2' the last opcode emitted is CALL (no * bytecode is emitted for '2') but 'rc_val' indicates * constant '2'. Similarly if '2' is replaced by a register - * bound variable, no opcodes are emitted but tailcall would + * bound variable, no opcodes are emitted but tail call would * be incorrect. * * This is tricky and easy to get wrong. It would be best to @@ -55855,21 +65259,6 @@ DUK_LOCAL void duk__parse_return_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *re ret_flags = DUK_BC_RETURN_FLAG_HAVE_RETVAL; } - /* XXX: For now, "fast returns" are disabled. The compiler doesn't track - * label site depth so when it emits a fast return, it doesn't know whether - * label sites exist or not. Label sites are emitted for e.g. for loops, - * so it's probably quite relevant to handle them in the executor's fast - * return handler. - */ -#if 0 - if (comp_ctx->curr_func.catch_depth == 0) { - DUK_DDD(DUK_DDDPRINT("fast return allowed -> use fast return")); - ret_flags |= DUK_BC_RETURN_FLAG_FAST; - } else { - DUK_DDD(DUK_DDDPRINT("fast return not allowed -> use slow return")); - } -#endif - duk__emit_a_b(comp_ctx, DUK_OP_RETURN | DUK__EMIT_FLAG_NO_SHUFFLE_A, (duk_regconst_t) ret_flags /*flags*/, @@ -55899,6 +65288,7 @@ DUK_LOCAL void duk__parse_try_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) duk_reg_t reg_catch; /* reg_catch+0 and reg_catch+1 are reserved for TRYCATCH */ duk_regconst_t rc_varname = 0; duk_small_uint_t trycatch_flags = 0; + duk_int_t pc_ldconst = -1; duk_int_t pc_trycatch = -1; duk_int_t pc_catch = -1; duk_int_t pc_finally = -1; @@ -55908,7 +65298,7 @@ DUK_LOCAL void duk__parse_try_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) /* * See the following documentation for discussion: * - * doc/execution.txt: control flow details + * doc/execution.rst: control flow details * * Try, catch, and finally "parts" are Blocks, not Statements, so * they must always be delimited by curly braces. This is unlike e.g. @@ -55926,6 +65316,14 @@ DUK_LOCAL void duk__parse_try_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) reg_catch = DUK__ALLOCTEMPS(comp_ctx, 2); + /* The target for this LDCONST may need output shuffling, but we assume + * that 'pc_ldconst' will be the LDCONST that we can patch later. This + * should be the case because there's no input shuffling. (If there's + * no catch clause, this LDCONST will be replaced with a NOP.) + */ + pc_ldconst = duk__get_current_pc(comp_ctx); + duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, reg_catch, 0 /*patched later*/); + pc_trycatch = duk__get_current_pc(comp_ctx); duk__emit_invalid(comp_ctx); /* TRYCATCH, cannot emit now (not enough info) */ duk__emit_invalid(comp_ctx); /* jump for 'catch' case */ @@ -56087,7 +65485,13 @@ DUK_LOCAL void duk__parse_try_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) goto syntax_error; } + /* If there's no catch block, rc_varname will be 0 and duk__patch_trycatch() + * will replace the LDCONST with a NOP. For any actual constant (including + * constant 0) the DUK__CONST_MARKER flag will be set in rc_varname. + */ + duk__patch_trycatch(comp_ctx, + pc_ldconst, pc_trycatch, reg_catch, rc_varname, @@ -56117,7 +65521,6 @@ DUK_LOCAL void duk__parse_with_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) duk_int_t pc_trycatch; duk_int_t pc_finished; duk_reg_t reg_catch; - duk_regconst_t rc_target; duk_small_uint_t trycatch_flags; if (comp_ctx->curr_func.is_strict) { @@ -56131,23 +65534,15 @@ DUK_LOCAL void duk__parse_with_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) reg_catch = DUK__ALLOCTEMPS(comp_ctx, 2); duk__advance_expect(comp_ctx, DUK_TOK_LPAREN); - rc_target = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/); + duk__exprtop_toforcedreg(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/, reg_catch); duk__advance_expect(comp_ctx, DUK_TOK_RPAREN); - /* XXX: the trycatch shuffle flags are now very limiting and a fix - * is needed to allow trycatch to work in functions with a very large - * number of temporaries or constants. - */ - pc_trycatch = duk__get_current_pc(comp_ctx); trycatch_flags = DUK_BC_TRYCATCH_FLAG_WITH_BINDING; - duk__emit_a_b_c(comp_ctx, - DUK_OP_TRYCATCH | DUK__EMIT_FLAG_NO_SHUFFLE_A - | DUK__EMIT_FLAG_NO_SHUFFLE_B - | DUK__EMIT_FLAG_NO_SHUFFLE_C, + duk__emit_a_bc(comp_ctx, + DUK_OP_TRYCATCH | DUK__EMIT_FLAG_NO_SHUFFLE_A, (duk_regconst_t) trycatch_flags /*a*/, - (duk_regconst_t) reg_catch /*b*/, - rc_target /*c*/); + (duk_regconst_t) reg_catch /*bc*/); duk__emit_invalid(comp_ctx); /* catch jump */ duk__emit_invalid(comp_ctx); /* finished jump */ @@ -56326,9 +65721,15 @@ DUK_LOCAL void duk__parse_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_ stmt_flags = 0; break; } + case DUK_TOK_CONST: { + DUK_DDD(DUK_DDDPRINT("constant declaration statement")); + duk__parse_var_stmt(comp_ctx, res, DUK__EXPR_FLAG_REQUIRE_INIT /*expr_flags*/); + stmt_flags = DUK__HAS_TERM; + break; + } case DUK_TOK_VAR: { DUK_DDD(DUK_DDDPRINT("variable declaration statement")); - duk__parse_var_stmt(comp_ctx, res); + duk__parse_var_stmt(comp_ctx, res, 0 /*expr_flags*/); stmt_flags = DUK__HAS_TERM; break; } @@ -56355,7 +65756,7 @@ DUK_LOCAL void duk__parse_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_ * * https://bugs.ecmascript.org/show_bug.cgi?id=8 * - * See doc/compiler.txt for details. + * See doc/compiler.rst for details. */ DUK_DDD(DUK_DDDPRINT("do statement")); DUK_ASSERT(label_id >= 0); @@ -56444,13 +65845,13 @@ DUK_LOCAL void duk__parse_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_ break; } case DUK_TOK_DEBUGGER: { + duk__advance(comp_ctx); #if defined(DUK_USE_DEBUGGER_SUPPORT) DUK_DDD(DUK_DDDPRINT("debugger statement: debugging enabled, emit debugger opcode")); duk__emit_extraop_only(comp_ctx, DUK_EXTRAOP_DEBUGGER); #else DUK_DDD(DUK_DDDPRINT("debugger statement: ignored")); #endif - duk__advance(comp_ctx); stmt_flags = DUK__HAS_TERM; break; } @@ -57341,16 +66742,16 @@ DUK_LOCAL void duk__parse_func_body(duk_compiler_ctx *comp_ctx, duk_bool_t expec * (directly or via a jump) */ - DUK_ASSERT(comp_ctx->curr_func.catch_depth == 0); /* fast returns are always OK here */ + DUK_ASSERT(comp_ctx->curr_func.catch_depth == 0); if (reg_stmt_value >= 0) { duk__emit_a_b(comp_ctx, DUK_OP_RETURN | DUK__EMIT_FLAG_NO_SHUFFLE_A, - (duk_regconst_t) (DUK_BC_RETURN_FLAG_HAVE_RETVAL | DUK_BC_RETURN_FLAG_FAST) /*flags*/, + (duk_regconst_t) DUK_BC_RETURN_FLAG_HAVE_RETVAL /*flags*/, (duk_regconst_t) reg_stmt_value /*reg*/); } else { duk__emit_a_b(comp_ctx, DUK_OP_RETURN | DUK__EMIT_FLAG_NO_SHUFFLE_A, - (duk_regconst_t) DUK_BC_RETURN_FLAG_FAST /*flags*/, + (duk_regconst_t) 0 /*flags*/, (duk_regconst_t) 0 /*reg(ignored)*/); } @@ -57723,7 +67124,7 @@ DUK_LOCAL duk_ret_t duk__js_compile_raw(duk_context *ctx) { comp_ctx->tok12_idx = entry_top + 2; comp_ctx->tok21_idx = entry_top + 3; comp_ctx->tok22_idx = entry_top + 4; - comp_ctx->recursion_limit = DUK_COMPILER_RECURSION_LIMIT; + comp_ctx->recursion_limit = DUK_USE_COMPILER_RECLIMIT; /* comp_ctx->lex has been pre-initialized by caller: it has been * zeroed and input/input_length has been set. @@ -57735,7 +67136,7 @@ DUK_LOCAL duk_ret_t duk__js_compile_raw(duk_context *ctx) { comp_ctx->lex.buf_idx = entry_top + 0; comp_ctx->lex.buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, entry_top + 0); DUK_ASSERT(comp_ctx->lex.buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(comp_ctx->lex.buf)); + DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(comp_ctx->lex.buf) && !DUK_HBUFFER_HAS_EXTERNAL(comp_ctx->lex.buf)); comp_ctx->lex.token_limit = DUK_COMPILER_TOKEN_LIMIT; lex_pt->offset = 0; @@ -57835,37 +67236,9 @@ DUK_INTERNAL void duk_js_compile(duk_hthread *thr, const duk_uint8_t *src_buffer prev_ctx = thr->compile_ctx; thr->compile_ctx = &comp_stk.comp_ctx_alloc; /* for duk_error_augment.c */ safe_rc = duk_safe_call(ctx, duk__js_compile_raw, 2 /*nargs*/, 1 /*nret*/); - thr->compile_ctx = prev_ctx; + thr->compile_ctx = prev_ctx; /* must restore reliably before returning */ if (safe_rc != DUK_EXEC_SUCCESS) { - /* Append a "(line NNN)" to the "message" property of any - * error thrown during compilation. Usually compilation - * errors are SyntaxErrors but they can also be out-of-memory - * errors and the like. - * - * Source file/line are added to tracedata directly by - * duk_error_augment.c based on thr->compile_ctx. - */ - - /* [ ... error ] */ - - DUK_DDD(DUK_DDDPRINT("compile error, before adding line info: %!T", - (duk_tval *) duk_get_tval(ctx, -1))); - if (duk_is_object(ctx, -1)) { - /* XXX: Now that fileName and lineNumber are set, this is - * unnecessary. Remove in Duktape 1.3.0? - */ - - if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_MESSAGE)) { - duk_push_sprintf(ctx, " (line %ld)", (long) comp_stk.comp_ctx_alloc.curr_token.start_line); - duk_concat(ctx, 2); - duk_put_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE); - } else { - duk_pop(ctx); - } - } - DUK_DDD(DUK_DDDPRINT("compile error, after adding line info: %!T", - (duk_tval *) duk_get_tval(ctx, -1))); duk_throw(ctx); } @@ -57879,22 +67252,24 @@ DUK_INTERNAL void duk_js_compile(duk_hthread *thr, const duk_uint8_t *src_buffer /* include removed: duk_internal.h */ /* - * Local forward declarations + * Local declarations. */ -DUK_LOCAL_DECL void duk__reconfig_valstack(duk_hthread *thr, duk_size_t act_idx, duk_small_uint_t retval_count); +DUK_LOCAL_DECL void duk__js_execute_bytecode_inner(duk_hthread *entry_thread, duk_size_t entry_callstack_top); /* * Arithmetic, binary, and logical helpers. * * Note: there is no opcode for logical AND or logical OR; this is on * purpose, because the evalution order semantics for them make such - * opcodes pretty pointless (short circuiting means they are most - * comfortably implemented as jumps). However, a logical NOT opcode + * opcodes pretty pointless: short circuiting means they are most + * comfortably implemented as jumps. However, a logical NOT opcode * is useful. * * Note: careful with duk_tval pointers here: they are potentially - * invalidated by any DECREF and almost any API call. + * invalidated by any DECREF and almost any API call. It's still + * preferable to work without making a copy but that's not always + * possible. */ DUK_LOCAL duk_double_t duk__compute_mod(duk_double_t d1, duk_double_t d2) { @@ -57944,7 +67319,6 @@ DUK_LOCAL void duk__vm_arith_add(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_ if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) { duk_int64_t v1, v2, v3; duk_int32_t v3_hi; - duk_tval tv_tmp; duk_tval *tv_z; /* Input values are signed 48-bit so we can detect overflow @@ -57957,10 +67331,7 @@ DUK_LOCAL void duk__vm_arith_add(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_ v3_hi = (duk_int32_t) (v3 >> 32); if (DUK_LIKELY(v3_hi >= -0x8000LL && v3_hi <= 0x7fffLL)) { tv_z = thr->valstack_bottom + idx_z; - DUK_TVAL_SET_TVAL(&tv_tmp, tv_z); - DUK_TVAL_SET_FASTINT(tv_z, v3); - DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z)); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_FASTINT_UPDREF(thr, tv_z, v3); /* side effects */ return; } else { /* overflow, fall through */ @@ -57970,7 +67341,6 @@ DUK_LOCAL void duk__vm_arith_add(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_ #endif /* DUK_USE_FASTINT */ if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) { - duk_tval tv_tmp; duk_tval *tv_z; du.d = DUK_TVAL_GET_NUMBER(tv_x) + DUK_TVAL_GET_NUMBER(tv_y); @@ -57978,10 +67348,7 @@ DUK_LOCAL void duk__vm_arith_add(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_ DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du)); tv_z = thr->valstack_bottom + idx_z; - DUK_TVAL_SET_TVAL(&tv_tmp, tv_z); - DUK_TVAL_SET_NUMBER(tv_z, du.d); - DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z)); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_NUMBER_UPDREF(thr, tv_z, du.d); /* side effects */ return; } @@ -58034,7 +67401,6 @@ DUK_LOCAL void duk__vm_arith_binary_op(duk_hthread *thr, duk_tval *tv_x, duk_tva */ duk_context *ctx = (duk_context *) thr; - duk_tval tv_tmp; duk_tval *tv_z; duk_double_t d1, d2; duk_double_union du; @@ -58111,10 +67477,7 @@ DUK_LOCAL void duk__vm_arith_binary_op(duk_hthread *thr, duk_tval *tv_x, duk_tva v3_hi = (duk_int32_t) (v3 >> 32); if (DUK_LIKELY(v3_hi >= -0x8000LL && v3_hi <= 0x7fffLL)) { tv_z = thr->valstack_bottom + idx_z; - DUK_TVAL_SET_TVAL(&tv_tmp, tv_z); - DUK_TVAL_SET_FASTINT(tv_z, v3); - DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z)); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_FASTINT_UPDREF(thr, tv_z, v3); /* side effects */ return; } /* fall through if overflow etc */ @@ -58167,10 +67530,7 @@ DUK_LOCAL void duk__vm_arith_binary_op(duk_hthread *thr, duk_tval *tv_x, duk_tva DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du)); tv_z = thr->valstack_bottom + idx_z; - DUK_TVAL_SET_TVAL(&tv_tmp, tv_z); - DUK_TVAL_SET_NUMBER(tv_z, du.d); - DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z)); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_NUMBER_UPDREF(thr, tv_z, du.d); /* side effects */ } DUK_LOCAL void duk__vm_bitwise_binary_op(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_uint_fast_t idx_z, duk_small_uint_fast_t opcode) { @@ -58185,7 +67545,6 @@ DUK_LOCAL void duk__vm_bitwise_binary_op(duk_hthread *thr, duk_tval *tv_x, duk_t */ duk_context *ctx = (duk_context *) thr; - duk_tval tv_tmp; duk_tval *tv_z; duk_int32_t i1, i2, i3; duk_uint32_t u1, u2, u3; @@ -58273,15 +67632,14 @@ DUK_LOCAL void duk__vm_bitwise_binary_op(duk_hthread *thr, duk_tval *tv_x, duk_t #if defined(DUK_USE_FASTINT) /* Result is always fastint compatible. */ - /* XXX: set 32-bit result (but must handle signed and unsigned) */ + /* XXX: Set 32-bit result (but must then handle signed and + * unsigned results separately). + */ fi3 = (duk_int64_t) i3; fastint_result_set: tv_z = thr->valstack_bottom + idx_z; - DUK_TVAL_SET_TVAL(&tv_tmp, tv_z); - DUK_TVAL_SET_FASTINT(tv_z, fi3); - DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z)); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_FASTINT_UPDREF(thr, tv_z, fi3); /* side effects */ #else d3 = (duk_double_t) i3; @@ -58290,10 +67648,7 @@ DUK_LOCAL void duk__vm_bitwise_binary_op(duk_hthread *thr, duk_tval *tv_x, duk_t DUK_ASSERT_DOUBLE_IS_NORMALIZED(d3); /* always normalized */ tv_z = thr->valstack_bottom + idx_z; - DUK_TVAL_SET_TVAL(&tv_tmp, tv_z); - DUK_TVAL_SET_NUMBER(tv_z, d3); - DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z)); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_NUMBER_UPDREF(thr, tv_z, d3); /* side effects */ #endif } @@ -58368,13 +67723,12 @@ DUK_LOCAL void duk__vm_arith_unary_op(duk_hthread *thr, duk_tval *tv_x, duk_idx_ #endif } -DUK_LOCAL void duk__vm_bitwise_not(duk_hthread *thr, duk_tval *tv_x, duk_small_uint_fast_t idx_z) { +DUK_LOCAL void duk__vm_bitwise_not(duk_hthread *thr, duk_tval *tv_x, duk_uint_fast_t idx_z) { /* * E5 Section 11.4.8 */ duk_context *ctx = (duk_context *) thr; - duk_tval tv_tmp; duk_tval *tv_z; duk_int32_t i1, i2; #if !defined(DUK_USE_FASTINT) @@ -58404,10 +67758,7 @@ DUK_LOCAL void duk__vm_bitwise_not(duk_hthread *thr, duk_tval *tv_x, duk_small_u #if defined(DUK_USE_FASTINT) /* Result is always fastint compatible. */ tv_z = thr->valstack_bottom + idx_z; - DUK_TVAL_SET_TVAL(&tv_tmp, tv_z); - DUK_TVAL_SET_FASTINT_I32(tv_z, i2); - DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z)); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_FASTINT_I32_UPDREF(thr, tv_z, i2); /* side effects */ #else d2 = (duk_double_t) i2; @@ -58415,10 +67766,7 @@ DUK_LOCAL void duk__vm_bitwise_not(duk_hthread *thr, duk_tval *tv_x, duk_small_u DUK_ASSERT_DOUBLE_IS_NORMALIZED(d2); /* always normalized */ tv_z = thr->valstack_bottom + idx_z; - DUK_TVAL_SET_TVAL(&tv_tmp, tv_z); - DUK_TVAL_SET_NUMBER(tv_z, d2); - DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z)); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_NUMBER_UPDREF(thr, tv_z, d2); /* side effects */ #endif } @@ -58427,7 +67775,6 @@ DUK_LOCAL void duk__vm_logical_not(duk_hthread *thr, duk_tval *tv_x, duk_tval *t * E5 Section 11.4.9 */ - duk_tval tv_tmp; duk_bool_t res; DUK_ASSERT(thr != NULL); @@ -58443,37 +67790,35 @@ DUK_LOCAL void duk__vm_logical_not(duk_hthread *thr, duk_tval *tv_x, duk_tval *t res = duk_js_toboolean(tv_x); /* does not modify tv_x */ DUK_ASSERT(res == 0 || res == 1); res ^= 1; - DUK_TVAL_SET_TVAL(&tv_tmp, tv_z); - DUK_TVAL_SET_BOOLEAN(tv_z, res); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_BOOLEAN_UPDREF(thr, tv_z, res); /* side effects */ } /* - * Longjmp handler for the bytecode executor (and a bunch of static - * helpers for it). + * Longjmp and other control flow transfer for the bytecode executor. * - * Any type of longjmp() can be caught here, including intra-function - * longjmp()s like 'break', 'continue', (slow) 'return', 'yield', etc. + * The longjmp handler can handle all longjmp types: error, yield, and + * resume (pseudotypes are never actually thrown). * - * Error policy: should not ordinarily throw errors. Errors thrown - * will bubble outwards. - * - * Returns: - * 0 restart execution - * 1 bytecode executor finished - * 2 rethrow longjmp + * Error policy for longjmp: should not ordinarily throw errors; if errors + * occur (e.g. due to out-of-memory) they bubble outwards rather than being + * handled recursively. */ -/* XXX: duk_api operations for cross-thread reg manipulation? */ -/* XXX: post-condition: value stack must be correct; for ecmascript functions, clamped to 'nregs' */ - #define DUK__LONGJMP_RESTART 0 /* state updated, restart bytecode execution */ -#define DUK__LONGJMP_FINISHED 1 /* exit bytecode executor with return value */ -#define DUK__LONGJMP_RETHROW 2 /* exit bytecode executor by rethrowing an error to caller */ +#define DUK__LONGJMP_RETHROW 1 /* exit bytecode executor by rethrowing an error to caller */ -/* only called when act_idx points to an Ecmascript function */ -DUK_LOCAL void duk__reconfig_valstack(duk_hthread *thr, duk_size_t act_idx, duk_small_uint_t retval_count) { +#define DUK__RETHAND_RESTART 0 /* state updated, restart bytecode execution */ +#define DUK__RETHAND_FINISHED 1 /* exit bytecode execution with return value */ + +/* XXX: optimize reconfig valstack operations so that resize, clamp, and setting + * top are combined into one pass. + */ + +/* Reconfigure value stack for return to an Ecmascript function at 'act_idx'. */ +DUK_LOCAL void duk__reconfig_valstack_ecma_return(duk_hthread *thr, duk_size_t act_idx) { + duk_activation *act; duk_hcompiledfunction *h_func; + duk_idx_t clamp_top; DUK_ASSERT(thr != NULL); DUK_ASSERT_DISABLE(act_idx >= 0); /* unsigned */ @@ -58481,91 +67826,109 @@ DUK_LOCAL void duk__reconfig_valstack(duk_hthread *thr, duk_size_t act_idx, duk_ DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + act_idx))); DUK_ASSERT_DISABLE(thr->callstack[act_idx].idx_retval >= 0); /* unsigned */ - thr->valstack_bottom = thr->valstack + thr->callstack[act_idx].idx_bottom; - - /* clamp so that retval is at the top (retval_count == 1) or register just before - * intended retval is at the top (retval_count == 0, happens e.g. with 'finally'). - */ - duk_set_top((duk_context *) thr, - (duk_idx_t) (thr->callstack[act_idx].idx_retval - - thr->callstack[act_idx].idx_bottom + - retval_count)); - - /* - * When returning to an Ecmascript function, extend the valstack - * top to 'nregs' always. + /* Clamp so that values at 'clamp_top' and above are wiped and won't + * retain reachable garbage. Then extend to 'nregs' because we're + * returning to an Ecmascript function. */ - h_func = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(thr->callstack + act_idx); + act = thr->callstack + act_idx; + h_func = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act); + + thr->valstack_bottom = thr->valstack + act->idx_bottom; + DUK_ASSERT(act->idx_retval >= act->idx_bottom); + clamp_top = (duk_idx_t) (act->idx_retval - act->idx_bottom + 1); /* +1 = one retval */ + duk_set_top((duk_context *) thr, clamp_top); + act = NULL; (void) duk_valstack_resize_raw((duk_context *) thr, - (thr->valstack_bottom - thr->valstack) + /* bottom of current func */ - h_func->nregs + /* reg count */ - DUK_VALSTACK_INTERNAL_EXTRA, /* + spare */ - DUK_VSRESIZE_FLAG_SHRINK | /* flags */ + (thr->valstack_bottom - thr->valstack) + /* bottom of current func */ + h_func->nregs + /* reg count */ + DUK_VALSTACK_INTERNAL_EXTRA, /* + spare */ + DUK_VSRESIZE_FLAG_SHRINK | /* flags */ 0 /* no compact */ | DUK_VSRESIZE_FLAG_THROW); duk_set_top((duk_context *) thr, h_func->nregs); } -DUK_LOCAL void duk__handle_catch_or_finally(duk_hthread *thr, duk_size_t cat_idx, duk_bool_t is_finally) { - duk_context *ctx = (duk_context *) thr; - duk_tval tv_tmp; +DUK_LOCAL void duk__reconfig_valstack_ecma_catcher(duk_hthread *thr, duk_size_t act_idx, duk_size_t cat_idx) { + duk_activation *act; + duk_catcher *cat; + duk_hcompiledfunction *h_func; + duk_idx_t clamp_top; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT_DISABLE(act_idx >= 0); /* unsigned */ + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + act_idx) != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + act_idx))); + DUK_ASSERT_DISABLE(thr->callstack[act_idx].idx_retval >= 0); /* unsigned */ + + act = thr->callstack + act_idx; + cat = thr->catchstack + cat_idx; + h_func = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act); + + thr->valstack_bottom = thr->valstack + act->idx_bottom; + DUK_ASSERT(cat->idx_base >= act->idx_bottom); + clamp_top = (duk_idx_t) (cat->idx_base - act->idx_bottom + 2); /* +2 = catcher value, catcher lj_type */ + duk_set_top((duk_context *) thr, clamp_top); + act = NULL; + cat = NULL; + + (void) duk_valstack_resize_raw((duk_context *) thr, + (thr->valstack_bottom - thr->valstack) + /* bottom of current func */ + h_func->nregs + /* reg count */ + DUK_VALSTACK_INTERNAL_EXTRA, /* + spare */ + DUK_VSRESIZE_FLAG_SHRINK | /* flags */ + 0 /* no compact */ | + DUK_VSRESIZE_FLAG_THROW); + + duk_set_top((duk_context *) thr, h_func->nregs); +} + +/* Set catcher regs: idx_base+0 = value, idx_base+1 = lj_type. */ +DUK_LOCAL void duk__set_catcher_regs(duk_hthread *thr, duk_size_t cat_idx, duk_tval *tv_val_unstable, duk_small_uint_t lj_type) { duk_tval *tv1; - DUK_DDD(DUK_DDDPRINT("handling catch/finally, cat_idx=%ld, is_finally=%ld", - (long) cat_idx, (long) is_finally)); - - /* - * Set caught value and longjmp type to catcher regs. - */ - - DUK_DDD(DUK_DDDPRINT("writing catch registers: idx_base=%ld -> %!T, idx_base+1=%ld -> %!T", - (long) thr->catchstack[cat_idx].idx_base, - (duk_tval *) &thr->heap->lj.value1, - (long) (thr->catchstack[cat_idx].idx_base + 1), - (duk_tval *) &thr->heap->lj.value2)); + DUK_ASSERT(thr != NULL); + DUK_ASSERT(tv_val_unstable != NULL); tv1 = thr->valstack + thr->catchstack[cat_idx].idx_base; - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_TVAL(tv1, &thr->heap->lj.value1); - DUK_TVAL_INCREF(thr, tv1); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_ASSERT(tv1 < thr->valstack_top); + DUK_TVAL_SET_TVAL_UPDREF(thr, tv1, tv_val_unstable); /* side effects */ tv1 = thr->valstack + thr->catchstack[cat_idx].idx_base + 1; - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_NUMBER(tv1, (duk_double_t) thr->heap->lj.type); /* XXX: set int */ - DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv1)); /* no need to incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_ASSERT(tv1 < thr->valstack_top); - /* - * Unwind catchstack and callstack. - * - * The 'cat_idx' catcher is always kept, even when executing finally. - */ +#if defined(DUK_USE_FASTINT) + DUK_TVAL_SET_FASTINT_U32_UPDREF(thr, tv1, (duk_uint32_t) lj_type); /* side effects */ +#else + DUK_TVAL_SET_NUMBER_UPDREF(thr, tv1, (duk_double_t) lj_type); /* side effects */ +#endif +} + +DUK_LOCAL void duk__handle_catch(duk_hthread *thr, duk_size_t cat_idx, duk_tval *tv_val_unstable, duk_small_uint_t lj_type) { + duk_context *ctx; + duk_activation *act; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(tv_val_unstable != NULL); + ctx = (duk_context *) thr; + + duk__set_catcher_regs(thr, cat_idx, tv_val_unstable, lj_type); duk_hthread_catchstack_unwind(thr, cat_idx + 1); duk_hthread_callstack_unwind(thr, thr->catchstack[cat_idx].callstack_index + 1); - /* - * Reconfigure valstack to 'nregs' (this is always the case for - * Ecmascript functions). - */ - DUK_ASSERT(thr->callstack_top >= 1); DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL); DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1))); - thr->valstack_bottom = thr->valstack + (thr->callstack + thr->callstack_top - 1)->idx_bottom; - duk_set_top((duk_context *) thr, ((duk_hcompiledfunction *) DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1))->nregs); + duk__reconfig_valstack_ecma_catcher(thr, thr->callstack_top - 1, cat_idx); - /* - * Reset PC: resume execution from catch or finally jump slot. - */ - - (thr->callstack + thr->callstack_top - 1)->pc = - thr->catchstack[cat_idx].pc_base + (is_finally ? 1 : 0); + DUK_ASSERT(thr->callstack_top >= 1); + act = thr->callstack + thr->callstack_top - 1; + act->curr_pc = thr->catchstack[cat_idx].pc_base + 0; /* +0 = catch */ + act = NULL; /* * If entering a 'catch' block which requires an automatic @@ -58577,8 +67940,7 @@ DUK_LOCAL void duk__handle_catch_or_finally(duk_hthread *thr, duk_size_t cat_idx * which implies the binding is not deletable. */ - if (!is_finally && DUK_CAT_HAS_CATCH_BINDING_ENABLED(&thr->catchstack[cat_idx])) { - duk_activation *act; + if (DUK_CAT_HAS_CATCH_BINDING_ENABLED(&thr->catchstack[cat_idx])) { duk_hobject *new_env; duk_hobject *act_lex_env; @@ -58611,7 +67973,7 @@ DUK_LOCAL void duk__handle_catch_or_finally(duk_hthread *thr, duk_size_t cat_idx DUK_HOBJECT_FLAG_EXTENSIBLE | DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV), act_lex_env); - new_env = duk_require_hobject(ctx, -1); + new_env = duk_get_hobject(ctx, -1); DUK_ASSERT(new_env != NULL); DUK_DDD(DUK_DDDPRINT("new_env allocated: %!iO", (duk_heaphdr *) new_env)); @@ -58623,7 +67985,7 @@ DUK_LOCAL void duk__handle_catch_or_finally(duk_hthread *thr, duk_size_t cat_idx DUK_ASSERT(thr->catchstack[cat_idx].h_varname != NULL); duk_push_hstring(ctx, thr->catchstack[cat_idx].h_varname); - duk_push_tval(ctx, &thr->heap->lj.value1); + duk_push_tval(ctx, thr->valstack + thr->catchstack[cat_idx].idx_base); duk_xdef_prop(ctx, -3, DUK_PROPDESC_FLAGS_W); /* writable, not configurable */ act = thr->callstack + thr->callstack_top - 1; @@ -58637,28 +67999,47 @@ DUK_LOCAL void duk__handle_catch_or_finally(duk_hthread *thr, duk_size_t cat_idx DUK_DDD(DUK_DDDPRINT("new_env finished: %!iO", (duk_heaphdr *) new_env)); } - if (is_finally) { - DUK_CAT_CLEAR_FINALLY_ENABLED(&thr->catchstack[cat_idx]); - } else { - DUK_CAT_CLEAR_CATCH_ENABLED(&thr->catchstack[cat_idx]); - } + DUK_CAT_CLEAR_CATCH_ENABLED(&thr->catchstack[cat_idx]); } -DUK_LOCAL void duk__handle_label(duk_hthread *thr, duk_size_t cat_idx) { +DUK_LOCAL void duk__handle_finally(duk_hthread *thr, duk_size_t cat_idx, duk_tval *tv_val_unstable, duk_small_uint_t lj_type) { duk_activation *act; - /* no callstack changes, no value stack changes */ + DUK_ASSERT(thr != NULL); + DUK_ASSERT(tv_val_unstable != NULL); + + duk__set_catcher_regs(thr, cat_idx, tv_val_unstable, lj_type); + + duk_hthread_catchstack_unwind(thr, cat_idx + 1); /* cat_idx catcher is kept, even for finally */ + duk_hthread_callstack_unwind(thr, thr->catchstack[cat_idx].callstack_index + 1); + + DUK_ASSERT(thr->callstack_top >= 1); + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1))); + + duk__reconfig_valstack_ecma_catcher(thr, thr->callstack_top - 1, cat_idx); + + DUK_ASSERT(thr->callstack_top >= 1); + act = thr->callstack + thr->callstack_top - 1; + act->curr_pc = thr->catchstack[cat_idx].pc_base + 1; /* +1 = finally */ + act = NULL; + + DUK_CAT_CLEAR_FINALLY_ENABLED(&thr->catchstack[cat_idx]); +} + +DUK_LOCAL void duk__handle_label(duk_hthread *thr, duk_size_t cat_idx, duk_small_uint_t lj_type) { + duk_activation *act; DUK_ASSERT(thr != NULL); - DUK_ASSERT(thr->callstack_top >= 1); + DUK_ASSERT(thr->callstack_top >= 1); act = thr->callstack + thr->callstack_top - 1; DUK_ASSERT(DUK_ACT_GET_FUNC(act) != NULL); DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(act))); /* +0 = break, +1 = continue */ - act->pc = thr->catchstack[cat_idx].pc_base + (thr->heap->lj.type == DUK_LJ_TYPE_CONTINUE ? 1 : 0); + act->curr_pc = thr->catchstack[cat_idx].pc_base + (lj_type == DUK_LJ_TYPE_CONTINUE ? 1 : 0); act = NULL; /* invalidated */ duk_hthread_catchstack_unwind(thr, cat_idx + 1); /* keep label catcher */ @@ -58666,38 +68047,32 @@ DUK_LOCAL void duk__handle_label(duk_hthread *thr, duk_size_t cat_idx) { /* valstack should not need changes */ #if defined(DUK_USE_ASSERTIONS) + DUK_ASSERT(thr->callstack_top >= 1); act = thr->callstack + thr->callstack_top - 1; DUK_ASSERT((duk_size_t) (thr->valstack_top - thr->valstack_bottom) == (duk_size_t) ((duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act))->nregs); #endif } -/* Note: called for DUK_LJ_TYPE_YIELD and for DUK_LJ_TYPE_RETURN, when a - * return terminates a thread and yields to the resumer. +/* Called for handling both a longjmp() with type DUK_LJ_TYPE_YIELD and + * when a RETURN opcode terminates a thread and yields to the resumer. */ -DUK_LOCAL void duk__handle_yield(duk_hthread *thr, duk_hthread *resumer, duk_size_t act_idx) { - duk_tval tv_tmp; +DUK_LOCAL void duk__handle_yield(duk_hthread *thr, duk_hthread *resumer, duk_size_t act_idx, duk_tval *tv_val_unstable) { duk_tval *tv1; - /* this may also be called for DUK_LJ_TYPE_RETURN; this is OK as long as - * lj.value1 is correct. - */ - + DUK_ASSERT(thr != NULL); + DUK_ASSERT(resumer != NULL); + DUK_ASSERT(tv_val_unstable != NULL); DUK_ASSERT(DUK_ACT_GET_FUNC(resumer->callstack + act_idx) != NULL); DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(resumer->callstack + act_idx))); /* resume caller must be an ecmascript func */ - DUK_DDD(DUK_DDDPRINT("resume idx_retval is %ld", (long) resumer->callstack[act_idx].idx_retval)); - tv1 = resumer->valstack + resumer->callstack[act_idx].idx_retval; /* return value from Duktape.Thread.resume() */ - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_TVAL(tv1, &thr->heap->lj.value1); - DUK_TVAL_INCREF(thr, tv1); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_TVAL_UPDREF(thr, tv1, tv_val_unstable); /* side effects */ duk_hthread_callstack_unwind(resumer, act_idx + 1); /* unwind to 'resume' caller */ /* no need to unwind catchstack */ - duk__reconfig_valstack(resumer, act_idx, 1); /* 1 = have retval */ + duk__reconfig_valstack_ecma_return(resumer, act_idx); /* caller must change active thread, and set thr->resumer to NULL */ } @@ -58706,7 +68081,6 @@ DUK_LOCAL duk_small_uint_t duk__handle_longjmp(duk_hthread *thr, duk_hthread *entry_thread, duk_size_t entry_callstack_top) { - duk_tval tv_tmp; duk_size_t entry_callstack_index; duk_small_uint_t retval = DUK__LONGJMP_RESTART; @@ -58719,6 +68093,7 @@ duk_small_uint_t duk__handle_longjmp(duk_hthread *thr, /* 'thr' is the current thread, as no-one resumes except us and we * switch 'thr' in that case. */ + DUK_ASSERT(thr == thr->heap->curr_thread); /* * (Re)try handling the longjmp. @@ -58823,16 +68198,13 @@ duk_small_uint_t duk__handle_longjmp(duk_hthread *thr, tv = resumee->valstack + resumee->callstack[act_idx].idx_retval; /* return value from Duktape.Thread.yield() */ DUK_ASSERT(tv >= resumee->valstack && tv < resumee->valstack_top); tv2 = &thr->heap->lj.value1; - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_TVAL(tv, tv2); - DUK_TVAL_INCREF(thr, tv); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_TVAL_UPDREF(thr, tv, tv2); /* side effects */ duk_hthread_callstack_unwind(resumee, act_idx + 1); /* unwind to 'yield' caller */ /* no need to unwind catchstack */ - duk__reconfig_valstack(resumee, act_idx, 1); /* 1 = have retval */ + duk__reconfig_valstack_ecma_return(resumee, act_idx); resumee->resumer = thr; resumee->state = DUK_HTHREAD_STATE_RUNNING; @@ -58856,7 +68228,7 @@ duk_small_uint_t duk__handle_longjmp(duk_hthread *thr, /* resumee: [... initial_func undefined(= this) resume_value ] */ - call_flags = DUK_CALL_FLAG_IS_RESUME; /* is resume, not a tailcall */ + call_flags = DUK_CALL_FLAG_IS_RESUME; /* is resume, not a tail call */ setup_rc = duk_handle_ecma_call_setup(resumee, 1, /* num_stack_args */ @@ -58932,7 +68304,7 @@ duk_small_uint_t duk__handle_longjmp(duk_hthread *thr, DUK_DD(DUK_DDPRINT("-> yield an error, converted to a throw in the resumer, propagate")); goto check_longjmp; } else { - duk__handle_yield(thr, resumer, resumer->callstack_top - 2); + duk__handle_yield(thr, resumer, resumer->callstack_top - 2, &thr->heap->lj.value1); thr->state = DUK_HTHREAD_STATE_YIELDED; thr->resumer = NULL; @@ -58950,201 +68322,6 @@ duk_small_uint_t duk__handle_longjmp(duk_hthread *thr, break; /* never here */ } - case DUK_LJ_TYPE_RETURN: { - /* - * Four possible outcomes: - * * A 'finally' in the same function catches the 'return'. - * (or) - * * The return happens at the entry level of the bytecode - * executor, so return from the executor (in C stack). - * (or) - * * There is a calling (Ecmascript) activation in the call - * stack => return to it. - * (or) - * * There is no calling activation, and the thread is - * terminated. There is always a resumer in this case, - * which gets the return value similarly to a 'yield' - * (except that the current thread can no longer be - * resumed). - */ - - duk_tval *tv1; - duk_hthread *resumer; - duk_catcher *cat; - duk_size_t orig_callstack_index; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT(thr->callstack_top >= 1); - DUK_ASSERT(thr->catchstack != NULL); - - /* XXX: does not work if thr->catchstack is NULL */ - /* XXX: does not work if thr->catchstack is allocated but lowest pointer */ - - cat = thr->catchstack + thr->catchstack_top - 1; /* may be < thr->catchstack initially */ - DUK_ASSERT(thr->callstack_top > 0); /* ensures callstack_top - 1 >= 0 */ - orig_callstack_index = thr->callstack_top - 1; - - while (cat >= thr->catchstack) { - if (cat->callstack_index != orig_callstack_index) { - break; - } - if (DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF && - DUK_CAT_HAS_FINALLY_ENABLED(cat)) { - /* 'finally' catches */ - duk__handle_catch_or_finally(thr, - cat - thr->catchstack, - 1); /* is_finally */ - - DUK_DD(DUK_DDPRINT("-> return caught by a finally (in the same function), restart execution")); - retval = DUK__LONGJMP_RESTART; - goto wipe_and_return; - } - cat--; - } - /* if out of catchstack, cat = thr->catchstack - 1 */ - - DUK_DD(DUK_DDPRINT("no catcher in catch stack, return to calling activation / yield")); - - /* return to calling activation (if any) */ - - if (thr == entry_thread && - thr->callstack_top == entry_callstack_top) { - /* return to the bytecode executor caller */ - - duk_push_tval((duk_context *) thr, &thr->heap->lj.value1); - - /* [ ... retval ] */ - - DUK_DD(DUK_DDPRINT("-> return propagated up to entry level, exit bytecode executor")); - retval = DUK__LONGJMP_FINISHED; - goto wipe_and_return; - } - - if (thr->callstack_top >= 2) { - /* there is a caller; it MUST be an Ecmascript caller (otherwise it would - * match entry level check) - */ - - DUK_DDD(DUK_DDDPRINT("slow return to Ecmascript caller, idx_retval=%ld, lj_value1=%!T", - (long) (thr->callstack + thr->callstack_top - 2)->idx_retval, - (duk_tval *) &thr->heap->lj.value1)); - - DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2))); /* must be ecmascript */ - - tv1 = thr->valstack + (thr->callstack + thr->callstack_top - 2)->idx_retval; - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_TVAL(tv1, &thr->heap->lj.value1); - DUK_TVAL_INCREF(thr, tv1); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ - - DUK_DDD(DUK_DDDPRINT("return value at idx_retval=%ld is %!T", - (long) (thr->callstack + thr->callstack_top - 2)->idx_retval, - (duk_tval *) (thr->valstack + (thr->callstack + thr->callstack_top - 2)->idx_retval))); - - duk_hthread_catchstack_unwind(thr, (cat - thr->catchstack) + 1); /* leave 'cat' as top catcher (also works if catchstack exhausted) */ - duk_hthread_callstack_unwind(thr, thr->callstack_top - 1); - duk__reconfig_valstack(thr, thr->callstack_top - 1, 1); /* new top, i.e. callee */ - - DUK_DD(DUK_DDPRINT("-> return not caught, restart execution in caller")); - retval = DUK__LONGJMP_RESTART; - goto wipe_and_return; - } - - DUK_DD(DUK_DDPRINT("no calling activation, thread finishes (similar to yield)")); - - DUK_ASSERT(thr->resumer != NULL); - DUK_ASSERT(thr->resumer->callstack_top >= 2); /* Ecmascript activation + Duktape.Thread.resume() activation */ - DUK_ASSERT(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1) != NULL && - DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1)) && - ((duk_hnativefunction *) DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1))->func == duk_bi_thread_resume); /* Duktape.Thread.resume() */ - DUK_ASSERT(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 2) != NULL && - DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 2))); /* an Ecmascript function */ - DUK_ASSERT_DISABLE((thr->resumer->callstack + thr->resumer->callstack_top - 2)->idx_retval >= 0); /* unsigned */ - DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING); - DUK_ASSERT(thr->resumer->state == DUK_HTHREAD_STATE_RESUMED); - - resumer = thr->resumer; - - duk__handle_yield(thr, resumer, resumer->callstack_top - 2); - - duk_hthread_terminate(thr); /* updates thread state, minimizes its allocations */ - DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_TERMINATED); - - thr->resumer = NULL; - resumer->state = DUK_HTHREAD_STATE_RUNNING; - DUK_HEAP_SWITCH_THREAD(thr->heap, resumer); -#if 0 - thr = resumer; /* not needed */ -#endif - - DUK_DD(DUK_DDPRINT("-> return not caught, thread terminated; handle like yield, restart execution in resumer")); - retval = DUK__LONGJMP_RESTART; - goto wipe_and_return; - } - - case DUK_LJ_TYPE_BREAK: - case DUK_LJ_TYPE_CONTINUE: { - /* - * Find a matching label catcher or 'finally' catcher in - * the same function. - * - * A label catcher must always exist and will match unless - * a 'finally' captures the break/continue first. It is the - * compiler's responsibility to ensure that labels are used - * correctly. - */ - - duk_catcher *cat; - duk_size_t orig_callstack_index; - duk_uint_t lj_label; - - cat = thr->catchstack + thr->catchstack_top - 1; - orig_callstack_index = cat->callstack_index; - - DUK_ASSERT(DUK_TVAL_IS_NUMBER(&thr->heap->lj.value1)); - lj_label = (duk_uint_t) DUK_TVAL_GET_NUMBER(&thr->heap->lj.value1); - - DUK_DDD(DUK_DDDPRINT("handling break/continue with label=%ld, callstack index=%ld", - (long) lj_label, (long) cat->callstack_index)); - - while (cat >= thr->catchstack) { - if (cat->callstack_index != orig_callstack_index) { - break; - } - DUK_DDD(DUK_DDDPRINT("considering catcher %ld: type=%ld label=%ld", - (long) (cat - thr->catchstack), - (long) DUK_CAT_GET_TYPE(cat), - (long) DUK_CAT_GET_LABEL(cat))); - - if (DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF && - DUK_CAT_HAS_FINALLY_ENABLED(cat)) { - /* finally catches */ - duk__handle_catch_or_finally(thr, - cat - thr->catchstack, - 1); /* is_finally */ - - DUK_DD(DUK_DDPRINT("-> break/continue caught by a finally (in the same function), restart execution")); - retval = DUK__LONGJMP_RESTART; - goto wipe_and_return; - } - if (DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_LABEL && - (duk_uint_t) DUK_CAT_GET_LABEL(cat) == lj_label) { - /* found label */ - duk__handle_label(thr, - cat - thr->catchstack); - - DUK_DD(DUK_DDPRINT("-> break/continue caught by a label catcher (in the same function), restart execution")); - retval = DUK__LONGJMP_RESTART; - goto wipe_and_return; - } - cat--; - } - - /* should never happen, but be robust */ - DUK_D(DUK_DPRINT("break/continue not caught by anything in the current function (should never happen)")); - goto convert_to_internal_error; - } - case DUK_LJ_TYPE_THROW: { /* * Three possible outcomes: @@ -59176,12 +68353,12 @@ duk_small_uint_t duk__handle_longjmp(duk_hthread *thr, } if (DUK_CAT_HAS_CATCH_ENABLED(cat)) { - /* try catches */ DUK_ASSERT(DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF); - duk__handle_catch_or_finally(thr, - cat - thr->catchstack, - 0); /* is_finally */ + duk__handle_catch(thr, + cat - thr->catchstack, + &thr->heap->lj.value1, + DUK_LJ_TYPE_THROW); DUK_DD(DUK_DDPRINT("-> throw caught by a 'catch' clause, restart execution")); retval = DUK__LONGJMP_RESTART; @@ -59192,9 +68369,10 @@ duk_small_uint_t duk__handle_longjmp(duk_hthread *thr, DUK_ASSERT(DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF); DUK_ASSERT(!DUK_CAT_HAS_CATCH_ENABLED(cat)); - duk__handle_catch_or_finally(thr, - cat - thr->catchstack, - 1); /* is_finally */ + duk__handle_finally(thr, + cat - thr->catchstack, + &thr->heap->lj.value1, + DUK_LJ_TYPE_THROW); DUK_DD(DUK_DDPRINT("-> throw caught by a 'finally' clause, restart execution")); retval = DUK__LONGJMP_RESTART; @@ -59219,7 +68397,7 @@ duk_small_uint_t duk__handle_longjmp(duk_hthread *thr, /* Note: MUST NOT wipe_and_return here, as heap->lj must remain intact */ } - DUK_DD(DUK_DDPRINT("not caught by current thread, yield error to resumer")); + DUK_DD(DUK_DDPRINT("-> throw not caught by current thread, yield error to resumer and recheck longjmp")); /* not caught by current thread, thread terminates (yield error to resumer); * note that this may cause a cascade if the resumer terminates with an uncaught @@ -59251,11 +68429,10 @@ duk_small_uint_t duk__handle_longjmp(duk_hthread *thr, goto check_longjmp; } - case DUK_LJ_TYPE_NORMAL: { - DUK_D(DUK_DPRINT("caught DUK_LJ_TYPE_NORMAL, should never happen, treat as internal error")); - goto convert_to_internal_error; - } - + case DUK_LJ_TYPE_BREAK: /* pseudotypes, not used in actual longjmps */ + case DUK_LJ_TYPE_CONTINUE: + case DUK_LJ_TYPE_RETURN: + case DUK_LJ_TYPE_NORMAL: default: { /* should never happen, but be robust */ DUK_D(DUK_DPRINT("caught unknown longjmp type %ld, treat as internal error", (long) thr->heap->lj.type)); @@ -59271,84 +68448,253 @@ duk_small_uint_t duk__handle_longjmp(duk_hthread *thr, thr->heap->lj.type = DUK_LJ_TYPE_UNKNOWN; thr->heap->lj.iserror = 0; - DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1); - DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->heap->lj.value1); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ - - DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value2); - DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->heap->lj.value2); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_UNDEFINED_UPDREF(thr, &thr->heap->lj.value1); /* side effects */ + DUK_TVAL_SET_UNDEFINED_UPDREF(thr, &thr->heap->lj.value2); /* side effects */ just_return: return retval; convert_to_internal_error: /* This could also be thrown internally (set the error, goto check_longjmp), - * but it's better for internal errors to bubble outwards. + * but it's better for internal errors to bubble outwards so that we won't + * infinite loop in this catchpoint. */ DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR_EXEC_LONGJMP); DUK_UNREACHABLE(); return retval; } -/* XXX: Disabled for 1.0 release. This needs to handle unwinding for label - * sites (which are created for explicit labels but also for control statements - * like for-loops). At that point it's quite close to the "slow return" handler - * except for longjmp(). Perhaps all returns could initially be handled as fast - * returns and only converted to longjmp()s when basic handling won't do? +/* Handle a BREAK/CONTINUE opcode. Avoid using longjmp() for BREAK/CONTINUE + * handling because it has a measurable performance impact in ordinary + * environments and an extreme impact in Emscripten (GH-342). */ -#if 0 -/* Try a fast return. Return false if fails, so that a slow return can be done - * instead. - */ -DUK_LOCAL -duk_bool_t duk__handle_fast_return(duk_hthread *thr, - duk_tval *tv_retval, - duk_hthread *entry_thread, - duk_size_t entry_callstack_top) { - duk_tval tv_tmp; - duk_tval *tv1; +DUK_LOCAL void duk__handle_break_or_continue(duk_hthread *thr, + duk_uint_t label_id, + duk_small_uint_t lj_type) { + duk_catcher *cat; + duk_size_t orig_callstack_index; - /* retval == NULL indicates 'undefined' return value */ + DUK_ASSERT(thr != NULL); - if (thr == entry_thread && thr->callstack_top == entry_callstack_top) { - DUK_DDD(DUK_DDDPRINT("reject fast return: return would exit bytecode executor to caller")); - return 0; - } - if (thr->callstack_top <= 1) { - DUK_DDD(DUK_DDDPRINT("reject fast return: there is no caller in this callstack (thread yield)")); - return 0; - } - - /* There is a caller, and it must be an Ecmascript caller (otherwise - * it would have matched the entry level check). + /* + * Find a matching label catcher or 'finally' catcher in + * the same function. + * + * A label catcher must always exist and will match unless + * a 'finally' captures the break/continue first. It is the + * compiler's responsibility to ensure that labels are used + * correctly. */ - DUK_ASSERT(thr->callstack_top >= 2); - DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2))); /* must be ecmascript */ - tv1 = thr->valstack + (thr->callstack + thr->callstack_top - 2)->idx_retval; - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - if (tv_retval) { - DUK_TVAL_SET_TVAL(tv1, tv_retval); - DUK_TVAL_INCREF(thr, tv1); - } else { - DUK_TVAL_SET_UNDEFINED_ACTUAL(tv1); - /* no need to incref */ + /* Note: thr->catchstack_top may be 0, so that cat < thr->catchstack + * initially. This is OK and intended. + */ + cat = thr->catchstack + thr->catchstack_top - 1; + DUK_ASSERT(thr->callstack_top > 0); + orig_callstack_index = thr->callstack_top - 1; + + DUK_DDD(DUK_DDDPRINT("handling break/continue with label=%ld, callstack index=%ld", + (long) label_id, (long) cat->callstack_index)); + + while (cat >= thr->catchstack) { + if (cat->callstack_index != orig_callstack_index) { + break; + } + DUK_DDD(DUK_DDDPRINT("considering catcher %ld: type=%ld label=%ld", + (long) (cat - thr->catchstack), + (long) DUK_CAT_GET_TYPE(cat), + (long) DUK_CAT_GET_LABEL(cat))); + + if (DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF && + DUK_CAT_HAS_FINALLY_ENABLED(cat)) { + duk_size_t cat_idx; + duk_tval tv_tmp; + + cat_idx = (duk_size_t) (cat - thr->catchstack); /* get before side effects */ + +#if defined(DUK_USE_FASTINT) + DUK_TVAL_SET_FASTINT_U32(&tv_tmp, (duk_uint32_t) label_id); +#else + DUK_TVAL_SET_NUMBER(&tv_tmp, (duk_double_t) label_id); +#endif + duk__handle_finally(thr, cat_idx, &tv_tmp, lj_type); + + DUK_DD(DUK_DDPRINT("-> break/continue caught by 'finally', restart execution")); + return; + } + if (DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_LABEL && + (duk_uint_t) DUK_CAT_GET_LABEL(cat) == label_id) { + duk_size_t cat_idx; + + cat_idx = (duk_size_t) (cat - thr->catchstack); + duk__handle_label(thr, cat_idx, lj_type); + + DUK_DD(DUK_DDPRINT("-> break/continue caught by a label catcher (in the same function), restart execution")); + return; + } + cat--; } - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ - /* No catchstack to unwind. */ -#if 0 - duk_hthread_catchstack_unwind(thr, (cat - thr->catchstack) + 1); /* leave 'cat' as top catcher (also works if catchstack exhausted) */ -#endif - duk_hthread_callstack_unwind(thr, thr->callstack_top - 1); - duk__reconfig_valstack(thr, thr->callstack_top - 1, 1); /* new top, i.e. callee */ - - DUK_DDD(DUK_DDDPRINT("fast return accepted")); - return 1; + /* should never happen, but be robust */ + DUK_D(DUK_DPRINT("-> break/continue not caught by anything in the current function (should never happen), throw internal error")); + DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR); + return; } + +/* Handle a RETURN opcode. Avoid using longjmp() for return handling because + * it has a measurable performance impact in ordinary environments and an extreme + * impact in Emscripten (GH-342). Return value is on value stack top. + */ +DUK_LOCAL duk_small_uint_t duk__handle_return(duk_hthread *thr, + duk_hthread *entry_thread, + duk_size_t entry_callstack_top) { + duk_tval *tv1; + duk_tval *tv2; + duk_hthread *resumer; + duk_catcher *cat; + duk_size_t new_cat_top; + duk_size_t orig_callstack_index; + + /* We can directly access value stack here. */ + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(entry_thread != NULL); + DUK_ASSERT(thr->valstack_top - 1 >= thr->valstack_bottom); + tv1 = thr->valstack_top - 1; + DUK_TVAL_CHKFAST_INPLACE(tv1); /* fastint downgrade check for return values */ + + /* + * Four possible outcomes: + * + * 1. A 'finally' in the same function catches the 'return'. + * It may continue to propagate when 'finally' is finished, + * or it may be neutralized by 'finally' (both handled by + * ENDFIN). + * + * 2. The return happens at the entry level of the bytecode + * executor, so return from the executor (in C stack). + * + * 3. There is a calling (Ecmascript) activation in the call + * stack => return to it, in the same executor instance. + * + * 4. There is no calling activation, and the thread is + * terminated. There is always a resumer in this case, + * which gets the return value similarly to a 'yield' + * (except that the current thread can no longer be + * resumed). + */ + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->callstack_top >= 1); + DUK_ASSERT(thr->catchstack != NULL); + + /* XXX: does not work if thr->catchstack is NULL */ + /* XXX: does not work if thr->catchstack is allocated but lowest pointer */ + + cat = thr->catchstack + thr->catchstack_top - 1; /* may be < thr->catchstack initially */ + DUK_ASSERT(thr->callstack_top > 0); /* ensures callstack_top - 1 >= 0 */ + orig_callstack_index = thr->callstack_top - 1; + + while (cat >= thr->catchstack) { + if (cat->callstack_index != orig_callstack_index) { + break; + } + if (DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF && + DUK_CAT_HAS_FINALLY_ENABLED(cat)) { + duk_size_t cat_idx; + + cat_idx = (duk_size_t) (cat - thr->catchstack); /* get before side effects */ + + DUK_ASSERT(thr->valstack_top - 1 >= thr->valstack_bottom); + duk__handle_finally(thr, cat_idx, thr->valstack_top - 1, DUK_LJ_TYPE_RETURN); + + DUK_DD(DUK_DDPRINT("-> return caught by 'finally', restart execution")); + return DUK__RETHAND_RESTART; + } + cat--; + } + /* If out of catchstack, cat = thr->catchstack - 1; + * new_cat_top will be 0 in that case. + */ + new_cat_top = (duk_size_t) ((cat + 1) - thr->catchstack); + cat = NULL; /* avoid referencing, invalidated */ + + DUK_DDD(DUK_DDDPRINT("no catcher in catch stack, return to calling activation / yield")); + + if (thr == entry_thread && + thr->callstack_top == entry_callstack_top) { + /* Return to the bytecode executor caller which will unwind stacks. + * Return value is already on the stack top: [ ... retval ]. + */ + + /* XXX: could unwind catchstack here, so that call handling + * didn't need to do that? + */ + DUK_DDD(DUK_DDDPRINT("-> return propagated up to entry level, exit bytecode executor")); + return DUK__RETHAND_FINISHED; + } + + if (thr->callstack_top >= 2) { + /* There is a caller; it MUST be an Ecmascript caller (otherwise it would + * match entry level check) + */ + + DUK_DDD(DUK_DDDPRINT("return to Ecmascript caller, idx_retval=%ld, lj_value1=%!T", + (long) (thr->callstack + thr->callstack_top - 2)->idx_retval, + (duk_tval *) &thr->heap->lj.value1)); + + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2))); /* must be ecmascript */ + + tv1 = thr->valstack + (thr->callstack + thr->callstack_top - 2)->idx_retval; + DUK_ASSERT(thr->valstack_top - 1 >= thr->valstack_bottom); + tv2 = thr->valstack_top - 1; + DUK_TVAL_SET_TVAL_UPDREF(thr, tv1, tv2); /* side effects */ + + DUK_DDD(DUK_DDDPRINT("return value at idx_retval=%ld is %!T", + (long) (thr->callstack + thr->callstack_top - 2)->idx_retval, + (duk_tval *) (thr->valstack + (thr->callstack + thr->callstack_top - 2)->idx_retval))); + + duk_hthread_catchstack_unwind(thr, new_cat_top); /* leave 'cat' as top catcher (also works if catchstack exhausted) */ + duk_hthread_callstack_unwind(thr, thr->callstack_top - 1); + duk__reconfig_valstack_ecma_return(thr, thr->callstack_top - 1); + + DUK_DD(DUK_DDPRINT("-> return not intercepted, restart execution in caller")); + return DUK__RETHAND_RESTART; + } + + DUK_DD(DUK_DDPRINT("no calling activation, thread finishes (similar to yield)")); + + DUK_ASSERT(thr->resumer != NULL); + DUK_ASSERT(thr->resumer->callstack_top >= 2); /* Ecmascript activation + Duktape.Thread.resume() activation */ + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1) != NULL && + DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1)) && + ((duk_hnativefunction *) DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1))->func == duk_bi_thread_resume); /* Duktape.Thread.resume() */ + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 2) != NULL && + DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 2))); /* an Ecmascript function */ + DUK_ASSERT_DISABLE((thr->resumer->callstack + thr->resumer->callstack_top - 2)->idx_retval >= 0); /* unsigned */ + DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING); + DUK_ASSERT(thr->resumer->state == DUK_HTHREAD_STATE_RESUMED); + + resumer = thr->resumer; + + /* Share yield longjmp handler. */ + DUK_ASSERT(thr->valstack_top - 1 >= thr->valstack_bottom); + duk__handle_yield(thr, resumer, resumer->callstack_top - 2, thr->valstack_top - 1); + + duk_hthread_terminate(thr); /* updates thread state, minimizes its allocations */ + DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_TERMINATED); + + thr->resumer = NULL; + resumer->state = DUK_HTHREAD_STATE_RUNNING; + DUK_HEAP_SWITCH_THREAD(thr->heap, resumer); +#if 0 + thr = resumer; /* not needed */ #endif + DUK_DD(DUK_DDPRINT("-> return not caught, thread terminated; handle like yield, restart execution in resumer")); + return DUK__RETHAND_RESTART; +} + /* * Executor interrupt handling * @@ -59374,7 +68720,7 @@ duk_bool_t duk__handle_fast_return(duk_hthread *thr, * work accurately even when single stepping. */ -#ifdef DUK_USE_INTERRUPT_COUNTER +#if defined(DUK_USE_INTERRUPT_COUNTER) #define DUK__INT_NOACTION 0 /* no specific action, resume normal execution */ #define DUK__INT_RESTART 1 /* must "goto restart_execution", e.g. breakpoints changed */ @@ -59408,9 +68754,6 @@ DUK_LOCAL void duk__interrupt_handle_debugger(duk_hthread *thr, duk_bool_t *out_ line = duk_debug_curr_line(thr); if (act->prev_line != line) { - DUK_DDD(DUK_DDDPRINT("PC=%ld line=%ld; line transition: %ld -> %ld", - (long) act->pc, (long) line, (long) act->prev_line, (long) line)); - /* Stepped? Step out is handled by callstack unwind. */ if ((thr->heap->dbg_step_type == DUK_STEP_TYPE_INTO || thr->heap->dbg_step_type == DUK_STEP_TYPE_OVER) && @@ -59424,9 +68767,16 @@ DUK_LOCAL void duk__interrupt_handle_debugger(duk_hthread *thr, duk_bool_t *out_ } /* Check for breakpoints only on line transition. - * Breakpoint is triggered when we enter or cross - * the target line, and the previous line was within - * the same function. + * Breakpoint is triggered when we enter the target + * line from a different line, and the previous line + * was within the same function. + * + * This condition is tricky: the condition used to be + * that transition to -or across- the breakpoint line + * triggered the breakpoint. This seems intuitively + * better because it handles breakpoints on lines with + * no emitted opcodes; but this leads to the issue + * described in: https://github.com/svaarala/duktape/issues/263. */ bp_active = thr->heap->dbg_breakpoints_active; for (;;) { @@ -59434,8 +68784,9 @@ DUK_LOCAL void duk__interrupt_handle_debugger(duk_hthread *thr, duk_bool_t *out_ if (bp == NULL) { break; } + DUK_ASSERT(bp->filename != NULL); - if (act->prev_line < bp->line && line >= bp->line) { + if (act->prev_line != bp->line && line == bp->line) { DUK_D(DUK_DPRINT("BREAKPOINT TRIGGERED at %!O:%ld", (duk_heaphdr *) bp->filename, (long) bp->line)); @@ -59443,7 +68794,7 @@ DUK_LOCAL void duk__interrupt_handle_debugger(duk_hthread *thr, duk_bool_t *out_ } } } else { - DUK_DDD(DUK_DDDPRINT("PC=%ld line=%ld", (long) act->pc, (long) line)); + ; } act->prev_line = line; @@ -59473,7 +68824,8 @@ DUK_LOCAL void duk__interrupt_handle_debugger(duk_hthread *thr, duk_bool_t *out_ process_messages = 0; } - thr->heap->dbg_exec_counter += thr->heap->interrupt_init; + /* XXX: remove heap->dbg_exec_counter, use heap->inst_count_interrupt instead? */ + thr->heap->dbg_exec_counter += thr->interrupt_init; if (thr->heap->dbg_exec_counter - thr->heap->dbg_last_counter >= DUK_HEAP_DBG_RATELIMIT_OPCODES) { /* Overflow of the execution counter is fine and doesn't break * anything here. @@ -59482,7 +68834,7 @@ DUK_LOCAL void duk__interrupt_handle_debugger(duk_hthread *thr, duk_bool_t *out_ duk_double_t now, diff_last; thr->heap->dbg_last_counter = thr->heap->dbg_exec_counter; - now = duk_bi_date_get_now(ctx); + now = DUK_USE_DATE_GET_NOW(ctx); diff_last = now - thr->heap->dbg_last_time; if (diff_last < 0.0 || diff_last >= (duk_double_t) DUK_HEAP_DBG_RATELIMIT_MILLISECS) { @@ -59561,33 +68913,53 @@ DUK_LOCAL duk_small_uint_t duk__executor_interrupt(duk_hthread *thr) { duk_small_uint_t retval; DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->heap != NULL); DUK_ASSERT(thr->callstack != NULL); DUK_ASSERT(thr->callstack_top > 0); +#if defined(DUK_USE_DEBUG) + thr->heap->inst_count_interrupt += thr->interrupt_init; + DUK_DD(DUK_DDPRINT("execution interrupt, counter=%ld, init=%ld, " + "instruction counts: executor=%ld, interrupt=%ld", + (long) thr->interrupt_counter, (long) thr->interrupt_init, + (long) thr->heap->inst_count_exec, (long) thr->heap->inst_count_interrupt)); +#endif + retval = DUK__INT_NOACTION; - ctr = DUK_HEAP_INTCTR_DEFAULT; + ctr = DUK_HTHREAD_INTCTR_DEFAULT; /* * Avoid nested calls. Concretely this happens during debugging, e.g. * when we eval() an expression. + * + * Also don't interrupt if we're currently doing debug processing + * (which can be initiated outside the bytecode executor) as this + * may cause the debugger to be called recursively. Check required + * for correct operation of throw intercept and other "exotic" halting + * scenarios. */ +#if defined(DUK_USE_DEBUGGER_SUPPORT) + if (DUK_HEAP_HAS_INTERRUPT_RUNNING(thr->heap) || thr->heap->dbg_processing) { +#else if (DUK_HEAP_HAS_INTERRUPT_RUNNING(thr->heap)) { +#endif DUK_DD(DUK_DDPRINT("nested executor interrupt, ignoring")); /* Set a high interrupt counter; the original executor * interrupt invocation will rewrite before exiting. */ - thr->heap->interrupt_init = ctr; - thr->heap->interrupt_counter = ctr - 1; + thr->interrupt_init = ctr; thr->interrupt_counter = ctr - 1; return DUK__INT_NOACTION; } DUK_HEAP_SET_INTERRUPT_RUNNING(thr->heap); act = thr->callstack + thr->callstack_top - 1; + fun = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act); DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION((duk_hobject *) fun)); + DUK_UNREF(fun); #if defined(DUK_USE_EXEC_TIMEOUT_CHECK) @@ -59605,9 +68977,9 @@ DUK_LOCAL duk_small_uint_t duk__executor_interrupt(duk_hthread *thr) { * until we've fully bubbled out of Duktape. */ DUK_D(DUK_DPRINT("execution timeout, throwing a RangeError")); - thr->heap->interrupt_init = 0; - thr->heap->interrupt_counter = 0; + thr->interrupt_init = 0; thr->interrupt_counter = 0; + DUK_HEAP_CLEAR_INTERRUPT_RUNNING(thr->heap); DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, "execution timeout"); } #endif /* DUK_USE_EXEC_TIMEOUT_CHECK */ @@ -59628,15 +69000,13 @@ DUK_LOCAL duk_small_uint_t duk__executor_interrupt(duk_hthread *thr) { ctr = 1; } - DUK_DDD(DUK_DDDPRINT("executor interrupt finished, cstop=%ld, pc=%ld, nextctr=%ld", - (long) thr->callstack_top, (long) act->pc, (long) ctr)); - /* The counter value is one less than the init value: init value should * indicate how many instructions are executed before interrupt. To - * execute 1 instruction, counter must be 0. + * execute 1 instruction (after interrupt handler return), counter must + * be 0. */ - thr->heap->interrupt_init = ctr; - thr->heap->interrupt_counter = ctr - 1; + DUK_ASSERT(ctr >= 1); + thr->interrupt_init = ctr; thr->interrupt_counter = ctr - 1; DUK_HEAP_CLEAR_INTERRUPT_RUNNING(thr->heap); @@ -59654,7 +69024,7 @@ DUK_LOCAL duk_small_uint_t duk__executor_interrupt(duk_hthread *thr) { */ #if defined(DUK_USE_DEBUGGER_SUPPORT) -DUK_LOCAL void duk__executor_handle_debugger(duk_hthread *thr, duk_activation *act, duk_hcompiledfunction *fun) { +DUK_LOCAL void duk__executor_recheck_debugger(duk_hthread *thr, duk_activation *act, duk_hcompiledfunction *fun) { duk_heap *heap; duk_tval *tv_tmp; duk_hstring *filename; @@ -59767,6 +69137,13 @@ DUK_LOCAL void duk__executor_handle_debugger(duk_hthread *thr, duk_activation *a thr->heap->dbg_paused || (thr->heap->dbg_step_type != DUK_STEP_TYPE_OUT && thr->heap->dbg_step_csindex == thr->callstack_top - 1)) { + /* We'll need to interrupt early so recompute the init + * counter to reflect the number of bytecode instructions + * executed so that step counts for e.g. debugger rate + * limiting are accurate. + */ + DUK_ASSERT(thr->interrupt_counter <= thr->interrupt_init); + thr->interrupt_init = thr->interrupt_init - thr->interrupt_counter; thr->interrupt_counter = 0; } } @@ -59783,15 +69160,15 @@ DUK_LOCAL void duk__executor_handle_debugger(duk_hthread *thr, duk_activation *a * setjmp() jmpbuf. * * Ecmascript function calls and coroutine resumptions are handled - * internally without recursive C calls. Other function calls are - * handled using duk_handle_call(), increasing C recursion depth. + * internally (by the outer executor function) without recursive C calls. + * Other function calls are handled using duk_handle_call(), increasing + * C recursion depth. * - * There are many other tricky control flow situations, such as: - * - * - Break and continue (fast and slow) - * - Return (fast and slow) - * - Error throwing - * - Thread resume and yield + * Abrupt completions (= long control tranfers) are handled either + * directly by reconfiguring relevant stacks and restarting execution, + * or via a longjmp. Longjmp-free handling is preferable for performance + * (especially Emscripten performance), and is used for: break, continue, + * and return. * * For more detailed notes, see doc/execution.rst. * @@ -59799,11 +69176,19 @@ DUK_LOCAL void duk__executor_handle_debugger(duk_hthread *thr, duk_activation *a * and volatile. */ -#define DUK__STRICT() (DUK_HOBJECT_HAS_STRICT(&(fun)->obj)) -#define DUK__REG(x) (thr->valstack_bottom[(x)]) -#define DUK__REGP(x) (&thr->valstack_bottom[(x)]) -#define DUK__CONST(x) (DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, fun)[(x)]) -#define DUK__CONSTP(x) (&DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, fun)[(x)]) +/* Presence of 'fun' is config based, there's a marginal performance + * difference and the best option is architecture dependent. + */ +#if defined(DUK_USE_EXEC_FUN_LOCAL) +#define DUK__FUN() fun +#else +#define DUK__FUN() ((duk_hcompiledfunction *) DUK_ACT_GET_FUNC((thr)->callstack + (thr)->callstack_top - 1)) +#endif +#define DUK__STRICT() (DUK_HOBJECT_HAS_STRICT((duk_hobject *) DUK__FUN())) +#define DUK__REG(x) (*(thr->valstack_bottom + (x))) +#define DUK__REGP(x) (thr->valstack_bottom + (x)) +#define DUK__CONST(x) (*(consts + (x))) +#define DUK__CONSTP(x) (consts + (x)) #define DUK__REGCONST(x) ((x) < DUK_BC_REGLIMIT ? DUK__REG((x)) : DUK__CONST((x) - DUK_BC_REGLIMIT)) #define DUK__REGCONSTP(x) ((x) < DUK_BC_REGLIMIT ? DUK__REGP((x)) : DUK__CONSTP((x) - DUK_BC_REGLIMIT)) @@ -59817,45 +69202,78 @@ DUK_LOCAL void duk__executor_handle_debugger(duk_hthread *thr, duk_activation *a } while (0) #endif +#define DUK__SYNC_CURR_PC() do { \ + duk_activation *act; \ + act = thr->callstack + thr->callstack_top - 1; \ + act->curr_pc = curr_pc; \ + } while (0) +#define DUK__SYNC_AND_NULL_CURR_PC() do { \ + duk_activation *act; \ + act = thr->callstack + thr->callstack_top - 1; \ + act->curr_pc = curr_pc; \ + thr->ptr_curr_pc = NULL; \ + } while (0) + +DUK_LOCAL void duk__handle_executor_error(duk_heap *heap, + duk_hthread *entry_thread, + duk_size_t entry_callstack_top, + duk_int_t entry_call_recursion_depth +#if !defined(DUK_USE_CPP_EXCEPTIONS) + , duk_jmpbuf *entry_jmpbuf_ptr +#endif + ) { + duk_small_uint_t lj_ret; + + /* Longjmp callers are required to sync-and-null thr->ptr_curr_pc + * before longjmp. + */ + DUK_ASSERT(heap->curr_thread != NULL); + DUK_ASSERT(heap->curr_thread->ptr_curr_pc == NULL); + + /* XXX: signalling the need to shrink check (only if unwound) */ + + /* Must be restored here to handle e.g. yields properly. */ + heap->call_recursion_depth = entry_call_recursion_depth; + +#if !defined(DUK_USE_CPP_EXCEPTIONS) + /* Switch to caller's setjmp() catcher so that if an error occurs + * during error handling, it is always propagated outwards instead + * of causing an infinite loop in our own handler. + */ + heap->lj.jmpbuf_ptr = (duk_jmpbuf *) entry_jmpbuf_ptr; +#endif + + lj_ret = duk__handle_longjmp(heap->curr_thread, entry_thread, entry_callstack_top); + + if (lj_ret == DUK__LONGJMP_RESTART) { + /* Restart bytecode execution, possibly with a changed thread. */ + ; + } else { + /* Rethrow error to calling state. */ + DUK_ASSERT(lj_ret == DUK__LONGJMP_RETHROW); + +#if !defined(DUK_USE_CPP_EXCEPTIONS) + /* Longjmp handling has restored jmpbuf_ptr. */ + DUK_ASSERT(heap->lj.jmpbuf_ptr == entry_jmpbuf_ptr); +#endif + + /* Thread may have changed, e.g. YIELD converted to THROW. */ + duk_err_longjmp(heap->curr_thread); + DUK_UNREACHABLE(); + } +} + +/* Outer executor with setjmp/longjmp handling. */ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { - /* Entry level info. Although these are assigned to before setjmp() - * a 'volatile' seems to be needed. Note placement of "volatile" for - * pointers. See doc/code-issues.rst for more discussion. - */ - duk_hthread * volatile entry_thread; /* volatile copy of exec_thr */ - volatile duk_size_t entry_callstack_top; - volatile duk_int_t entry_call_recursion_depth; - duk_jmpbuf * volatile entry_jmpbuf_ptr; - - /* "hot" variables for interpretation -- not volatile, value not guaranteed in setjmp error handling */ - duk_hthread *thr; /* stable */ - duk_activation *act; /* semi-stable (ok as long as callstack not resized) */ - duk_hcompiledfunction *fun; /* stable */ - duk_instr_t *bcode; /* stable */ - /* 'consts' is computed on-the-fly */ - /* 'funcs' is quite rarely used, so no local for it */ - - /* "hot" temps for interpretation -- not volatile, value not guaranteed in setjmp error handling */ - duk_uint_fast32_t ins; /* XXX: check performance impact on x64 between fast/non-fast variant */ - - /* jmpbuf */ + /* Entry level info. */ + duk_hthread *entry_thread; + duk_size_t entry_callstack_top; + duk_int_t entry_call_recursion_depth; +#if !defined(DUK_USE_CPP_EXCEPTIONS) + duk_jmpbuf *entry_jmpbuf_ptr; duk_jmpbuf jmpbuf; - -#ifdef DUK_USE_INTERRUPT_COUNTER - duk_int_t int_ctr; #endif - -#ifdef DUK_USE_ASSERTIONS - duk_size_t valstack_top_base; /* valstack top, should match before interpreting each op (no leftovers) */ -#endif - - /* XXX: document assumptions on setjmp and volatile variables - * (see duk_handle_call()). - */ - - /* - * Preliminaries - */ + duk_heap *heap; DUK_ASSERT(exec_thr != NULL); DUK_ASSERT(exec_thr->heap != NULL); @@ -59865,145 +69283,149 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { DUK_ASSERT(DUK_ACT_GET_FUNC(exec_thr->callstack + exec_thr->callstack_top - 1) != NULL); DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(exec_thr->callstack + exec_thr->callstack_top - 1))); - entry_thread = exec_thr; /* volatile copy */ - thr = (duk_hthread *) entry_thread; - entry_callstack_top = thr->callstack_top; - entry_call_recursion_depth = thr->heap->call_recursion_depth; - entry_jmpbuf_ptr = thr->heap->lj.jmpbuf_ptr; + entry_thread = exec_thr; + heap = entry_thread->heap; + entry_callstack_top = entry_thread->callstack_top; + entry_call_recursion_depth = entry_thread->heap->call_recursion_depth; +#if !defined(DUK_USE_CPP_EXCEPTIONS) + entry_jmpbuf_ptr = entry_thread->heap->lj.jmpbuf_ptr; +#endif /* - * Setjmp catchpoint setup. - * * Note: we currently assume that the setjmp() catchpoint is * not re-entrant (longjmp() cannot be called more than once * for a single setjmp()). + * + * See doc/code-issues.rst for notes on variable assignment + * before and after setjmp(). */ - reset_setjmp_catchpoint: + for (;;) { +#if !defined(DUK_USE_CPP_EXCEPTIONS) + heap->lj.jmpbuf_ptr = &jmpbuf; + DUK_ASSERT(heap->lj.jmpbuf_ptr != NULL); +#endif - DUK_ASSERT(thr != NULL); - thr->heap->lj.jmpbuf_ptr = &jmpbuf; - DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); +#if defined(DUK_USE_CPP_EXCEPTIONS) + try { +#else + if (DUK_LIKELY(DUK_SETJMP(heap->lj.jmpbuf_ptr->jb) == 0)) { +#endif + /* Execute bytecode until returned or longjmp(). */ + duk__js_execute_bytecode_inner(entry_thread, entry_callstack_top); - if (DUK_SETJMP(thr->heap->lj.jmpbuf_ptr->jb)) { - /* - * Note: any local variables accessed here must have their value - * assigned *before* the setjmp() call, OR they must be declared - * volatile. Otherwise their value is not guaranteed to be correct. - * - * 'thr' might seem to be a risky variable because it is changed - * for yield and resume. However, yield and resume are handled - * using longjmp()s. - */ +#if !defined(DUK_USE_CPP_EXCEPTIONS) + /* Successful return: restore jmpbuf and return to caller. */ + heap->lj.jmpbuf_ptr = (duk_jmpbuf *) entry_jmpbuf_ptr; +#endif - duk_small_uint_t lj_ret; - - DUK_DDD(DUK_DDDPRINT("longjmp caught by bytecode executor")); - - /* Relookup 'thr': it's not volatile so its value is not - * guaranteed. The heap->curr_thread value should always be - * valid here because longjmp callers don't switch threads, - * only the longjmp handler does that (even for RESUME and - * YIELD). - */ - DUK_ASSERT(entry_thread != NULL); - thr = entry_thread->heap->curr_thread; - - /* XXX: signalling the need to shrink check (only if unwound) */ - - /* Must be restored here to handle e.g. yields properly. */ - thr->heap->call_recursion_depth = entry_call_recursion_depth; - - /* Switch to caller's setjmp() catcher so that if an error occurs - * during error handling, it is always propagated outwards instead - * of causing an infinite loop in our own handler. - */ - - DUK_DDD(DUK_DDDPRINT("restore jmpbuf_ptr: %p -> %p", - (void *) ((thr && thr->heap) ? thr->heap->lj.jmpbuf_ptr : NULL), - (void *) entry_jmpbuf_ptr)); - thr->heap->lj.jmpbuf_ptr = (duk_jmpbuf *) entry_jmpbuf_ptr; - - lj_ret = duk__handle_longjmp(thr, (duk_hthread *) entry_thread, (duk_size_t) entry_callstack_top); - - if (lj_ret == DUK__LONGJMP_RESTART) { - /* - * Restart bytecode execution, possibly with a changed thread. - */ - thr = thr->heap->curr_thread; - goto reset_setjmp_catchpoint; - } else if (lj_ret == DUK__LONGJMP_RETHROW) { - /* - * Rethrow error to calling state. - */ - - /* thread may have changed (e.g. YIELD converted to THROW) */ - thr = thr->heap->curr_thread; - - DUK_ASSERT(thr->heap->lj.jmpbuf_ptr == entry_jmpbuf_ptr); - - duk_err_longjmp(thr); - DUK_UNREACHABLE(); - } else { - /* - * Return from bytecode executor with a return value. - */ - DUK_ASSERT(lj_ret == DUK__LONGJMP_FINISHED); - - /* XXX: return assertions for valstack, callstack, catchstack */ - - DUK_ASSERT(thr->heap->lj.jmpbuf_ptr == entry_jmpbuf_ptr); return; +#if defined(DUK_USE_CPP_EXCEPTIONS) + } catch (duk_internal_exception &exc) { +#else + } else { +#endif +#if defined(DUK_USE_CPP_EXCEPTIONS) + DUK_UNREF(exc); +#endif + DUK_DDD(DUK_DDDPRINT("longjmp caught by bytecode executor")); + + duk__handle_executor_error(heap, + entry_thread, + entry_callstack_top, + entry_call_recursion_depth +#if !defined(DUK_USE_CPP_EXCEPTIONS) + , entry_jmpbuf_ptr +#endif + ); } - DUK_UNREACHABLE(); +#if defined(DUK_USE_CPP_EXCEPTIONS) + catch (std::exception &exc) { + const char *what = exc.what(); + if (!what) { + what = "unknown"; + } + DUK_D(DUK_DPRINT("unexpected c++ std::exception (perhaps thrown by user code)")); + try { + DUK_ASSERT(heap->curr_thread != NULL); + DUK_ERROR(heap->curr_thread, DUK_ERR_API_ERROR, "caught invalid c++ std::exception '%s' (perhaps thrown by user code)", what); + } catch (duk_internal_exception exc) { + DUK_D(DUK_DPRINT("caught api error thrown from unexpected c++ std::exception")); + duk__handle_executor_error(heap, + entry_thread, + entry_callstack_top, + entry_call_recursion_depth +#if !defined(DUK_USE_CPP_EXCEPTIONS) + , entry_jmpbuf_ptr +#endif + ); + } + } catch (...) { + DUK_D(DUK_DPRINT("unexpected c++ exception (perhaps thrown by user code)")); + try { + DUK_ASSERT(heap->curr_thread != NULL); + DUK_ERROR(heap->curr_thread, DUK_ERR_API_ERROR, "caught invalid c++ exception (perhaps thrown by user code)"); + } catch (duk_internal_exception exc) { + DUK_D(DUK_DPRINT("caught api error thrown from unexpected c++ exception")); + duk__handle_executor_error(heap, + entry_thread, + entry_callstack_top, + entry_call_recursion_depth +#if !defined(DUK_USE_CPP_EXCEPTIONS) + , entry_jmpbuf_ptr +#endif + ); + } + } +#endif } + DUK_UNREACHABLE(); +} + +/* Inner executor, performance critical. */ +DUK_LOCAL DUK_NOINLINE void duk__js_execute_bytecode_inner(duk_hthread *entry_thread, duk_size_t entry_callstack_top) { + /* Current PC, accessed by other functions through thr->ptr_to_curr_pc. + * Critical for performance. It would be safest to make this volatile, + * but that eliminates performance benefits; aliasing guarantees + * should be enough though. + */ + duk_instr_t *curr_pc; /* bytecode has a stable pointer */ + + /* Hot variables for interpretation. Critical for performance, + * but must add sparingly to minimize register shuffling. + */ + duk_hthread *thr; /* stable */ + duk_tval *consts; /* stable */ + duk_uint_fast32_t ins; + /* 'funcs' is quite rarely used, so no local for it */ +#if defined(DUK_USE_EXEC_FUN_LOCAL) + duk_hcompiledfunction *fun; +#else + /* 'fun' is quite rarely used, so no local for it */ +#endif + +#ifdef DUK_USE_INTERRUPT_COUNTER + duk_int_t int_ctr; +#endif + +#ifdef DUK_USE_ASSERTIONS + duk_size_t valstack_top_base; /* valstack top, should match before interpreting each op (no leftovers) */ +#endif + /* * Restart execution by reloading thread state. * * Note that 'thr' and any thread configuration may have changed, - * so all local variables are suspect. + * so all local variables are suspect and we need to reinitialize. * * The number of local variables should be kept to a minimum: if * the variables are spilled, they will need to be loaded from * memory anyway. - */ - - restart_execution: - - /* Lookup current thread; use the volatile 'entry_thread' for this to - * avoid clobber warnings. (Any valid, reachable 'thr' value would be - * fine for this, so using 'entry_thread' is just to silence warnings.) - */ - thr = entry_thread->heap->curr_thread; - DUK_ASSERT(thr != NULL); - DUK_ASSERT(thr->callstack_top >= 1); - DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL); - DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1))); - -#ifdef DUK_USE_INTERRUPT_COUNTER - thr->interrupt_counter = thr->heap->interrupt_counter; -#endif - - /* assume that thr->valstack_bottom has been set-up before getting here */ - act = thr->callstack + thr->callstack_top - 1; - fun = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act); - DUK_ASSERT(fun != NULL); - DUK_ASSERT(thr->valstack_top - thr->valstack_bottom == fun->nregs); - bcode = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, fun); - -#if defined(DUK_USE_DEBUGGER_SUPPORT) - if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap) && !thr->heap->dbg_processing) { - thr->heap->dbg_processing = 1; - duk__executor_handle_debugger(thr, act, fun); - thr->heap->dbg_processing = 0; - } -#endif /* DUK_USE_DEBUGGER_SUPPORT */ - - /* XXX: shrink check flag? */ - - /* - * Bytecode interpreter. + * + * Any 'goto restart_execution;' code path in opcode dispatch must + * ensure 'curr_pc' is synced back to act->curr_pc before the goto + * takes place. * * The interpreter must be very careful with memory pointers, as * many pointers are not guaranteed to be 'stable' and may be @@ -60021,43 +69443,83 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { * is not changed (reallocated by growing or shrinking), or * by any garbage collection invocation (through finalizers) * - Note in particular that ANY DECREF can invalidate the - * activation pointer + * activation pointer, so for the most part a fresh lookup + * is required * * The following are not assumed to have stable pointers at all: * - the value stack (registers) of the current thread * - the catch stack of the current thread * - * See execution.txt for discussion. + * See execution.rst for discussion. */ - DUK_ASSERT(thr != NULL); - DUK_ASSERT(act != NULL); - DUK_ASSERT(fun != NULL); - DUK_ASSERT(bcode != NULL); + restart_execution: - DUK_DD(DUK_DDPRINT("restarting execution, thr %p, act %p (idx %ld), fun %p, bcode %p, " + /* Lookup current thread; use the stable 'entry_thread' for this to + * avoid clobber warnings. Any valid, reachable 'thr' value would be + * fine for this, so using 'entry_thread' is just to silence warnings. + */ + thr = entry_thread->heap->curr_thread; + DUK_ASSERT(thr != NULL); + DUK_ASSERT(thr->callstack_top >= 1); + DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL); + DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1))); + + thr->ptr_curr_pc = &curr_pc; + + /* Relookup and initialize dispatch loop variables. Debugger check. */ + { + duk_activation *act; +#if !defined(DUK_USE_EXEC_FUN_LOCAL) + duk_hcompiledfunction *fun; +#endif + + /* Assume interrupt init/counter are properly initialized here. */ + /* Assume that thr->valstack_bottom has been set-up before getting here. */ + + act = thr->callstack + thr->callstack_top - 1; + fun = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act); + DUK_ASSERT(fun != NULL); + DUK_ASSERT(thr->valstack_top - thr->valstack_bottom == fun->nregs); + consts = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, fun); + DUK_ASSERT(consts != NULL); + +#if defined(DUK_USE_DEBUGGER_SUPPORT) + if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap) && !thr->heap->dbg_processing) { + thr->heap->dbg_processing = 1; + duk__executor_recheck_debugger(thr, act, fun); + act = thr->callstack + thr->callstack_top - 1; /* relookup after side effects */ + thr->heap->dbg_processing = 0; + } +#endif /* DUK_USE_DEBUGGER_SUPPORT */ + +#ifdef DUK_USE_ASSERTIONS + valstack_top_base = (duk_size_t) (thr->valstack_top - thr->valstack); +#endif + + /* Set up curr_pc for opcode dispatch. */ + curr_pc = act->curr_pc; + } + + DUK_DD(DUK_DDPRINT("restarting execution, thr %p, act idx %ld, fun %p," "consts %p, funcs %p, lev %ld, regbot %ld, regtop %ld, catchstack_top=%ld, " "preventcount=%ld", (void *) thr, - (void *) act, (long) (thr->callstack_top - 1), - (void *) fun, - (void *) bcode, - (void *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, fun), - (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, fun), + (void *) DUK__FUN(), + (void *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, DUK__FUN()), + (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, DUK__FUN()), (long) (thr->callstack_top - 1), (long) (thr->valstack_bottom - thr->valstack), (long) (thr->valstack_top - thr->valstack), (long) thr->catchstack_top, (long) thr->callstack_preventcount)); -#ifdef DUK_USE_ASSERTIONS - valstack_top_base = (duk_size_t) (thr->valstack_top - thr->valstack); -#endif + /* Dispatch loop. */ for (;;) { DUK_ASSERT(thr->callstack_top >= 1); - DUK_ASSERT(thr->valstack_top - thr->valstack_bottom == fun->nregs); + DUK_ASSERT(thr->valstack_top - thr->valstack_bottom == DUK__FUN()->nregs); DUK_ASSERT((duk_size_t) (thr->valstack_top - thr->valstack) == valstack_top_base); /* Executor interrupt counter check, used to implement breakpoints, @@ -60066,7 +69528,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { * as fast as possible. The counter is copied back to the heap struct * whenever a thread switch occurs by the DUK_HEAP_SWITCH_THREAD() macro. */ -#ifdef DUK_USE_INTERRUPT_COUNTER +#if defined(DUK_USE_INTERRUPT_COUNTER) int_ctr = thr->interrupt_counter; if (DUK_LIKELY(int_ctr > 0)) { thr->interrupt_counter = int_ctr - 1; @@ -60074,56 +69536,76 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { /* Trigger at zero or below */ duk_small_uint_t exec_int_ret; + /* Write curr_pc back for the debugger. */ + DUK_ASSERT(thr->callstack_top > 0); + { + duk_activation *act; + act = thr->callstack + thr->callstack_top - 1; + act->curr_pc = (duk_instr_t *) curr_pc; + } + + /* Force restart caused by a function return; must recheck + * debugger breakpoints before checking line transitions, + * see GH-303. Restart and then handle interrupt_counter + * zero again. + */ +#if defined(DUK_USE_DEBUGGER_SUPPORT) + if (thr->heap->dbg_force_restart) { + DUK_DD(DUK_DDPRINT("dbg_force_restart flag forced restart execution")); /* GH-303 */ + thr->heap->dbg_force_restart = 0; + goto restart_execution; + } +#endif + exec_int_ret = duk__executor_interrupt(thr); if (exec_int_ret == DUK__INT_RESTART) { + /* curr_pc synced back above */ goto restart_execution; } } +#endif /* DUK_USE_INTERRUPT_COUNTER */ +#if defined(DUK_USE_INTERRUPT_COUNTER) && defined(DUK_USE_DEBUG) + /* For cross-checking during development: ensure dispatch count + * matches cumulative interrupt counter init value sums. + */ + thr->heap->inst_count_exec++; #endif - /* Because ANY DECREF potentially invalidates 'act' now (through - * finalization), we need to re-lookup 'act' in almost every case. - * - * XXX: future work for performance optimization: - * This is not nice; it would be nice if the program counter was a - * behind a stable pointer. For instance, put a raw bytecode pointer - * into duk_hthread struct (not into the callstack); since bytecode - * has a stable pointer this would work nicely. Whenever a call is - * made, the bytecode pointer could be backed up as an integer index - * to the calling activation. Perhaps add a macro for setting up a - * new activation (same as for setting up / switching threads)? - */ +#if defined(DUK_USE_ASSERTIONS) || defined(DUK_USE_DEBUG) + { + duk_activation *act; + act = thr->callstack + thr->callstack_top - 1; + DUK_ASSERT(curr_pc >= DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, DUK__FUN())); + DUK_ASSERT(curr_pc < DUK_HCOMPILEDFUNCTION_GET_CODE_END(thr->heap, DUK__FUN())); + DUK_UNREF(act); /* if debugging disabled */ - act = thr->callstack + thr->callstack_top - 1; - DUK_ASSERT(bcode + act->pc >= DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, fun)); - DUK_ASSERT(bcode + act->pc < DUK_HCOMPILEDFUNCTION_GET_CODE_END(thr->heap, fun)); - - DUK_DDD(DUK_DDDPRINT("executing bytecode: pc=%ld ins=0x%08lx, op=%ld, valstack_top=%ld/%ld, nregs=%ld --> %!I", - (long) act->pc, - (unsigned long) bcode[act->pc], - (long) DUK_DEC_OP(bcode[act->pc]), - (long) (thr->valstack_top - thr->valstack), - (long) (thr->valstack_end - thr->valstack), - (long) (fun ? fun->nregs : -1), - (duk_instr_t) bcode[act->pc])); + DUK_DDD(DUK_DDDPRINT("executing bytecode: pc=%ld, ins=0x%08lx, op=%ld, valstack_top=%ld/%ld, nregs=%ld --> %!I", + (long) (curr_pc - DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, DUK__FUN())), + (unsigned long) *curr_pc, + (long) DUK_DEC_OP(*curr_pc), + (long) (thr->valstack_top - thr->valstack), + (long) (thr->valstack_end - thr->valstack), + (long) (DUK__FUN() ? DUK__FUN()->nregs : -1), + (duk_instr_t) *curr_pc)); + } +#endif #if defined(DUK_USE_ASSERTIONS) - /* Quite heavy assert: check that valstack is in correctly - * initialized state. Improper shuffle instructions can - * write beyond valstack_end so this check catches them in - * the act. + /* Quite heavy assert: check valstack policy. Improper + * shuffle instructions can write beyond valstack_top/end + * so this check catches them in the act. */ { duk_tval *tv; tv = thr->valstack_top; while (tv != thr->valstack_end) { - DUK_ASSERT(DUK_TVAL_IS_UNDEFINED_UNUSED(tv)); + DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(tv)); tv++; } } #endif - ins = bcode[act->pc++]; + ins = *curr_pc++; /* Typing: use duk_small_(u)int_fast_t when decoding small * opcode fields (op, A, B, C) and duk_(u)int_fast_t when @@ -60147,52 +69629,39 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { case DUK_OP_LDREG: { duk_small_uint_fast_t a; duk_uint_fast_t bc; - duk_tval tv_tmp; duk_tval *tv1, *tv2; a = DUK_DEC_A(ins); tv1 = DUK__REGP(a); bc = DUK_DEC_BC(ins); tv2 = DUK__REGP(bc); - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_TVAL(tv1, tv2); - DUK_TVAL_INCREF(thr, tv1); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_TVAL_UPDREF_FAST(thr, tv1, tv2); /* side effects */ break; } case DUK_OP_STREG: { duk_small_uint_fast_t a; duk_uint_fast_t bc; - duk_tval tv_tmp; duk_tval *tv1, *tv2; a = DUK_DEC_A(ins); tv1 = DUK__REGP(a); bc = DUK_DEC_BC(ins); tv2 = DUK__REGP(bc); - DUK_TVAL_SET_TVAL(&tv_tmp, tv2); - DUK_TVAL_SET_TVAL(tv2, tv1); - DUK_TVAL_INCREF(thr, tv2); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_TVAL_UPDREF_FAST(thr, tv2, tv1); /* side effects */ break; } case DUK_OP_LDCONST: { duk_small_uint_fast_t a; duk_uint_fast_t bc; - duk_tval tv_tmp; duk_tval *tv1, *tv2; a = DUK_DEC_A(ins); tv1 = DUK__REGP(a); bc = DUK_DEC_BC(ins); tv2 = DUK__CONSTP(bc); - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_TVAL(tv1, tv2); - DUK_TVAL_INCREF(thr, tv2); /* may be e.g. string */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_TVAL_UPDREF_FAST(thr, tv1, tv2); /* side effects */ break; } case DUK_OP_LDINT: { duk_small_uint_fast_t a; duk_int_fast_t bc; - duk_tval tv_tmp; duk_tval *tv1; #if defined(DUK_USE_FASTINT) duk_int32_t val; @@ -60203,15 +69672,11 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { #if defined(DUK_USE_FASTINT) a = DUK_DEC_A(ins); tv1 = DUK__REGP(a); bc = DUK_DEC_BC(ins); val = (duk_int32_t) (bc - DUK_BC_LDINT_BIAS); - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_FASTINT_I32(tv1, val); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_FASTINT_I32_UPDREF(thr, tv1, val); /* side effects */ #else a = DUK_DEC_A(ins); tv1 = DUK__REGP(a); bc = DUK_DEC_BC(ins); val = (duk_double_t) (bc - DUK_BC_LDINT_BIAS); - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_NUMBER(tv1, val); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_NUMBER_UPDREF(thr, tv1, val); /* side effects */ #endif break; } @@ -60382,11 +69847,15 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { * C -> num args (N) */ - /* Note: duk_new() will call the constuctor using duk_handle_call(). + /* duk_new() will call the constuctor using duk_handle_call(). * A constructor call prevents a yield from inside the constructor, * even if the constructor is an Ecmascript function. */ + /* Don't need to sync curr_pc here; duk_new() will do that + * when it augments the created error. + */ + /* XXX: unnecessary copying of values? Just set 'top' to * b + c, and let the return handling fix up the stack frame? */ @@ -60414,6 +69883,11 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { duk_new(ctx, (duk_idx_t) c); /* [... constructor arg1 ... argN] -> [retval] */ DUK_DDD(DUK_DDDPRINT("NEW -> %!iT", (duk_tval *) duk_get_tval(ctx, -1))); duk_replace(ctx, (duk_idx_t) idx); + + /* When debugger is enabled, we need to recheck the activation + * status after returning. This is now handled by call handling + * and heap->dbg_force_restart. + */ break; } @@ -60491,6 +69965,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { case DUK_OP_GETVAR: { duk_context *ctx = (duk_context *) thr; + duk_activation *act; duk_small_uint_fast_t a = DUK_DEC_A(ins); duk_uint_fast_t bc = DUK_DEC_BC(ins); duk_tval *tv1; @@ -60501,6 +69976,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { name = DUK_TVAL_GET_STRING(tv1); DUK_ASSERT(name != NULL); DUK_DDD(DUK_DDDPRINT("GETVAR: '%!O'", (duk_heaphdr *) name)); + act = thr->callstack + thr->callstack_top - 1; (void) duk_js_getvar_activation(thr, act, name, 1 /*throw*/); /* -> [... val this] */ duk_pop(ctx); /* 'this' binding is not needed here */ @@ -60509,6 +69985,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { } case DUK_OP_PUTVAR: { + duk_activation *act; duk_small_uint_fast_t a = DUK_DEC_A(ins); duk_uint_fast_t bc = DUK_DEC_BC(ins); duk_tval *tv1; @@ -60524,11 +70001,13 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { */ tv1 = DUK__REGP(a); /* val */ + act = thr->callstack + thr->callstack_top - 1; duk_js_putvar_activation(thr, act, name, tv1, DUK__STRICT()); break; } case DUK_OP_DECLVAR: { + duk_activation *act; duk_context *ctx = (duk_context *) thr; duk_small_uint_fast_t a = DUK_DEC_A(ins); duk_small_uint_fast_t b = DUK_DEC_B(ins); @@ -60563,6 +70042,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { } tv1 = duk_get_tval(ctx, -1); + act = thr->callstack + thr->callstack_top - 1; if (duk_js_declvar_activation(thr, act, name, tv1, prop_flags, is_func_decl)) { /* already declared, must update binding value */ tv1 = duk_get_tval(ctx, -1); @@ -60574,6 +70054,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { } case DUK_OP_DELVAR: { + duk_activation *act; duk_context *ctx = (duk_context *) thr; duk_small_uint_fast_t a = DUK_DEC_A(ins); duk_small_uint_fast_t b = DUK_DEC_B(ins); @@ -60586,6 +70067,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { name = DUK_TVAL_GET_STRING(tv1); DUK_ASSERT(name != NULL); DUK_DDD(DUK_DDDPRINT("DELVAR '%!O'", (duk_heaphdr *) name)); + act = thr->callstack + thr->callstack_top - 1; rc = duk_js_delvar_activation(thr, act, name); duk_push_boolean(ctx, rc); @@ -60605,6 +70087,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { */ duk_context *ctx = (duk_context *) thr; + duk_activation *act; duk_small_uint_fast_t b = DUK_DEC_B(ins); duk_uint_fast_t idx; duk_tval *tv1; @@ -60614,6 +70097,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { DUK_ASSERT(DUK_TVAL_IS_STRING(tv1)); name = DUK_TVAL_GET_STRING(tv1); DUK_ASSERT(name != NULL); + act = thr->callstack + thr->callstack_top - 1; (void) duk_js_getvar_activation(thr, act, name, 1 /*throw*/); /* -> [... val this] */ /* Note: target registers a and a+1 may overlap with DUK__REGCONSTP(b) @@ -60642,6 +70126,8 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { case DUK_OP_CLOSURE: { duk_context *ctx = (duk_context *) thr; + duk_activation *act; + duk_hcompiledfunction *fun; duk_small_uint_fast_t a = DUK_DEC_A(ins); duk_uint_fast_t bc = DUK_DEC_BC(ins); duk_hobject *fun_temp; @@ -60651,10 +70137,13 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { */ DUK_DDD(DUK_DDDPRINT("CLOSURE to target register %ld, fnum %ld (count %ld)", - (long) a, (long) bc, (long) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(thr->heap, fun))); + (long) a, (long) bc, (long) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(thr->heap, DUK__FUN()))); DUK_ASSERT_DISABLE(bc >= 0); /* unsigned */ - DUK_ASSERT((duk_uint_t) bc < (duk_uint_t) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(thr->heap, fun)); + DUK_ASSERT((duk_uint_t) bc < (duk_uint_t) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(thr->heap, DUK__FUN())); + + act = thr->callstack + thr->callstack_top - 1; + fun = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act); fun_temp = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, fun)[bc]; DUK_ASSERT(fun_temp != NULL); DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(fun_temp)); @@ -60989,7 +70478,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { tmp = duk_js_toboolean(DUK__REGCONSTP(b)); if (tmp == (duk_bool_t) a) { /* if boolean matches A, skip next inst */ - act->pc++; + curr_pc++; } else { ; } @@ -60999,7 +70488,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { case DUK_OP_JUMP: { duk_int_fast_t abc = DUK_DEC_ABC(ins); - act->pc += abc - DUK_BC_JUMP_BIAS; + curr_pc += abc - DUK_BC_JUMP_BIAS; break; } @@ -61008,60 +70497,35 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { duk_small_uint_fast_t a = DUK_DEC_A(ins); duk_small_uint_fast_t b = DUK_DEC_B(ins); /* duk_small_uint_fast_t c = DUK_DEC_C(ins); */ - duk_tval *tv_val; + duk_small_uint_t ret_result; /* A -> flags * B -> return value reg/const * C -> currently unused */ - /* A fast return avoids full longjmp handling for a set of - * scenarios which hopefully represents the common cases. - * The compiler is responsible for emitting fast returns - * only when they are safe. Currently this means that there - * is nothing on the catch stack (not even label catchers). - * The speed advantage of fast returns (avoiding longjmp) is - * not very high, around 10-15%. + DUK__SYNC_AND_NULL_CURR_PC(); + + /* duk__handle_return() is guaranteed never to throw, except + * for potential out-of-memory situations which will then + * propagate out of the executor longjmp handler. */ -#if 0 /* XXX: Disabled for 1.0 release */ - if (a & DUK_BC_RETURN_FLAG_FAST) { - DUK_DDD(DUK_DDDPRINT("FASTRETURN attempt a=%ld b=%ld", (long) a, (long) b)); - - if (duk__handle_fast_return(thr, - (a & DUK_BC_RETURN_FLAG_HAVE_RETVAL) ? DUK__REGCONSTP(b) : NULL, - entry_thread, - entry_callstack_top)) { - DUK_DDD(DUK_DDDPRINT("FASTRETURN success a=%ld b=%ld", (long) a, (long) b)); - goto restart_execution; - } - } -#endif - - /* No fast return, slow path. */ - DUK_DDD(DUK_DDDPRINT("SLOWRETURN a=%ld b=%ld", (long) a, (long) b)); if (a & DUK_BC_RETURN_FLAG_HAVE_RETVAL) { - tv_val = DUK__REGCONSTP(b); -#if defined(DUK_OPT_FASTINT) - /* Explicit check for fastint downgrade. Do - * it also for consts for now, which is odd - * but harmless. - */ - /* XXX: restrict to reg values only? */ - - DUK_TVAL_CHKFAST_INPLACE(tv_val); -#endif - duk_push_tval(ctx, tv_val); + duk_push_tval(ctx, DUK__REGCONSTP(b)); } else { duk_push_undefined(ctx); } + ret_result = duk__handle_return(thr, + entry_thread, + entry_callstack_top); + if (ret_result == DUK__RETHAND_RESTART) { + goto restart_execution; + } + DUK_ASSERT(ret_result == DUK__RETHAND_FINISHED); - duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_RETURN); - - DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); /* in bytecode executor, should always be set */ - duk_err_longjmp(thr); - DUK_UNREACHABLE(); - break; + DUK_DDD(DUK_DDDPRINT("exiting executor after RETURN handling")); + return; } case DUK_OP_CALL: @@ -61077,6 +70541,9 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { duk_hobject *obj_func; duk_bool_t setup_rc; duk_idx_t num_stack_args; +#if !defined(DUK_USE_EXEC_FUN_LOCAL) + duk_hcompiledfunction *fun; +#endif /* A -> flags * B -> base register for call (base -> func, base+1 -> this, base+2 -> arg1 ... base+2+N-1 -> argN) @@ -61127,8 +70594,8 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { call_flags = 0; if (flag_tailcall) { - /* We request a tailcall, but in some corner cases - * call handling can decide that a tailcall is + /* We request a tail call, but in some corner cases + * call handling can decide that a tail call is * actually not possible. * See: test-bug-tailcall-preventyield-assert.c. */ @@ -61145,12 +70612,14 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { call_flags); if (setup_rc) { - /* Ecma-to-ecma call possible, may or may not be a tailcall. + /* Ecma-to-ecma call possible, may or may not be a tail call. * Avoid C recursion by being clever. */ DUK_DDD(DUK_DDDPRINT("ecma-to-ecma call setup possible, restart execution")); + /* curr_pc synced by duk_handle_ecma_call_setup() */ goto restart_execution; } + DUK_ASSERT(thr->ptr_curr_pc != NULL); /* restored if ecma-to-ecma setup fails */ DUK_DDD(DUK_DDDPRINT("ecma-to-ecma call not possible, target is native (may be lightfunc)")); @@ -61160,6 +70629,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { tv_func = DUK__REGP(idx); /* Relookup if relocated */ if (DUK_TVAL_IS_LIGHTFUNC(tv_func)) { + call_flags = 0; /* not protected, respect reclimit, not constructor */ /* There is no eval() special handling here: eval() is never @@ -61167,13 +70637,16 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { */ DUK_ASSERT(DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv_func) != duk_bi_global_object_eval); - duk_handle_call(thr, - num_stack_args, - call_flags); + duk_handle_call_unprotected(thr, + num_stack_args, + call_flags); /* duk_js_call.c is required to restore the stack reserve * so we only need to reset the top. */ +#if !defined(DUK_USE_EXEC_FUN_LOCAL) + fun = DUK__FUN(); +#endif duk_set_top(ctx, (duk_idx_t) fun->nregs); /* No need to reinit setjmp() catchpoint, as call handling @@ -61189,9 +70662,9 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { /* * Other cases, use C recursion. * - * If a tailcall was requested we ignore it and execute a normal call. + * If a tail call was requested we ignore it and execute a normal call. * Since Duktape 0.11.0 the compiler emits a RETURN opcode even after - * a tailcall to avoid test-bug-tailcall-thread-yield-resume.js. + * a tail call to avoid test-bug-tailcall-thread-yield-resume.js. * * Direct eval call: (1) call target (before following bound function * chain) is the built-in eval() function, and (2) call was made with @@ -61210,13 +70683,16 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { } } - duk_handle_call(thr, - num_stack_args, - call_flags); + duk_handle_call_unprotected(thr, + num_stack_args, + call_flags); /* duk_js_call.c is required to restore the stack reserve * so we only need to reset the top. */ +#if !defined(DUK_USE_EXEC_FUN_LOCAL) + fun = DUK__FUN(); +#endif duk_set_top(ctx, (duk_idx_t) fun->nregs); /* No need to reinit setjmp() catchpoint, as call handling @@ -61224,48 +70700,53 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { */ } -#if defined(DUK_USE_DEBUGGER_SUPPORT) /* When debugger is enabled, we need to recheck the activation - * status after returning. + * status after returning. This is now handled by call handling + * and heap->dbg_force_restart. */ - goto restart_execution; -#endif break; } case DUK_OP_TRYCATCH: { duk_context *ctx = (duk_context *) thr; + duk_activation *act; duk_catcher *cat; duk_tval *tv1; duk_small_uint_fast_t a; - duk_small_uint_fast_t b; - duk_small_uint_fast_t c; + duk_uint_fast_t bc; /* A -> flags - * B -> reg_catch; base register for 2 regs - * C -> semantics depend on flags: var_name or with_target + * BC -> reg_catch; base register for two registers used both during + * trycatch setup and when catch is triggered * * If DUK_BC_TRYCATCH_FLAG_CATCH_BINDING set: - * C is constant index for catch binding variable name. + * reg_catch + 0: catch binding variable name (string). * Automatic declarative environment is established for * the duration of the 'catch' clause. * * If DUK_BC_TRYCATCH_FLAG_WITH_BINDING set: - * C is reg/const index for with 'target value', which - * is coerced to an object and then used as a binding - * object for an environment record. The binding is - * initialized here, for the 'try' clause. + * reg_catch + 0: with 'target value', which is coerced to + * an object and then used as a bindind object for an + * environment record. The binding is initialized here, for + * the 'try' clause. * * Note that a TRYCATCH generated for a 'with' statement has no * catch or finally parts. */ + /* XXX: TRYCATCH handling should be reworked to avoid creating + * an explicit scope unless it is actually needed (e.g. function + * instances or eval is executed inside the catch block). This + * rework is not trivial because the compiler doesn't have an + * intermediate representation. When the rework is done, the + * opcode format can also be made more straightforward. + */ + /* XXX: side effect handling is quite awkward here */ - DUK_DDD(DUK_DDDPRINT("TRYCATCH: reg_catch=%ld, var_name/with_target=%ld, have_catch=%ld, " + DUK_DDD(DUK_DDDPRINT("TRYCATCH: reg_catch=%ld, have_catch=%ld, " "have_finally=%ld, catch_binding=%ld, with_binding=%ld (flags=0x%02lx)", - (long) DUK_DEC_B(ins), - (long) DUK_DEC_C(ins), + (long) DUK_DEC_BC(ins), (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_HAVE_CATCH ? 1 : 0), (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY ? 1 : 0), (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_CATCH_BINDING ? 1 : 0), @@ -61273,9 +70754,9 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { (unsigned long) DUK_DEC_A(ins))); a = DUK_DEC_A(ins); - b = DUK_DEC_B(ins); - c = DUK_DEC_C(ins); + bc = DUK_DEC_BC(ins); + act = thr->callstack + thr->callstack_top - 1; DUK_ASSERT(thr->callstack_top >= 1); /* 'with' target must be created first, in case we run out of memory */ @@ -61300,7 +70781,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJENV), -1); /* no prototype, updated below */ - duk_push_tval(ctx, DUK__REGCONSTP(c)); + duk_push_tval(ctx, DUK__REGP(bc)); duk_to_object(ctx, -1); duk_dup(ctx, -1); @@ -61335,8 +70816,13 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { if (a & DUK_BC_TRYCATCH_FLAG_CATCH_BINDING) { DUK_DDD(DUK_DDDPRINT("catch binding flag set to catcher")); cat->flags |= DUK_CAT_FLAG_CATCH_BINDING_ENABLED; - tv1 = DUK__CONSTP(c); + tv1 = DUK__REGP(bc); DUK_ASSERT(DUK_TVAL_IS_STRING(tv1)); + + /* borrowed reference; although 'tv1' comes from a register, + * its value was loaded using LDCONST so the constant will + * also exist and be reachable. + */ cat->h_varname = DUK_TVAL_GET_STRING(tv1); } else if (a & DUK_BC_TRYCATCH_FLAG_WITH_BINDING) { /* env created above to stack top */ @@ -61352,7 +70838,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { DUK_ASSERT(new_env != NULL); act = thr->callstack + thr->callstack_top - 1; /* relookup (side effects) */ - DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, new_env, act->lex_env); + DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, new_env, act->lex_env); /* side effects */ act = thr->callstack + thr->callstack_top - 1; /* relookup (side effects) */ act->lex_env = new_env; @@ -61362,17 +70848,32 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { ; } + /* Registers 'bc' and 'bc + 1' are written in longjmp handling + * and if their previous values (which are temporaries) become + * unreachable -and- have a finalizer, there'll be a function + * call during error handling which is not supported now (GH-287). + * Ensure that both 'bc' and 'bc + 1' have primitive values to + * guarantee no finalizer calls in error handling. Scrubbing also + * ensures finalizers for the previous values run here rather than + * later. Error handling related values are also written to 'bc' + * and 'bc + 1' but those values never become unreachable during + * error handling, so there's no side effect problem even if the + * error value has a finalizer. + */ + duk_to_undefined(ctx, bc); + duk_to_undefined(ctx, bc + 1); + cat = thr->catchstack + thr->catchstack_top - 1; /* relookup (side effects) */ cat->callstack_index = thr->callstack_top - 1; - cat->pc_base = act->pc; /* pre-incremented, points to first jump slot */ - cat->idx_base = (duk_size_t) (thr->valstack_bottom - thr->valstack) + b; + cat->pc_base = (duk_instr_t *) curr_pc; /* pre-incremented, points to first jump slot */ + cat->idx_base = (duk_size_t) (thr->valstack_bottom - thr->valstack) + bc; DUK_DDD(DUK_DDDPRINT("TRYCATCH catcher: flags=0x%08lx, callstack_index=%ld, pc_base=%ld, " "idx_base=%ld, h_varname=%!O", (unsigned long) cat->flags, (long) cat->callstack_index, (long) cat->pc_base, (long) cat->idx_base, (duk_heaphdr *) cat->h_varname)); - act->pc += 2; /* skip jump slots */ + curr_pc += 2; /* skip jump slots */ break; } @@ -61385,7 +70886,6 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { duk_small_uint_fast_t a = DUK_DEC_A(ins); duk_uint_fast_t bc = DUK_DEC_BC(ins); duk_tval *tv1, *tv2; - duk_tval tv_tmp; duk_double_t x, y, z; /* Two lowest bits of opcode are used to distinguish @@ -61416,10 +70916,8 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { DUK_TVAL_SET_FASTINT(tv1, y_fi); /* no need for refcount update */ tv2 = DUK__REGP(a); - DUK_TVAL_SET_TVAL(&tv_tmp, tv2); z_fi = (ins & DUK_ENC_OP(0x02)) ? x_fi : y_fi; - DUK_TVAL_SET_FASTINT(tv2, z_fi); /* no need for incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_FASTINT_UPDREF(thr, tv2, z_fi); /* side effects */ break; } skip_fastint: @@ -61451,10 +70949,8 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { } tv2 = DUK__REGP(a); - DUK_TVAL_SET_TVAL(&tv_tmp, tv2); z = (ins & DUK_ENC_OP(0x02)) ? x : y; - DUK_TVAL_SET_NUMBER(tv2, z); /* no need for incref */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_NUMBER_UPDREF(thr, tv2, z); /* side effects */ break; } @@ -61464,6 +70960,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { case DUK_OP_POSTINCV: case DUK_OP_POSTDECV: { duk_context *ctx = (duk_context *) thr; + duk_activation *act; duk_small_uint_fast_t a = DUK_DEC_A(ins); duk_uint_fast_t bc = DUK_DEC_BC(ins); duk_double_t x, y; @@ -61482,6 +70979,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { DUK_ASSERT(DUK_TVAL_IS_STRING(tv1)); name = DUK_TVAL_GET_STRING(tv1); DUK_ASSERT(name != NULL); + act = thr->callstack + thr->callstack_top - 1; (void) duk_js_getvar_activation(thr, act, name, 1 /*throw*/); /* -> [... val this] */ /* XXX: fastint fast path would be very useful here */ @@ -61584,7 +71082,6 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { case DUK_EXTRAOP_LDTHIS: { /* Note: 'this' may be bound to any value, not just an object */ duk_uint_fast_t bc = DUK_DEC_BC(ins); - duk_tval tv_tmp; duk_tval *tv1, *tv2; tv1 = DUK__REGP(bc); @@ -61593,48 +71090,36 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { DUK_DDD(DUK_DDDPRINT("LDTHIS: %!T to r%ld", (duk_tval *) tv2, (long) bc)); - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_TVAL(tv1, tv2); - DUK_TVAL_INCREF(thr, tv1); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_TVAL_UPDREF_FAST(thr, tv1, tv2); /* side effects */ break; } case DUK_EXTRAOP_LDUNDEF: { duk_uint_fast_t bc = DUK_DEC_BC(ins); - duk_tval tv_tmp; duk_tval *tv1; tv1 = DUK__REGP(bc); - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_UNDEFINED_ACTUAL(tv1); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv1); /* side effects */ break; } case DUK_EXTRAOP_LDNULL: { duk_uint_fast_t bc = DUK_DEC_BC(ins); - duk_tval tv_tmp; duk_tval *tv1; tv1 = DUK__REGP(bc); - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_NULL(tv1); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_NULL_UPDREF(thr, tv1); /* side effects */ break; } case DUK_EXTRAOP_LDTRUE: case DUK_EXTRAOP_LDFALSE: { duk_uint_fast_t bc = DUK_DEC_BC(ins); - duk_tval tv_tmp; duk_tval *tv1; duk_small_uint_fast_t bval = (extraop == DUK_EXTRAOP_LDTRUE ? 1 : 0); tv1 = DUK__REGP(bc); - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_BOOLEAN(tv1, bval); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_BOOLEAN_UPDREF(thr, tv1, bval); /* side effects */ break; } @@ -61686,6 +71171,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { case DUK_EXTRAOP_TYPEOFID: { duk_context *ctx = (duk_context *) thr; + duk_activation *act; duk_small_uint_fast_t b = DUK_DEC_B(ins); duk_small_uint_fast_t c = DUK_DEC_C(ins); duk_hstring *name; @@ -61698,6 +71184,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { tv = DUK__REGCONSTP(c); /* XXX: this could be a DUK__CONSTP instead */ DUK_ASSERT(DUK_TVAL_IS_STRING(tv)); name = DUK_TVAL_GET_STRING(tv); + act = thr->callstack + thr->callstack_top - 1; if (duk_js_getvar_activation(thr, act, name, 0 /*throw*/)) { /* -> [... val this] */ tv = duk_get_tval(ctx, -2); @@ -61768,7 +71255,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { /* [ ... enum ] -> [ ... next_key ] */ DUK_DDD(DUK_DDDPRINT("enum active, next key is %!T, skip jump slot ", (duk_tval *) duk_get_tval(ctx, -1))); - act->pc++;; + curr_pc++; } else { /* [ ... enum ] -> [ ... ] */ DUK_DDD(DUK_DDDPRINT("enum finished, execute jump slot")); @@ -61852,7 +71339,6 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { case DUK_EXTRAOP_ENDTRY: { duk_catcher *cat; - duk_tval tv_tmp; duk_tval *tv1; DUK_ASSERT(thr->catchstack_top >= 1); @@ -61869,16 +71355,16 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { tv1 = thr->valstack + cat->idx_base; DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top); - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_UNDEFINED_ACTUAL(tv1); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv1); /* side effects */ tv1 = NULL; tv1 = thr->valstack + cat->idx_base + 1; DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top); - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_NUMBER(tv1, (duk_double_t) DUK_LJ_TYPE_NORMAL); /* XXX: set int */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ +#if defined(DUK_USE_FASTINT) + DUK_TVAL_SET_FASTINT_U32_UPDREF(thr, tv1, (duk_uint32_t) DUK_LJ_TYPE_NORMAL); /* side effects */ +#else + DUK_TVAL_SET_NUMBER_UPDREF(thr, tv1, (duk_double_t) DUK_LJ_TYPE_NORMAL); /* side effects */ +#endif tv1 = NULL; DUK_CAT_CLEAR_FINALLY_ENABLED(cat); @@ -61888,13 +71374,13 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { /* no need to unwind callstack */ } - act->pc = cat->pc_base + 1; + curr_pc = cat->pc_base + 1; break; } case DUK_EXTRAOP_ENDCATCH: { + duk_activation *act; duk_catcher *cat; - duk_tval tv_tmp; duk_tval *tv1; DUK_ASSERT(thr->catchstack_top >= 1); @@ -61904,6 +71390,8 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { cat = thr->catchstack + thr->catchstack_top - 1; DUK_ASSERT(!DUK_CAT_HAS_CATCH_ENABLED(cat)); /* cleared before entering catch part */ + act = thr->callstack + thr->callstack_top - 1; + if (DUK_CAT_HAS_LEXENV_ACTIVE(cat)) { duk_hobject *prev_env; @@ -61925,16 +71413,16 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { tv1 = thr->valstack + cat->idx_base; DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top); - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_UNDEFINED_ACTUAL(tv1); - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ + DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv1); /* side effects */ tv1 = NULL; tv1 = thr->valstack + cat->idx_base + 1; DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top); - DUK_TVAL_SET_TVAL(&tv_tmp, tv1); - DUK_TVAL_SET_NUMBER(tv1, (duk_double_t) DUK_LJ_TYPE_NORMAL); /* XXX: set int */ - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ +#if defined(DUK_USE_FASTINT) + DUK_TVAL_SET_FASTINT_U32_UPDREF(thr, tv1, (duk_uint32_t) DUK_LJ_TYPE_NORMAL); /* side effects */ +#else + DUK_TVAL_SET_NUMBER_UPDREF(thr, tv1, (duk_double_t) DUK_LJ_TYPE_NORMAL); /* side effects */ +#endif tv1 = NULL; DUK_CAT_CLEAR_FINALLY_ENABLED(cat); @@ -61944,7 +71432,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { /* no need to unwind callstack */ } - act->pc = cat->pc_base + 1; + curr_pc = cat->pc_base + 1; break; } @@ -61952,7 +71440,11 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { duk_context *ctx = (duk_context *) thr; duk_catcher *cat; duk_tval *tv1; - duk_small_uint_fast_t cont_type; + duk_small_uint_t cont_type; + duk_small_uint_t ret_result; + + /* Sync and NULL early. */ + DUK__SYNC_AND_NULL_CURR_PC(); DUK_ASSERT(thr->catchstack_top >= 1); DUK_ASSERT(thr->callstack_top >= 1); @@ -61973,29 +71465,86 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { tv1 = thr->valstack + cat->idx_base + 1; /* type */ DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv1)); - cont_type = (duk_small_uint_fast_t) DUK_TVAL_GET_NUMBER(tv1); + cont_type = (duk_small_uint_t) DUK_TVAL_GET_NUMBER(tv1); - if (cont_type == DUK_LJ_TYPE_NORMAL) { + switch (cont_type) { + case DUK_LJ_TYPE_NORMAL: { DUK_DDD(DUK_DDDPRINT("ENDFIN: finally part finishing with 'normal' (non-abrupt) completion -> " "dismantle catcher, resume execution after ENDFIN")); duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1); /* no need to unwind callstack */ - } else { + goto restart_execution; + } + case DUK_LJ_TYPE_RETURN: { + DUK_DDD(DUK_DDDPRINT("ENDFIN: finally part finishing with 'return' complation -> dismantle " + "catcher, handle return, lj.value1=%!T", thr->valstack + cat->idx_base)); + + /* Not necessary to unwind catchstack: return handling will + * do it. The finally flag of 'cat' is no longer set. The + * catch flag may be set, but it's not checked by return handling. + */ + DUK_ASSERT(!DUK_CAT_HAS_FINALLY_ENABLED(cat)); /* cleared before entering finally */ +#if 0 + duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1); +#endif + + duk_push_tval(ctx, thr->valstack + cat->idx_base); + ret_result = duk__handle_return(thr, + entry_thread, + entry_callstack_top); + if (ret_result == DUK__RETHAND_RESTART) { + goto restart_execution; + } + DUK_ASSERT(ret_result == DUK__RETHAND_FINISHED); + + DUK_DDD(DUK_DDDPRINT("exiting executor after ENDFIN and RETURN (pseudo) longjmp type")); + return; + } + case DUK_LJ_TYPE_BREAK: + case DUK_LJ_TYPE_CONTINUE: { + duk_uint_t label_id; + duk_small_uint_t lj_type; + + /* Not necessary to unwind catchstack: break/continue + * handling will do it. The finally flag of 'cat' is + * no longer set. The catch flag may be set, but it's + * not checked by break/continue handling. + */ +#if 0 + duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1); +#endif + + tv1 = thr->valstack + cat->idx_base; + DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv1)); +#if defined(DUK_USE_FASTINT) + DUK_ASSERT(DUK_TVAL_IS_FASTINT(tv1)); + label_id = (duk_small_uint_t) DUK_TVAL_GET_FASTINT_U32(tv1); +#else + label_id = (duk_small_uint_t) DUK_TVAL_GET_NUMBER(tv1); +#endif + lj_type = cont_type; + duk__handle_break_or_continue(thr, label_id, lj_type); + goto restart_execution; + } + default: { DUK_DDD(DUK_DDDPRINT("ENDFIN: finally part finishing with abrupt completion, lj_type=%ld -> " "dismantle catcher, re-throw error", (long) cont_type)); duk_push_tval(ctx, thr->valstack + cat->idx_base); - /* XXX: assert lj type valid */ duk_err_setup_heap_ljstate(thr, (duk_small_int_t) cont_type); +#if !defined(DUK_USE_CPP_EXCEPTIONS) DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); /* always in executor */ +#endif duk_err_longjmp(thr); DUK_UNREACHABLE(); } + } - /* continue execution after ENDFIN */ + /* Must restart in all cases because we NULLed thr->ptr_curr_pc. */ + DUK_UNREACHABLE(); break; } @@ -62008,6 +71557,12 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { * break re-throwing for instance. */ + /* Sync so that augmentation sees up-to-date activations, NULL + * thr->ptr_curr_pc so that it's not used if side effects occur + * in augmentation or longjmp handling. + */ + DUK__SYNC_AND_NULL_CURR_PC(); + duk_dup(ctx, (duk_idx_t) bc); DUK_DDD(DUK_DDDPRINT("THROW ERROR (BYTECODE): %!dT (before throw augment)", (duk_tval *) duk_get_tval(ctx, -1))); @@ -62019,9 +71574,10 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_THROW); +#if !defined(DUK_USE_CPP_EXCEPTIONS) DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); /* always in executor */ +#endif duk_err_longjmp(thr); - DUK_UNREACHABLE(); break; } @@ -62047,10 +71603,14 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { * from precompiled bytecode. */ #if defined(DUK_USE_DEBUGGER_SUPPORT) - DUK_D(DUK_DPRINT("DEBUGGER statement encountered, halt execution")); if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) { - DUK_HEAP_SET_PAUSED(thr->heap); + DUK_D(DUK_DPRINT("DEBUGGER statement encountered, halt execution")); + DUK__SYNC_AND_NULL_CURR_PC(); + duk_debug_halt_execution(thr, 1 /*use_prev_pc*/); + DUK_D(DUK_DPRINT("DEBUGGER statement finished, resume execution")); goto restart_execution; + } else { + DUK_D(DUK_DPRINT("DEBUGGER statement ignored, debugger not attached")); } #else DUK_D(DUK_DPRINT("DEBUGGER statement ignored, no debugger support")); @@ -62059,43 +71619,23 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { } case DUK_EXTRAOP_BREAK: { - duk_context *ctx = (duk_context *) thr; duk_uint_fast_t bc = DUK_DEC_BC(ins); - /* always the "slow break" variant (longjmp'ing); a "fast break" is - * simply an DUK_OP_JUMP. - */ - DUK_DDD(DUK_DDDPRINT("BREAK: %ld", (long) bc)); - duk_push_uint(ctx, (duk_uint_t) bc); - duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_BREAK); - - DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); /* always in executor */ - duk_err_longjmp(thr); - - DUK_UNREACHABLE(); - break; + DUK__SYNC_AND_NULL_CURR_PC(); + duk__handle_break_or_continue(thr, (duk_uint_t) bc, DUK_LJ_TYPE_BREAK); + goto restart_execution; } case DUK_EXTRAOP_CONTINUE: { - duk_context *ctx = (duk_context *) thr; duk_uint_fast_t bc = DUK_DEC_BC(ins); - /* always the "slow continue" variant (longjmp'ing); a "fast continue" is - * simply an DUK_OP_JUMP. - */ - DUK_DDD(DUK_DDDPRINT("CONTINUE: %ld", (long) bc)); - duk_push_uint(ctx, (duk_uint_t) bc); - duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_CONTINUE); - - DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); /* always in executor */ - duk_err_longjmp(thr); - - DUK_UNREACHABLE(); - break; + DUK__SYNC_AND_NULL_CURR_PC(); + duk__handle_break_or_continue(thr, (duk_uint_t) bc, DUK_LJ_TYPE_CONTINUE); + goto restart_execution; } case DUK_EXTRAOP_BNOT: { @@ -62150,7 +71690,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { cat->flags = DUK_CAT_TYPE_LABEL | (bc << DUK_CAT_LABEL_SHIFT); cat->callstack_index = thr->callstack_top - 1; - cat->pc_base = act->pc; /* pre-incremented, points to first jump slot */ + cat->pc_base = (duk_instr_t *) curr_pc; /* pre-incremented, points to first jump slot */ cat->idx_base = 0; /* unused for label */ cat->h_varname = NULL; @@ -62159,7 +71699,7 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { (long) cat->flags, (long) cat->callstack_index, (long) cat->pc_base, (long) cat->idx_base, (duk_heaphdr *) cat->h_varname, (long) DUK_CAT_GET_LABEL(cat))); - act->pc += 2; /* skip jump slots */ + curr_pc += 2; /* skip jump slots */ break; } @@ -62184,32 +71724,6 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { break; } -#ifdef DUK_USE_DEBUG - case DUK_EXTRAOP_DUMPREG: { - DUK_D(DUK_DPRINT("DUMPREG: %ld -> %!T", - (long) DUK_DEC_BC(ins), - (duk_tval *) duk_get_tval((duk_context *) thr, (duk_idx_t) DUK_DEC_BC(ins)))); - break; - } - - case DUK_EXTRAOP_DUMPREGS: { - duk_idx_t i, i_top; - i_top = duk_get_top((duk_context *) thr); - DUK_D(DUK_DPRINT("DUMPREGS: %ld regs", (long) i_top)); - for (i = 0; i < i_top; i++) { - DUK_D(DUK_DPRINT(" r%ld -> %!dT", - (long) i, - (duk_tval *) duk_get_tval((duk_context *) thr, i))); - } - break; - } - - case DUK_EXTRAOP_LOGMARK: { - DUK_D(DUK_DPRINT("LOGMARK: mark %ld at pc %ld", (long) DUK_DEC_BC(ins), (long) (act->pc - 1))); /* -1, autoinc */ - break; - } -#endif /* DUK_USE_DEBUG */ - default: { DUK__INTERNAL_ERROR("invalid extra opcode"); } @@ -62237,7 +71751,16 @@ DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) { #endif } +#undef DUK__LONGJMP_RESTART +#undef DUK__LONGJMP_FINISHED +#undef DUK__LONGJMP_RETHROW + +#undef DUK__RETHAND_RESTART +#undef DUK__RETHAND_FINISHED + #undef DUK__INTERNAL_ERROR +#undef DUK__SYNC_CURR_PC +#undef DUK__SYNC_AND_NULL_CURR_PC #line 1 "duk_js_ops.c" /* * Ecmascript specification algorithm and conversion helpers. @@ -62343,6 +71866,7 @@ DUK_INTERNAL duk_bool_t duk_js_toboolean(duk_tval *tv) { /* number */ duk_double_t d; int c; + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv)); DUK_ASSERT(DUK_TVAL_IS_DOUBLE(tv)); d = DUK_TVAL_GET_DOUBLE(tv); c = DUK_FPCLASSIFY((double) d); @@ -62481,6 +72005,7 @@ DUK_INTERNAL duk_double_t duk_js_tonumber(duk_hthread *thr, duk_tval *tv) { #endif default: { /* number */ + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv)); DUK_ASSERT(DUK_TVAL_IS_DOUBLE(tv)); return DUK_TVAL_GET_DOUBLE(tv); } @@ -62858,7 +72383,7 @@ DUK_INTERNAL duk_bool_t duk_js_equals_helper(duk_hthread *thr, duk_tval *tv_x, d DUK_ASSERT(len_x == len_y); DUK_ASSERT(len_x == 0 || buf_x != NULL); DUK_ASSERT(len_y == 0 || buf_y != NULL); - return (DUK_MEMCMP(buf_x, buf_y, len_x) == 0) ? 1 : 0; + return (DUK_MEMCMP((const void *) buf_x, (const void *) buf_y, (size_t) len_x) == 0) ? 1 : 0; } } case DUK_TAG_LIGHTFUNC: { @@ -62878,6 +72403,8 @@ DUK_INTERNAL duk_bool_t duk_js_equals_helper(duk_hthread *thr, duk_tval *tv_x, d case DUK_TAG_FASTINT: #endif default: { + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv_x)); + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv_y)); DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_x)); DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_y)); DUK_UNREACHABLE(); @@ -62935,20 +72462,20 @@ DUK_INTERNAL duk_bool_t duk_js_equals_helper(duk_hthread *thr, duk_tval *tv_x, d duk_hbuffer *h_y = DUK_TVAL_GET_BUFFER(tv_y); duk_size_t len_x = DUK_HSTRING_GET_BYTELEN(h_x); duk_size_t len_y = DUK_HBUFFER_GET_SIZE(h_y); - void *buf_x; - void *buf_y; + const void *buf_x; + const void *buf_y; if (len_x != len_y) { return 0; } - buf_x = (void *) DUK_HSTRING_GET_DATA(h_x); - buf_y = (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_y); + buf_x = (const void *) DUK_HSTRING_GET_DATA(h_x); + buf_y = (const void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_y); /* if len_x == len_y == 0, buf_x and/or buf_y may * be NULL, but that's OK. */ DUK_ASSERT(len_x == len_y); DUK_ASSERT(len_x == 0 || buf_x != NULL); DUK_ASSERT(len_y == 0 || buf_y != NULL); - return (DUK_MEMCMP(buf_x, buf_y, len_x) == 0) ? 1 : 0; + return (DUK_MEMCMP((const void *) buf_x, (const void *) buf_y, (size_t) len_x) == 0) ? 1 : 0; } /* Boolean/any -> coerce boolean to number and try again. If boolean is @@ -63005,6 +72532,36 @@ DUK_INTERNAL duk_bool_t duk_js_equals_helper(duk_hthread *thr, duk_tval *tv_x, d * needs to push stuff on the stack anyway... */ +DUK_INTERNAL duk_small_int_t duk_js_data_compare(const duk_uint8_t *buf1, const duk_uint8_t *buf2, duk_size_t len1, duk_size_t len2) { + duk_size_t prefix_len; + duk_small_int_t rc; + + prefix_len = (len1 <= len2 ? len1 : len2); + + /* DUK_MEMCMP() is guaranteed to return zero (equal) for zero length + * inputs so no zero length check is needed. + */ + rc = DUK_MEMCMP((const void *) buf1, + (const void *) buf2, + (size_t) prefix_len); + + if (rc < 0) { + return -1; + } else if (rc > 0) { + return 1; + } + + /* prefix matches, lengths matter now */ + if (len1 < len2) { + /* e.g. "x" < "xx" */ + return -1; + } else if (len1 > len2) { + return 1; + } + + return 0; +} + DUK_INTERNAL duk_small_int_t duk_js_string_compare(duk_hstring *h1, duk_hstring *h2) { /* * String comparison (E5 Section 11.8.5, step 4), which @@ -63019,45 +72576,29 @@ DUK_INTERNAL duk_small_int_t duk_js_string_compare(duk_hstring *h1, duk_hstring * is not an issue for compliance. */ - duk_size_t h1_len, h2_len, prefix_len; - duk_small_int_t rc; + DUK_ASSERT(h1 != NULL); + DUK_ASSERT(h2 != NULL); + + return duk_js_data_compare((const duk_uint8_t *) DUK_HSTRING_GET_DATA(h1), + (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h2), + (duk_size_t) DUK_HSTRING_GET_BYTELEN(h1), + (duk_size_t) DUK_HSTRING_GET_BYTELEN(h2)); +} + +#if 0 /* unused */ +DUK_INTERNAL duk_small_int_t duk_js_buffer_compare(duk_heap *heap, duk_hbuffer *h1, duk_hbuffer *h2) { + /* Similar to String comparison. */ DUK_ASSERT(h1 != NULL); DUK_ASSERT(h2 != NULL); - h1_len = DUK_HSTRING_GET_BYTELEN(h1); - h2_len = DUK_HSTRING_GET_BYTELEN(h2); - prefix_len = (h1_len <= h2_len ? h1_len : h2_len); + DUK_UNREF(heap); - /* XXX: this special case can now be removed with DUK_MEMCMP */ - /* memcmp() should return zero (equal) for zero length, but avoid - * it because there are some platform specific bugs. Don't use - * strncmp() because it stops comparing at a NUL. - */ - - if (prefix_len == 0) { - rc = 0; - } else { - rc = DUK_MEMCMP((const char *) DUK_HSTRING_GET_DATA(h1), - (const char *) DUK_HSTRING_GET_DATA(h2), - prefix_len); - } - - if (rc < 0) { - return -1; - } else if (rc > 0) { - return 1; - } - - /* prefix matches, lengths matter now */ - if (h1_len < h2_len) { - /* e.g. "x" < "xx" */ - return -1; - } else if (h1_len > h2_len) { - return 1; - } - - return 0; + return duk_js_data_compare((const duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(heap, h1), + (const duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(heap, h2), + (duk_size_t) DUK_HBUFFER_GET_SIZE(h1), + (duk_size_t) DUK_HBUFFER_GET_SIZE(h2)); } +#endif DUK_INTERNAL duk_bool_t duk_js_compare_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags) { duk_context *ctx = (duk_context *) thr; @@ -63248,6 +72789,9 @@ DUK_INTERNAL duk_bool_t duk_js_compare_helper(duk_hthread *thr, duk_tval *tv_x, * E5 Section 15.3.4.5.3 * * For other objects, a TypeError is thrown. + * + * Limited Proxy support: don't support 'getPrototypeOf' trap but + * continue lookup in Proxy target if the value is a Proxy. */ DUK_INTERNAL duk_bool_t duk_js_instanceof(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y) { @@ -63337,6 +72881,13 @@ DUK_INTERNAL duk_bool_t duk_js_instanceof(duk_hthread *thr, duk_tval *tv_x, duk_ proto = duk_require_hobject(ctx, -1); duk_pop(ctx); /* -> [ ... lval rval ] */ + DUK_ASSERT(val != NULL); + +#if defined(DUK_USE_ES6_PROXY) + val = duk_hobject_resolve_proxy_target(thr, val); + DUK_ASSERT(val != NULL); +#endif + sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY; do { /* @@ -63357,11 +72908,19 @@ DUK_INTERNAL duk_bool_t duk_js_instanceof(duk_hthread *thr, duk_tval *tv_x, duk_ * also the built-in Function prototype, the result is true. */ + DUK_ASSERT(val != NULL); val = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, val); if (!val) { goto pop_and_false; - } else if (val == proto) { + } + + DUK_ASSERT(val != NULL); +#if defined(DUK_USE_ES6_PROXY) + val = duk_hobject_resolve_proxy_target(thr, val); +#endif + + if (val == proto) { goto pop_and_true; } @@ -63488,6 +73047,7 @@ DUK_INTERNAL duk_hstring *duk_js_typeof(duk_hthread *thr, duk_tval *tv_x) { #endif default: { /* number */ + DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv_x)); DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_x)); stridx = DUK_STRIDX_LC_NUMBER; break; @@ -63578,8 +73138,8 @@ DUK_INTERNAL duk_uarridx_t duk_js_to_arrayindex_string_helper(duk_hstring *h) { * convenient field). The prototype chain is not followed in the ordinary * sense for variable lookups. * - * See identifier-handling.txt for more details on the identifier algorithms - * and the internal representation. See function-objects.txt for details on + * See identifier-handling.rst for more details on the identifier algorithms + * and the internal representation. See function-objects.rst for details on * what function templates and instances are expected to look like. * * Care must be taken to avoid duk_tval pointer invalidation caused by @@ -63620,7 +73180,7 @@ typedef struct { * * See E5 Section 13.2 for detailed requirements on the function objects; * there are no similar requirements for function "templates" which are an - * implementation dependent internal feature. Also see function-objects.txt + * implementation dependent internal feature. Also see function-objects.rst * for a discussion on the function instance properties provided by this * implementation. * @@ -63751,7 +73311,13 @@ void duk_js_push_closure(duk_hthread *thr, DUK_HOBJECT_SET_NOTAIL(&fun_clos->obj); } /* DUK_HOBJECT_FLAG_NEWENV: handled below */ - DUK_ASSERT(!DUK_HOBJECT_HAS_NAMEBINDING(&fun_clos->obj)); + if (DUK_HOBJECT_HAS_NAMEBINDING(&fun_temp->obj)) { + /* Although NAMEBINDING is not directly needed for using + * function instances, it's needed by bytecode dump/load + * so copy it too. + */ + DUK_HOBJECT_SET_NAMEBINDING(&fun_clos->obj); + } if (DUK_HOBJECT_HAS_CREATEARGS(&fun_temp->obj)) { DUK_HOBJECT_SET_CREATEARGS(&fun_clos->obj); } @@ -63772,7 +73338,7 @@ void duk_js_push_closure(duk_hthread *thr, * _Lexenv is always set; _Varenv defaults to _Lexenv if missing, * so _Varenv is only set if _Lexenv != _Varenv. * - * This is relatively complex, see doc/identifier-handling.txt. + * This is relatively complex, see doc/identifier-handling.rst. */ if (DUK_HOBJECT_HAS_NEWENV(&fun_temp->obj)) { @@ -64445,6 +74011,8 @@ duk_bool_t duk__get_identifier_reference(duk_hthread *thr, duk_bool_t parents, duk__id_lookup_result *out) { duk_tval *tv; + duk_tval *tv_target; + duk_tval tv_name; duk_uint_t sanity; DUK_ASSERT(thr != NULL); @@ -64606,7 +74174,8 @@ duk_bool_t duk__get_identifier_reference(duk_hthread *thr, * * Binding (target) object is an external, uncontrolled object. * Identifier may be bound in an ancestor property, and may be - * an accessor. + * an accessor. Target can also be a Proxy which we must support + * here. */ /* XXX: we could save space by using _Target OR _This. If _Target, assume @@ -64615,24 +74184,38 @@ duk_bool_t duk__get_identifier_reference(duk_hthread *thr, */ duk_hobject *target; + duk_bool_t found; DUK_ASSERT(cl == DUK_HOBJECT_CLASS_OBJENV); - tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_TARGET(thr)); - DUK_ASSERT(tv != NULL); - DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv)); - target = DUK_TVAL_GET_OBJECT(tv); + tv_target = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_TARGET(thr)); + DUK_ASSERT(tv_target != NULL); + DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv_target)); + target = DUK_TVAL_GET_OBJECT(tv_target); DUK_ASSERT(target != NULL); - /* Note: we must traverse the prototype chain, so use an actual - * hasprop call here. The property may also be an accessor, so - * we can't get an duk_tval pointer here. + /* Target may be a Proxy or property may be an accessor, so we must + * use an actual, Proxy-aware hasprop check here. * * out->holder is NOT set to the actual duk_hobject where the - * property is found, but rather the target object. + * property is found, but rather the object binding target object. */ - if (duk_hobject_hasprop_raw(thr, target, name)) { + if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(target)) { + DUK_ASSERT(name != NULL); + DUK_TVAL_SET_STRING(&tv_name, name); + + found = duk_hobject_hasprop(thr, tv_target, &tv_name); + } else { + /* XXX: duk_hobject_hasprop() would be correct for + * non-Proxy objects too, but it is about ~20-25% + * slower at present so separate code paths for + * Proxy and non-Proxy now. + */ + found = duk_hobject_hasprop_raw(thr, target, name); + } + + if (found) { out->value = NULL; /* can't get value, may be accessor */ out->attrs = 0; /* irrelevant when out->value == NULL */ tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_THIS(thr)); @@ -64890,17 +74473,13 @@ void duk__putvar_helper(duk_hthread *thr, * (immutable binding), use duk_hobject_putprop() which * will respect mutability. */ - duk_tval tv_tmp; duk_tval *tv_val; DUK_ASSERT(ref.this_binding == NULL); /* always for register bindings */ tv_val = ref.value; DUK_ASSERT(tv_val != NULL); - DUK_TVAL_SET_TVAL(&tv_tmp, tv_val); - DUK_TVAL_SET_TVAL(tv_val, val); - DUK_TVAL_INCREF(thr, val); - DUK_TVAL_DECREF(thr, &tv_tmp); /* must be last */ + DUK_TVAL_SET_TVAL_UPDREF(thr, tv_val, val); /* side effects */ /* ref.value and ref.this_binding invalidated here */ } else { @@ -65243,12 +74822,8 @@ duk_bool_t duk__declvar_helper(duk_hthread *thr, DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); DUK_UNREF(tmp); } else { - duk_tval tv_tmp; - tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, holder, e_idx); - DUK_TVAL_SET_TVAL(&tv_tmp, tv); - DUK_TVAL_SET_UNDEFINED_UNUSED(tv); - DUK_TVAL_DECREF(thr, &tv_tmp); + DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv); } /* Here val would be potentially invalid if we didn't make @@ -65378,7 +74953,7 @@ duk_bool_t duk_js_declvar_activation(duk_hthread *thr, * checks (such as access outside the end of the input), which keeps the * tokenization code small at the cost of performance. * - * Character data in tokens (such as identifier names and string literals) + * Character data in tokens, such as identifier names and string literals, * is encoded into CESU-8 format on-the-fly while parsing the token in * question. The string data is made reachable to garbage collection by * placing the token-related values in value stack entries allocated for @@ -65404,12 +74979,7 @@ duk_bool_t duk_js_declvar_activation(duk_hthread *thr, * * Future work: * - * * Make the input window a circular array to avoid copying. This would - * not necessarily complicate the tokenizer much, although it would make - * the window fetches more expensive (one AND). - * - * * Make line number tracking optional, as it consumes space. Also, is - * tracking end line really useful for tokens? + * * Make line number tracking optional, as it consumes space. * * * Add a feature flag for disabling UTF-8 decoding of input, as most * source code is ASCII. Because of Unicode escapes written in ASCII, @@ -65434,7 +75004,8 @@ duk_bool_t duk_js_declvar_activation(duk_hthread *thr, * not after tokens have been formed (as is done now). However, the fix * is not trivial because two characters are decoded from one codepoint. * - * * Optimize for speed as well as size. Large if-else ladders are slow. + * * Optimize for speed as well as size. Large if-else ladders are (at + * least potentially) slow. */ /* include removed: duk_internal.h */ @@ -65446,11 +75017,6 @@ duk_bool_t duk_js_declvar_activation(duk_hthread *thr, #define DUK__MAX_RE_DECESC_DIGITS 9 #define DUK__MAX_RE_QUANT_DIGITS 9 /* Does not allow e.g. 2**31-1, but one more would allow overflows of u32. */ -#define DUK__LOOKUP(lex_ctx,index) ((lex_ctx)->window[(index)]) -#define DUK__ADVANCE(lex_ctx,count) duk__advance_chars((lex_ctx), (count)) -#define DUK__INITBUFFER(lex_ctx) duk__initbuffer((lex_ctx)) -#define DUK__APPENDBUFFER(lex_ctx,x) duk__appendbuffer((lex_ctx), (duk_codepoint_t) (x)) - /* whether to use macros or helper function depends on call count */ #define DUK__ISDIGIT(x) ((x) >= DUK_ASC_0 && (x) <= DUK_ASC_9) #define DUK__ISHEXDIGIT(x) duk__is_hex_digit((x)) @@ -65458,6 +75024,13 @@ duk_bool_t duk_js_declvar_activation(duk_hthread *thr, #define DUK__ISDIGIT03(x) ((x) >= DUK_ASC_0 && (x) <= DUK_ASC_3) #define DUK__ISDIGIT47(x) ((x) >= DUK_ASC_4 && (x) <= DUK_ASC_7) +/* lexer character window helpers */ +#define DUK__LOOKUP(lex_ctx,index) ((lex_ctx)->window[(index)].codepoint) +#define DUK__ADVANCECHARS(lex_ctx,count) duk__advance_bytes((lex_ctx), (count) * sizeof(duk_lexer_codepoint)) +#define DUK__ADVANCEBYTES(lex_ctx,count) duk__advance_bytes((lex_ctx), (count)) +#define DUK__INITBUFFER(lex_ctx) duk__initbuffer((lex_ctx)) +#define DUK__APPENDBUFFER(lex_ctx,x) duk__appendbuffer((lex_ctx), (duk_codepoint_t) (x)) + /* lookup shorthands (note: assume context variable is named 'lex_ctx') */ #define DUK__L0() DUK__LOOKUP(lex_ctx, 0) #define DUK__L1() DUK__LOOKUP(lex_ctx, 1) @@ -65467,10 +75040,23 @@ duk_bool_t duk_js_declvar_activation(duk_hthread *thr, #define DUK__L5() DUK__LOOKUP(lex_ctx, 5) /* packed advance/token number macro used by multiple functions */ -#define DUK__ADVTOK(adv,tok) (((adv) << 8) + (tok)) +#define DUK__ADVTOK(advbytes,tok) ((((advbytes) * sizeof(duk_lexer_codepoint)) << 8) + (tok)) /* - * Read a character from the window leading edge and update the line counter. + * Advance lookup window by N characters, filling in new characters as + * necessary. After returning caller is guaranteed a character window of + * at least DUK_LEXER_WINDOW_SIZE characters. + * + * The main function duk__advance_bytes() is called at least once per every + * token so it has a major lexer/compiler performance impact. There are two + * variants for the main duk__advance_bytes() algorithm: a sliding window + * approach which is slightly faster at the cost of larger code footprint, + * and a simple copying one. + * + * Decoding directly from the source string would be another lexing option. + * But the lookup window based approach has the advantage of hiding the + * source string and its encoding effectively which gives more flexibility + * going forward to e.g. support chunked streaming of source from flash. * * Decodes UTF-8/CESU-8 leniently with support for code points from U+0000 to * U+10FFFF, causing an error if the input is unparseable. Leniency means: @@ -65520,16 +75106,192 @@ duk_bool_t duk_js_declvar_activation(duk_hthread *thr, * * * Is checking against maximum 0x10ffff really useful? 4-byte encoding * imposes a certain limit anyway. + * + * * Support chunked streaming of source code. Can be implemented either + * by streaming chunks of bytes or chunks of codepoints. */ +#if defined(DUK_USE_LEXER_SLIDING_WINDOW) +DUK_LOCAL void duk__fill_lexer_buffer(duk_lexer_ctx *lex_ctx, duk_small_uint_t start_offset_bytes) { + duk_lexer_codepoint *cp, *cp_end; + duk_ucodepoint_t x; + duk_small_uint_t contlen; + const duk_uint8_t *p, *p_end; +#ifdef DUK_USE_STRICT_UTF8_SOURCE + duk_ucodepoint_t mincp; +#endif + duk_int_t input_line; + + /* Use temporaries and update lex_ctx only when finished. */ + input_line = lex_ctx->input_line; + p = lex_ctx->input + lex_ctx->input_offset; + p_end = lex_ctx->input + lex_ctx->input_length; + + cp = (duk_lexer_codepoint *) (void *) ((duk_uint8_t *) lex_ctx->buffer + start_offset_bytes); + cp_end = lex_ctx->buffer + DUK_LEXER_BUFFER_SIZE; + + for (; cp != cp_end; cp++) { + cp->offset = (duk_size_t) (p - lex_ctx->input); + cp->line = input_line; + + /* XXX: potential issue with signed pointers, p_end < p. */ + if (DUK_UNLIKELY(p >= p_end)) { + /* If input_offset were assigned a negative value, it would + * result in a large positive value. Most likely it would be + * larger than input_length and be caught here. In any case + * no memory unsafe behavior would happen. + */ + cp->codepoint = -1; + continue; + } + + x = (duk_ucodepoint_t) (*p++); + + /* Fast path. */ + + if (DUK_LIKELY(x < 0x80UL)) { + DUK_ASSERT(x != 0x2028UL && x != 0x2029UL); /* not LS/PS */ + if (DUK_UNLIKELY(x <= 0x000dUL)) { + if ((x == 0x000aUL) || + ((x == 0x000dUL) && (p >= p_end || *p != 0x000aUL))) { + /* lookup for 0x000a above assumes shortest encoding now */ + + /* E5 Section 7.3, treat the following as newlines: + * LF + * CR [not followed by LF] + * LS + * PS + * + * For CR LF, CR is ignored if it is followed by LF, and the LF will bump + * the line number. + */ + input_line++; + } + } + + cp->codepoint = (duk_codepoint_t) x; + continue; + } + + /* Slow path. */ + + if (x < 0xc0UL) { + /* 10xx xxxx -> invalid */ + goto error_encoding; + } else if (x < 0xe0UL) { + /* 110x xxxx 10xx xxxx */ + contlen = 1; +#ifdef DUK_USE_STRICT_UTF8_SOURCE + mincp = 0x80UL; +#endif + x = x & 0x1fUL; + } else if (x < 0xf0UL) { + /* 1110 xxxx 10xx xxxx 10xx xxxx */ + contlen = 2; +#ifdef DUK_USE_STRICT_UTF8_SOURCE + mincp = 0x800UL; +#endif + x = x & 0x0fUL; + } else if (x < 0xf8UL) { + /* 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx */ + contlen = 3; +#ifdef DUK_USE_STRICT_UTF8_SOURCE + mincp = 0x10000UL; +#endif + x = x & 0x07UL; + } else { + /* no point in supporting encodings of 5 or more bytes */ + goto error_encoding; + } + + DUK_ASSERT(p_end >= p); + if ((duk_size_t) contlen > (duk_size_t) (p_end - p)) { + goto error_clipped; + } + + while (contlen > 0) { + duk_small_uint_t y; + y = *p++; + if ((y & 0xc0U) != 0x80U) { + /* check that byte has the form 10xx xxxx */ + goto error_encoding; + } + x = x << 6; + x += y & 0x3fUL; + contlen--; + } + + /* check final character validity */ + + if (x > 0x10ffffUL) { + goto error_encoding; + } +#ifdef DUK_USE_STRICT_UTF8_SOURCE + if (x < mincp || (x >= 0xd800UL && x <= 0xdfffUL) || x == 0xfffeUL) { + goto error_encoding; + } +#endif + + DUK_ASSERT(x != 0x000aUL && x != 0x000dUL); + if ((x == 0x2028UL) || (x == 0x2029UL)) { + input_line++; + } + + cp->codepoint = (duk_codepoint_t) x; + } + + lex_ctx->input_offset = (duk_size_t) (p - lex_ctx->input); + lex_ctx->input_line = input_line; + return; + + error_clipped: /* clipped codepoint */ + error_encoding: /* invalid codepoint encoding or codepoint */ + lex_ctx->input_offset = (duk_size_t) (p - lex_ctx->input); + lex_ctx->input_line = input_line; + + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "utf8 decode failed"); +} + +DUK_LOCAL void duk__advance_bytes(duk_lexer_ctx *lex_ctx, duk_small_uint_t count_bytes) { + duk_small_uint_t used_bytes, avail_bytes; + + DUK_ASSERT_DISABLE(count_bytes >= 0); /* unsigned */ + DUK_ASSERT(count_bytes <= (duk_small_uint_t) (DUK_LEXER_WINDOW_SIZE * sizeof(duk_lexer_codepoint))); + DUK_ASSERT(lex_ctx->window >= lex_ctx->buffer); + DUK_ASSERT(lex_ctx->window < lex_ctx->buffer + DUK_LEXER_BUFFER_SIZE); + DUK_ASSERT((duk_uint8_t *) lex_ctx->window + count_bytes <= (duk_uint8_t *) lex_ctx->buffer + DUK_LEXER_BUFFER_SIZE * sizeof(duk_lexer_codepoint)); + + /* Zero 'count' is also allowed to make call sites easier. + * Arithmetic in bytes generates better code in GCC. + */ + + lex_ctx->window = (duk_lexer_codepoint *) (void *) ((duk_uint8_t *) lex_ctx->window + count_bytes); /* avoid multiply */ + used_bytes = (duk_small_uint_t) ((duk_uint8_t *) lex_ctx->window - (duk_uint8_t *) lex_ctx->buffer); + avail_bytes = DUK_LEXER_BUFFER_SIZE * sizeof(duk_lexer_codepoint) - used_bytes; + if (avail_bytes < (duk_small_uint_t) (DUK_LEXER_WINDOW_SIZE * sizeof(duk_lexer_codepoint))) { + /* Not enough data to provide a full window, so "scroll" window to + * start of buffer and fill up the rest. + */ + DUK_MEMMOVE((void *) lex_ctx->buffer, + (const void *) lex_ctx->window, + (size_t) avail_bytes); + lex_ctx->window = lex_ctx->buffer; + duk__fill_lexer_buffer(lex_ctx, avail_bytes); + } +} + +DUK_LOCAL void duk__init_lexer_window(duk_lexer_ctx *lex_ctx) { + lex_ctx->window = lex_ctx->buffer; + duk__fill_lexer_buffer(lex_ctx, 0); +} +#else /* DUK_USE_LEXER_SLIDING_WINDOW */ DUK_LOCAL duk_codepoint_t duk__read_char(duk_lexer_ctx *lex_ctx) { - /* attempting to reduce size of 'len' and/or 'i' resulted in larger code */ - duk_codepoint_t x; - duk_small_int_t len; - duk_small_int_t i; + duk_ucodepoint_t x; + duk_small_uint_t len; + duk_small_uint_t i; const duk_uint8_t *p; #ifdef DUK_USE_STRICT_UTF8_SOURCE - duk_codepoint_t mincp; + duk_ucodepoint_t mincp; #endif duk_size_t input_offset; @@ -65544,36 +75306,63 @@ DUK_LOCAL duk_codepoint_t duk__read_char(duk_lexer_ctx *lex_ctx) { } p = lex_ctx->input + input_offset; - x = (int) *p++; + x = (duk_ucodepoint_t) (*p); - if (x < 0x80L) { + if (DUK_LIKELY(x < 0x80UL)) { /* 0xxx xxxx -> fast path */ - len = 1; - goto fastpath; - } else if (x < 0xc0L) { + + /* input offset tracking */ + lex_ctx->input_offset++; + + DUK_ASSERT(x != 0x2028UL && x != 0x2029UL); /* not LS/PS */ + if (DUK_UNLIKELY(x <= 0x000dUL)) { + if ((x == 0x000aUL) || + ((x == 0x000dUL) && (lex_ctx->input_offset >= lex_ctx->input_length || + lex_ctx->input[lex_ctx->input_offset] != 0x000aUL))) { + /* lookup for 0x000a above assumes shortest encoding now */ + + /* E5 Section 7.3, treat the following as newlines: + * LF + * CR [not followed by LF] + * LS + * PS + * + * For CR LF, CR is ignored if it is followed by LF, and the LF will bump + * the line number. + */ + lex_ctx->input_line++; + } + } + + return (duk_codepoint_t) x; + } + + /* Slow path. */ + + if (x < 0xc0UL) { /* 10xx xxxx -> invalid */ goto error_encoding; - } else if (x < 0xe0L) { + } else if (x < 0xe0UL) { /* 110x xxxx 10xx xxxx */ len = 2; #ifdef DUK_USE_STRICT_UTF8_SOURCE - mincp = 0x80L; + mincp = 0x80UL; #endif - x = x & 0x1fL; - } else if (x < 0xf0L) { + x = x & 0x1fUL; + } else if (x < 0xf0UL) { /* 1110 xxxx 10xx xxxx 10xx xxxx */ len = 3; #ifdef DUK_USE_STRICT_UTF8_SOURCE - mincp = 0x800L; + mincp = 0x800UL; #endif - x = x & 0x0fL; - } else if (x < 0xf8L) { + x = x & 0x0fUL; + } else if (x < 0xf8UL) { /* 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx */ len = 4; #ifdef DUK_USE_STRICT_UTF8_SOURCE - mincp = 0x10000L; + mincp = 0x10000UL; #endif - x = x & 0x07; + x = x & 0x07UL; } else { /* no point in supporting encodings of 5 or more bytes */ goto error_encoding; @@ -65584,121 +75373,89 @@ DUK_LOCAL duk_codepoint_t duk__read_char(duk_lexer_ctx *lex_ctx) { goto error_clipped; } + p++; for (i = 1; i < len; i++) { - duk_small_int_t y = *p++; - if ((y & 0xc0) != 0x80) { + duk_small_uint_t y; + y = *p++; + if ((y & 0xc0U) != 0x80U) { /* check that byte has the form 10xx xxxx */ goto error_encoding; } x = x << 6; - x += y & 0x3f; + x += y & 0x3fUL; } /* check final character validity */ - if (x > 0x10ffffL) { + if (x > 0x10ffffUL) { goto error_encoding; } #ifdef DUK_USE_STRICT_UTF8_SOURCE - if (x < mincp || (x >= 0xd800L && x <= 0xdfffL) || x == 0xfffeL) { + if (x < mincp || (x >= 0xd800UL && x <= 0xdfffUL) || x == 0xfffeUL) { goto error_encoding; } #endif - /* fall through */ - - fastpath: /* input offset tracking */ lex_ctx->input_offset += len; /* line tracking */ - if ((x == 0x000aL) || - ((x == 0x000dL) && (lex_ctx->input_offset >= lex_ctx->input_length || - lex_ctx->input[lex_ctx->input_offset] != 0x000aL)) || - (x == 0x2028L) || - (x == 0x2029L)) { - /* lookup for 0x000a above assumes shortest encoding now */ - - /* E5 Section 7.3, treat the following as newlines: - * LF - * CR [not followed by LF] - * LS - * PS - * - * For CR LF, CR is ignored if it is followed by LF, and the LF will bump - * the line number. - */ + DUK_ASSERT(x != 0x000aUL && x != 0x000dUL); + if ((x == 0x2028UL) || (x == 0x2029UL)) { lex_ctx->input_line++; } - return x; + return (duk_codepoint_t) x; error_clipped: /* clipped codepoint */ error_encoding: /* invalid codepoint encoding or codepoint */ - DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "char decode failed"); + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "utf8 decode failed"); return 0; } -/* - * Advance lookup window by N characters. Also used to fill the window - * after position is changed (call with count == DUK_LEXER_WINDOW_SIZE). - * - * XXX: A lot of copying now, perhaps change to circular array or at - * least use memcpy(). For memcpy(), putting all elements of the - * window (code point, offset, line) into a struct would allow one - * memcpy() to slide the window, instead of three separate copys. - */ +DUK_LOCAL void duk__advance_bytes(duk_lexer_ctx *lex_ctx, duk_small_uint_t count_bytes) { + duk_small_uint_t keep_bytes; + duk_lexer_codepoint *cp, *cp_end; -DUK_LOCAL void duk__advance_chars(duk_lexer_ctx *lex_ctx, duk_small_int_t count) { - duk_small_int_t i, n; + DUK_ASSERT_DISABLE(count_bytes >= 0); /* unsigned */ + DUK_ASSERT(count_bytes <= (duk_small_uint_t) (DUK_LEXER_WINDOW_SIZE * sizeof(duk_lexer_codepoint))); - DUK_ASSERT(count >= 0 && count <= DUK_LEXER_WINDOW_SIZE); + /* Zero 'count' is also allowed to make call sites easier. */ - /* Without this check, gcc -O4 will complain the following for the - * first for-loop below: - * - * duk_lexer.c:301:19: error: array subscript is above array bounds [-Werror=array-bounds] - * - * Check for range explicitly; this also protects against legitimate - * internal errors and avoids memory unsafe behavior in such cases. - */ - if (DUK_UNLIKELY(!(count >= 0 && count <= DUK_LEXER_WINDOW_SIZE))) { - DUK_D(DUK_DPRINT("invalid count: %ld, should not happen", (long) count)); - DUK_ERROR(lex_ctx->thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR); - return; /* never here */ - } + keep_bytes = DUK_LEXER_WINDOW_SIZE * sizeof(duk_lexer_codepoint) - count_bytes; + DUK_MEMMOVE((void *) lex_ctx->window, + (const void *) ((duk_uint8_t *) lex_ctx->window + count_bytes), + (size_t) keep_bytes); - if (count == 0) { - /* allowing zero count makes some special caller flows easier */ - return; - } - - n = DUK_LEXER_WINDOW_SIZE - count; - for (i = 0; i < n; i++) { - lex_ctx->offsets[i] = lex_ctx->offsets[i + count]; - lex_ctx->lines[i] = lex_ctx->lines[i + count]; - lex_ctx->window[i] = lex_ctx->window[i + count]; - } - - for (; i < DUK_LEXER_WINDOW_SIZE; i++) { - lex_ctx->offsets[i] = lex_ctx->input_offset; - lex_ctx->lines[i] = lex_ctx->input_line; - lex_ctx->window[i] = duk__read_char(lex_ctx); + cp = (duk_lexer_codepoint *) ((duk_uint8_t *) lex_ctx->window + keep_bytes); + cp_end = lex_ctx->window + DUK_LEXER_WINDOW_SIZE; + for (; cp != cp_end; cp++) { + cp->offset = lex_ctx->input_offset; + cp->line = lex_ctx->input_line; + cp->codepoint = duk__read_char(lex_ctx); } } +DUK_LOCAL void duk__init_lexer_window(duk_lexer_ctx *lex_ctx) { + /* Call with count == DUK_LEXER_WINDOW_SIZE to fill buffer initially. */ + duk__advance_bytes(lex_ctx, DUK_LEXER_WINDOW_SIZE * sizeof(duk_lexer_codepoint)); /* fill window */ +} +#endif /* DUK_USE_LEXER_SLIDING_WINDOW */ + /* * (Re)initialize the temporary byte buffer. May be called extra times * with little impact. */ DUK_LOCAL void duk__initbuffer(duk_lexer_ctx *lex_ctx) { - if (DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(lex_ctx->buf) < DUK_LEXER_TEMP_BUF_LIMIT) { - /* Resize (zero) without realloc. */ - DUK_HBUFFER_DYNAMIC_SET_SIZE(lex_ctx->buf, 0); + /* Reuse buffer as is unless buffer has grown large. */ + if (DUK_HBUFFER_DYNAMIC_GET_SIZE(lex_ctx->buf) < DUK_LEXER_TEMP_BUF_LIMIT) { + /* Keep current size */ } else { - duk_hbuffer_resize(lex_ctx->thr, lex_ctx->buf, 0, DUK_LEXER_TEMP_BUF_LIMIT); + duk_hbuffer_resize(lex_ctx->thr, lex_ctx->buf, DUK_LEXER_TEMP_BUF_LIMIT); } + + DUK_BW_INIT_WITHBUF(lex_ctx->thr, &lex_ctx->bw, lex_ctx->buf); } /* @@ -65720,7 +75477,7 @@ DUK_LOCAL void duk__appendbuffer(duk_lexer_ctx *lex_ctx, duk_codepoint_t x) { DUK_ASSERT(x >= 0 && x <= 0x10ffff); - duk_hbuffer_append_cesu8(lex_ctx->thr, lex_ctx->buf, (duk_ucodepoint_t) x); + DUK_BW_WRITE_ENSURE_CESU8(lex_ctx->thr, &lex_ctx->bw, (duk_ucodepoint_t) x); } /* @@ -65733,8 +75490,7 @@ DUK_LOCAL void duk__internbuffer(duk_lexer_ctx *lex_ctx, duk_idx_t valstack_idx) DUK_ASSERT(valstack_idx == lex_ctx->slot1_idx || valstack_idx == lex_ctx->slot2_idx); - duk_dup(ctx, lex_ctx->buf_idx); - duk_to_string(ctx, -1); + DUK_BW_PUSH_AS_STRING(lex_ctx->thr, &lex_ctx->bw); duk_replace(ctx, valstack_idx); } @@ -65747,6 +75503,9 @@ DUK_INTERNAL void duk_lexer_initctx(duk_lexer_ctx *lex_ctx) { DUK_MEMZERO(lex_ctx, sizeof(*lex_ctx)); #ifdef DUK_USE_EXPLICIT_NULL_INIT +#if defined(DUK_USE_LEXER_SLIDING_WINDOW) + lex_ctx->window = NULL; +#endif lex_ctx->thr = NULL; lex_ctx->input = NULL; lex_ctx->buf = NULL; @@ -65764,7 +75523,7 @@ DUK_INTERNAL void duk_lexer_setpoint(duk_lexer_ctx *lex_ctx, duk_lexer_point *pt DUK_ASSERT(pt->line >= 1); lex_ctx->input_offset = pt->offset; lex_ctx->input_line = pt->line; - duk__advance_chars(lex_ctx, DUK_LEXER_WINDOW_SIZE); /* fill window */ + duk__init_lexer_window(lex_ctx); } /* @@ -65800,43 +75559,33 @@ DUK_LOCAL duk_bool_t duk__is_hex_digit(duk_codepoint_t x) { DUK_LOCAL duk_codepoint_t duk__decode_hexesc_from_window(duk_lexer_ctx *lex_ctx, duk_small_int_t lookup_offset) { /* validation performed by duk__hexval */ - return (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset]) << 4) | - (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 1])); + return (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset].codepoint) << 4) | + (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 1].codepoint)); } DUK_LOCAL duk_codepoint_t duk__decode_uniesc_from_window(duk_lexer_ctx *lex_ctx, duk_small_int_t lookup_offset) { /* validation performed by duk__hexval */ - return (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset]) << 12) | - (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 1]) << 8) | - (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 2]) << 4) | - (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 3])); -} - -/* - * Eat input characters until first character of window is not - * a white space (may be -1 if EOF encountered). - */ -DUK_LOCAL void duk__eat_whitespace(duk_lexer_ctx *lex_ctx) { - /* guaranteed to finish, as EOF (-1) is not a whitespace */ - while (duk_unicode_is_whitespace(DUK__LOOKUP(lex_ctx, 0))) { - DUK__ADVANCE(lex_ctx, 1); - } + return (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset].codepoint) << 12) | + (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 1].codepoint) << 8) | + (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 2].codepoint) << 4) | + (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 3].codepoint)); } /* * Parse Ecmascript source InputElementDiv or InputElementRegExp - * (E5 Section 7). + * (E5 Section 7), skipping whitespace, comments, and line terminators. * * Possible results are: * (1) a token - * (2) a line terminator - * (3) a comment + * (2) a line terminator (skipped) + * (3) a comment (skipped) * (4) EOF * * White space is automatically skipped from the current position (but * not after the input element). If input has already ended, returns * DUK_TOK_EOF indefinitely. If a parse error occurs, uses an DUK_ERROR() * macro call (and hence a longjmp through current heap longjmp context). + * Comments and line terminator tokens are automatically skipped. * * The input element being matched is determined by regexp_mode; if set, * parses a InputElementRegExp, otherwise a InputElementDiv. The @@ -65881,43 +75630,46 @@ DUK_LOCAL void duk__eat_whitespace(duk_lexer_ctx *lex_ctx) { * number of escapes. Directive detection can then check that the * number of escapes is zero. * - * * Comments are expressed as DUK_TOK_COMMENT tokens, with the type - * (single- or multi-line) and contents of the comments lost. - * Furthermore, multi-line comments with one or more internal - * LineTerminator are treated as DUK_TOK_LINETERM to comply with - * automatic semicolon insertion and to avoid complicating the - * tokenization process. See E5 Section 7.4. + * * Multi-line comments with one or more internal LineTerminator are + * treated like a line terminator to comply with automatic semicolon + * insertion. */ -DUK_LOCAL -void duk__parse_input_element_raw(duk_lexer_ctx *lex_ctx, - duk_token *out_token, - duk_bool_t strict_mode, - duk_bool_t regexp_mode) { - duk_codepoint_t x, y; /* temporaries, must be signed and 32-bit to hold Unicode code points */ +DUK_INTERNAL +void duk_lexer_parse_js_input_element(duk_lexer_ctx *lex_ctx, + duk_token *out_token, + duk_bool_t strict_mode, + duk_bool_t regexp_mode) { + duk_codepoint_t x; /* temporary, must be signed and 32-bit to hold Unicode code points */ duk_small_uint_t advtok = 0; /* (advance << 8) + token_type, updated at function end, * init is unnecessary but suppresses "may be used uninitialized" warnings. */ + duk_bool_t got_lineterm = 0; /* got lineterm preceding non-whitespace, non-lineterm token */ if (++lex_ctx->token_count >= lex_ctx->token_limit) { DUK_ERROR(lex_ctx->thr, DUK_ERR_RANGE_ERROR, "token limit"); return; /* unreachable */ } - duk__eat_whitespace(lex_ctx); - out_token->t = DUK_TOK_EOF; out_token->t_nores = -1; /* marker: copy t if not changed */ +#if 0 /* not necessary to init, disabled for faster parsing */ out_token->num = DUK_DOUBLE_NAN; out_token->str1 = NULL; out_token->str2 = NULL; +#endif out_token->num_escapes = 0; - out_token->start_line = lex_ctx->lines[0]; - out_token->start_offset = lex_ctx->offsets[0]; /* out_token->lineterm set by caller */ + /* This would be nice, but parsing is faster without resetting the + * value slots. The only side effect is that references to temporary + * string values may linger until lexing is finished; they're then + * freed normally. + */ +#if 0 duk_to_undefined((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx); duk_to_undefined((duk_context *) lex_ctx->thr, lex_ctx->slot2_idx); +#endif /* 'advtok' indicates how much to advance and which token id to assign * at the end. This shared functionality minimizes code size. All @@ -65939,57 +75691,66 @@ void duk__parse_input_element_raw(duk_lexer_ctx *lex_ctx, * The order does not matter as long as the longest match is * always correctly identified. There are order dependencies * in the clauses, so it's not trivial to convert to a switch. - * - * XXX: This is quite inefficient. Maybe change to a switch - * statement which handles all single character cases and then - * use a followup if-else chain? Switch matches need to use - * goto to bypass the if-else chain. */ - x = DUK__L0(); - y = DUK__L1(); + restart_lineupdate: + out_token->start_line = lex_ctx->window[0].line; - if (x == '/') { - if (y == '/') { + restart: + out_token->start_offset = lex_ctx->window[0].offset; + + x = DUK__L0(); + + switch (x) { + case DUK_ASC_SPACE: + case DUK_ASC_HT: /* fast paths for space and tab */ + DUK__ADVANCECHARS(lex_ctx, 1); + goto restart; + case DUK_ASC_LF: /* LF line terminator; CR LF and Unicode lineterms are handled in slow path */ + DUK__ADVANCECHARS(lex_ctx, 1); + got_lineterm = 1; + goto restart_lineupdate; + case DUK_ASC_SLASH: /* '/' */ + if (DUK__L1() == '/') { /* * E5 Section 7.4, allow SourceCharacter (which is any 16-bit * code point). */ - /* DUK__ADVANCE(lex_ctx, 2) would be correct here, but it unnecessary */ + /* DUK__ADVANCECHARS(lex_ctx, 2) would be correct here, but it unnecessary */ for (;;) { x = DUK__L0(); if (x < 0 || duk_unicode_is_line_terminator(x)) { break; } - DUK__ADVANCE(lex_ctx, 1); + DUK__ADVANCECHARS(lex_ctx, 1); } - advtok = DUK__ADVTOK(0, DUK_TOK_COMMENT); - } else if (y == '*') { + goto restart; /* line terminator will be handled on next round */ + } else if (DUK__L1() == '*') { /* * E5 Section 7.4. If the multi-line comment contains a newline, - * it is treated like a single DUK_TOK_LINETERM to facilitate - * automatic semicolon insertion. + * it is treated like a single line terminator for automatic + * semicolon insertion. */ duk_bool_t last_asterisk = 0; - advtok = DUK__ADVTOK(0, DUK_TOK_COMMENT); - DUK__ADVANCE(lex_ctx, 2); + DUK__ADVANCECHARS(lex_ctx, 2); for (;;) { x = DUK__L0(); if (x < 0) { DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "eof while parsing multiline comment"); } - DUK__ADVANCE(lex_ctx, 1); + DUK__ADVANCECHARS(lex_ctx, 1); if (last_asterisk && x == '/') { break; } if (duk_unicode_is_line_terminator(x)) { - advtok = DUK__ADVTOK(0, DUK_TOK_LINETERM); + got_lineterm = 1; } last_asterisk = (x == '*'); } + goto restart_lineupdate; } else if (regexp_mode) { #ifdef DUK_USE_REGEXP_SUPPORT /* @@ -66053,7 +75814,7 @@ void duk__parse_input_element_raw(duk_lexer_ctx *lex_ctx, DUK__INITBUFFER(lex_ctx); for (;;) { - DUK__ADVANCE(lex_ctx, 1); /* skip opening slash on first loop */ + DUK__ADVANCECHARS(lex_ctx, 1); /* skip opening slash on first loop */ x = DUK__L0(); if (x < 0 || duk_unicode_is_line_terminator(x)) { DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, @@ -66062,7 +75823,7 @@ void duk__parse_input_element_raw(duk_lexer_ctx *lex_ctx, x = DUK__L0(); /* re-read to avoid spill / fetch */ if (state == 0) { if (x == '/') { - DUK__ADVANCE(lex_ctx, 1); /* eat closing slash */ + DUK__ADVANCECHARS(lex_ctx, 1); /* eat closing slash */ break; } else if (x == '\\') { state = 1; @@ -66095,7 +75856,7 @@ void duk__parse_input_element_raw(duk_lexer_ctx *lex_ctx, } x = DUK__L0(); /* re-read to avoid spill / fetch */ DUK__APPENDBUFFER(lex_ctx, x); - DUK__ADVANCE(lex_ctx, 1); + DUK__ADVANCECHARS(lex_ctx, 1); } duk__internbuffer(lex_ctx, lex_ctx->slot2_idx); out_token->str2 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot2_idx); @@ -66108,139 +75869,325 @@ void duk__parse_input_element_raw(duk_lexer_ctx *lex_ctx, #else DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "regexp support disabled"); #endif - } else if (y == '=') { + } else if (DUK__L1() == '=') { /* "/=" and not in regexp mode */ advtok = DUK__ADVTOK(2, DUK_TOK_DIV_EQ); } else { /* "/" and not in regexp mode */ advtok = DUK__ADVTOK(1, DUK_TOK_DIV); } - } else if (x == '{') { + break; + case DUK_ASC_LCURLY: /* '{' */ advtok = DUK__ADVTOK(1, DUK_TOK_LCURLY); - } else if (x == '}') { + break; + case DUK_ASC_RCURLY: /* '}' */ advtok = DUK__ADVTOK(1, DUK_TOK_RCURLY); - } else if (x == '(') { + break; + case DUK_ASC_LPAREN: /* '(' */ advtok = DUK__ADVTOK(1, DUK_TOK_LPAREN); - } else if (x == ')') { + break; + case DUK_ASC_RPAREN: /* ')' */ advtok = DUK__ADVTOK(1, DUK_TOK_RPAREN); - } else if (x == '[') { + break; + case DUK_ASC_LBRACKET: /* '[' */ advtok = DUK__ADVTOK(1, DUK_TOK_LBRACKET); - } else if (x == ']') { + break; + case DUK_ASC_RBRACKET: /* ']' */ advtok = DUK__ADVTOK(1, DUK_TOK_RBRACKET); - } else if (x == '.' && !DUK__ISDIGIT(y)) { - /* Note: period followed by a digit can only start DecimalLiteral (captured below) */ + break; + case DUK_ASC_PERIOD: /* '.' */ + if (DUK__ISDIGIT(DUK__L1())) { + /* Period followed by a digit can only start DecimalLiteral + * (handled in slow path). We could jump straight into the + * DecimalLiteral handling but should avoid goto to inside + * a block. + */ + goto slow_path; + } advtok = DUK__ADVTOK(1, DUK_TOK_PERIOD); - } else if (x == ';') { + break; + case DUK_ASC_SEMICOLON: /* ';' */ advtok = DUK__ADVTOK(1, DUK_TOK_SEMICOLON); - } else if (x == ',') { + break; + case DUK_ASC_COMMA: /* ',' */ advtok = DUK__ADVTOK(1, DUK_TOK_COMMA); - } else if (x == '<') { - if (y == '<' && DUK__L2() == '=') { + break; + case DUK_ASC_LANGLE: /* '<' */ + if (DUK__L1() == '<' && DUK__L2() == '=') { advtok = DUK__ADVTOK(3, DUK_TOK_ALSHIFT_EQ); - } else if (y == '=') { + } else if (DUK__L1() == '=') { advtok = DUK__ADVTOK(2, DUK_TOK_LE); - } else if (y == '<') { + } else if (DUK__L1() == '<') { advtok = DUK__ADVTOK(2, DUK_TOK_ALSHIFT); } else { advtok = DUK__ADVTOK(1, DUK_TOK_LT); } - } else if (x == '>') { - if (y == '>' && DUK__L2() == '>' && DUK__L3() == '=') { + break; + case DUK_ASC_RANGLE: /* '>' */ + if (DUK__L1() == '>' && DUK__L2() == '>' && DUK__L3() == '=') { advtok = DUK__ADVTOK(4, DUK_TOK_RSHIFT_EQ); - } else if (y == '>' && DUK__L2() == '>') { + } else if (DUK__L1() == '>' && DUK__L2() == '>') { advtok = DUK__ADVTOK(3, DUK_TOK_RSHIFT); - } else if (y == '>' && DUK__L2() == '=') { + } else if (DUK__L1() == '>' && DUK__L2() == '=') { advtok = DUK__ADVTOK(3, DUK_TOK_ARSHIFT_EQ); - } else if (y == '=') { + } else if (DUK__L1() == '=') { advtok = DUK__ADVTOK(2, DUK_TOK_GE); - } else if (y == '>') { + } else if (DUK__L1() == '>') { advtok = DUK__ADVTOK(2, DUK_TOK_ARSHIFT); } else { advtok = DUK__ADVTOK(1, DUK_TOK_GT); } - } else if (x == '=') { - if (y == '=' && DUK__L2() == '=') { + break; + case DUK_ASC_EQUALS: /* '=' */ + if (DUK__L1() == '=' && DUK__L2() == '=') { advtok = DUK__ADVTOK(3, DUK_TOK_SEQ); - } else if (y == '=') { + } else if (DUK__L1() == '=') { advtok = DUK__ADVTOK(2, DUK_TOK_EQ); } else { advtok = DUK__ADVTOK(1, DUK_TOK_EQUALSIGN); } - } else if (x == '!') { - if (y == '=' && DUK__L2() == '=') { + break; + case DUK_ASC_EXCLAMATION: /* '!' */ + if (DUK__L1() == '=' && DUK__L2() == '=') { advtok = DUK__ADVTOK(3, DUK_TOK_SNEQ); - } else if (y == '=') { + } else if (DUK__L1() == '=') { advtok = DUK__ADVTOK(2, DUK_TOK_NEQ); } else { advtok = DUK__ADVTOK(1, DUK_TOK_LNOT); } - } else if (x == '+') { - if (y == '+') { + break; + case DUK_ASC_PLUS: /* '+' */ + if (DUK__L1() == '+') { advtok = DUK__ADVTOK(2, DUK_TOK_INCREMENT); - } else if (y == '=') { + } else if (DUK__L1() == '=') { advtok = DUK__ADVTOK(2, DUK_TOK_ADD_EQ); } else { advtok = DUK__ADVTOK(1, DUK_TOK_ADD); } - } else if (x == '-') { - if (y == '-') { + break; + case DUK_ASC_MINUS: /* '-' */ + if (DUK__L1() == '-') { advtok = DUK__ADVTOK(2, DUK_TOK_DECREMENT); - } else if (y == '=') { + } else if (DUK__L1() == '=') { advtok = DUK__ADVTOK(2, DUK_TOK_SUB_EQ); } else { advtok = DUK__ADVTOK(1, DUK_TOK_SUB); } - } else if (x == '*') { - if (y == '=') { + break; + case DUK_ASC_STAR: /* '*' */ + if (DUK__L1() == '=') { advtok = DUK__ADVTOK(2, DUK_TOK_MUL_EQ); } else { advtok = DUK__ADVTOK(1, DUK_TOK_MUL); } - } else if (x == '%') { - if (y == '=') { + break; + case DUK_ASC_PERCENT: /* '%' */ + if (DUK__L1() == '=') { advtok = DUK__ADVTOK(2, DUK_TOK_MOD_EQ); } else { advtok = DUK__ADVTOK(1, DUK_TOK_MOD); } - } else if (x == '&') { - if (y == '&') { + break; + case DUK_ASC_AMP: /* '&' */ + if (DUK__L1() == '&') { advtok = DUK__ADVTOK(2, DUK_TOK_LAND); - } else if (y == '=') { + } else if (DUK__L1() == '=') { advtok = DUK__ADVTOK(2, DUK_TOK_BAND_EQ); } else { advtok = DUK__ADVTOK(1, DUK_TOK_BAND); } - } else if (x == '|') { - if (y == '|') { + break; + case DUK_ASC_PIPE: /* '|' */ + if (DUK__L1() == '|') { advtok = DUK__ADVTOK(2, DUK_TOK_LOR); - } else if (y == '=') { + } else if (DUK__L1() == '=') { advtok = DUK__ADVTOK(2, DUK_TOK_BOR_EQ); } else { advtok = DUK__ADVTOK(1, DUK_TOK_BOR); } - } else if (x == '^') { - if (y == '=') { + break; + case DUK_ASC_CARET: /* '^' */ + if (DUK__L1() == '=') { advtok = DUK__ADVTOK(2, DUK_TOK_BXOR_EQ); } else { advtok = DUK__ADVTOK(1, DUK_TOK_BXOR); } - } else if (x == '~') { + break; + case DUK_ASC_TILDE: /* '~' */ advtok = DUK__ADVTOK(1, DUK_TOK_BNOT); - } else if (x == '?') { + break; + case DUK_ASC_QUESTION: /* '?' */ advtok = DUK__ADVTOK(1, DUK_TOK_QUESTION); - } else if (x == ':') { + break; + case DUK_ASC_COLON: /* ':' */ advtok = DUK__ADVTOK(1, DUK_TOK_COLON); - } else if (duk_unicode_is_line_terminator(x)) { - if (x == 0x000d && y == 0x000a) { + break; + case DUK_ASC_DOUBLEQUOTE: /* '"' */ + case DUK_ASC_SINGLEQUOTE: { /* '\'' */ + duk_small_int_t quote = x; /* Note: duk_uint8_t type yields larger code */ + duk_small_int_t adv; + + DUK__INITBUFFER(lex_ctx); + for (;;) { + DUK__ADVANCECHARS(lex_ctx, 1); /* eat opening quote on first loop */ + x = DUK__L0(); + if (x < 0 || duk_unicode_is_line_terminator(x)) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "eof or line terminator while parsing string literal"); + } + if (x == quote) { + DUK__ADVANCECHARS(lex_ctx, 1); /* eat closing quote */ + break; + } + if (x == '\\') { + /* DUK__L0 -> '\' char + * DUK__L1 ... DUK__L5 -> more lookup + */ + + x = DUK__L1(); + + /* How much to advance before next loop; note that next loop + * will advance by 1 anyway, so -1 from the total escape + * length (e.g. len('\uXXXX') - 1 = 6 - 1). As a default, + * 1 is good. + */ + adv = 2 - 1; /* note: long live range */ + + if (x < 0) { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "eof while parsing string literal"); + } + if (duk_unicode_is_line_terminator(x)) { + /* line continuation */ + if (x == 0x000d && DUK__L2() == 0x000a) { + /* CR LF again a special case */ + adv = 3 - 1; + } + } else if (x == '\'') { + DUK__APPENDBUFFER(lex_ctx, 0x0027); + } else if (x == '"') { + DUK__APPENDBUFFER(lex_ctx, 0x0022); + } else if (x == '\\') { + DUK__APPENDBUFFER(lex_ctx, 0x005c); + } else if (x == 'b') { + DUK__APPENDBUFFER(lex_ctx, 0x0008); + } else if (x == 'f') { + DUK__APPENDBUFFER(lex_ctx, 0x000c); + } else if (x == 'n') { + DUK__APPENDBUFFER(lex_ctx, 0x000a); + } else if (x == 'r') { + DUK__APPENDBUFFER(lex_ctx, 0x000d); + } else if (x == 't') { + DUK__APPENDBUFFER(lex_ctx, 0x0009); + } else if (x == 'v') { + DUK__APPENDBUFFER(lex_ctx, 0x000b); + } else if (x == 'x') { + adv = 4 - 1; + DUK__APPENDBUFFER(lex_ctx, duk__decode_hexesc_from_window(lex_ctx, 2)); + } else if (x == 'u') { + adv = 6 - 1; + DUK__APPENDBUFFER(lex_ctx, duk__decode_uniesc_from_window(lex_ctx, 2)); + } else if (DUK__ISDIGIT(x)) { + duk_codepoint_t ch = 0; /* initialized to avoid warnings of unused var */ + + /* + * Octal escape or zero escape: + * \0 (lookahead not DecimalDigit) + * \1 ... \7 (lookahead not DecimalDigit) + * \ZeroToThree OctalDigit (lookahead not DecimalDigit) + * \FourToSeven OctalDigit (no lookahead restrictions) + * \ZeroToThree OctalDigit OctalDigit (no lookahead restrictions) + * + * Zero escape is part of the standard syntax. Octal escapes are + * defined in E5 Section B.1.2, and are only allowed in non-strict mode. + * Any other productions starting with a decimal digit are invalid. + */ + + if (x == '0' && !DUK__ISDIGIT(DUK__L2())) { + /* Zero escape (also allowed in non-strict mode) */ + ch = 0; + /* adv = 2 - 1 default OK */ +#ifdef DUK_USE_OCTAL_SUPPORT + } else if (strict_mode) { + /* No other escape beginning with a digit in strict mode */ + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid escape while parsing string literal"); + } else if (DUK__ISDIGIT03(x) && DUK__ISOCTDIGIT(DUK__L2()) && DUK__ISOCTDIGIT(DUK__L3())) { + /* Three digit octal escape, digits validated. */ + adv = 4 - 1; + ch = (duk__hexval(lex_ctx, x) << 6) + + (duk__hexval(lex_ctx, DUK__L2()) << 3) + + duk__hexval(lex_ctx, DUK__L3()); + } else if (((DUK__ISDIGIT03(x) && !DUK__ISDIGIT(DUK__L3())) || DUK__ISDIGIT47(x)) && + DUK__ISOCTDIGIT(DUK__L2())) { + /* Two digit octal escape, digits validated. + * + * The if-condition is a bit tricky. We could catch e.g. + * '\039' in the three-digit escape and fail it there (by + * validating the digits), but we want to avoid extra + * additional validation code. + */ + adv = 3 - 1; + ch = (duk__hexval(lex_ctx, x) << 3) + + duk__hexval(lex_ctx, DUK__L2()); + } else if (DUK__ISDIGIT(x) && !DUK__ISDIGIT(DUK__L2())) { + /* One digit octal escape, digit validated. */ + /* adv = 2 default OK */ + ch = duk__hexval(lex_ctx, x); +#else + /* fall through to error */ +#endif + } else { + DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, + "invalid escape while parsing string literal"); + } + + DUK__APPENDBUFFER(lex_ctx, ch); + } else { + /* escaped NonEscapeCharacter */ + DUK__APPENDBUFFER(lex_ctx, x); + } + DUK__ADVANCECHARS(lex_ctx, adv); + + /* Track number of escapes; count not really needed but directive + * prologues need to detect whether there were any escapes or line + * continuations or not. + */ + out_token->num_escapes++; + } else { + /* part of string */ + DUK__APPENDBUFFER(lex_ctx, x); + } + } + + duk__internbuffer(lex_ctx, lex_ctx->slot1_idx); + out_token->str1 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx); + + DUK__INITBUFFER(lex_ctx); /* free some memory */ + + advtok = DUK__ADVTOK(0, DUK_TOK_STRING); + break; + } + default: + goto slow_path; + } /* switch */ + + goto skip_slow_path; + + slow_path: + if (duk_unicode_is_line_terminator(x)) { + if (x == 0x000d && DUK__L1() == 0x000a) { /* * E5 Section 7.3: CR LF is detected as a single line terminator for * line numbers. Here we also detect it as a single line terminator * token. */ - advtok = DUK__ADVTOK(2, DUK_TOK_LINETERM); + DUK__ADVANCECHARS(lex_ctx, 2); } else { - advtok = DUK__ADVTOK(1, DUK_TOK_LINETERM); + DUK__ADVANCECHARS(lex_ctx, 1); } + got_lineterm = 1; + goto restart_lineupdate; } else if (duk_unicode_is_identifier_start(x) || x == '\\') { /* * Parse an identifier and then check whether it is: @@ -66297,7 +76244,7 @@ void duk__parse_input_element_raw(duk_lexer_ctx *lex_ctx, "invalid unicode escaped character while parsing identifier"); } DUK__APPENDBUFFER(lex_ctx, ch); - DUK__ADVANCE(lex_ctx, 6); + DUK__ADVANCECHARS(lex_ctx, 6); /* Track number of escapes: necessary for proper keyword * detection. @@ -66313,7 +76260,7 @@ void duk__parse_input_element_raw(duk_lexer_ctx *lex_ctx, break; } DUK__APPENDBUFFER(lex_ctx, DUK__L0()); - DUK__ADVANCE(lex_ctx, 1); + DUK__ADVANCECHARS(lex_ctx, 1); } first = 0; } @@ -66392,12 +76339,14 @@ void duk__parse_input_element_raw(duk_lexer_ctx *lex_ctx, * 3=after exp and exp sign */ duk_small_uint_t s2n_flags; + duk_codepoint_t y; DUK__INITBUFFER(lex_ctx); + y = DUK__L1(); if (x == '0' && (y == 'x' || y == 'X')) { DUK__APPENDBUFFER(lex_ctx, x); DUK__APPENDBUFFER(lex_ctx, y); - DUK__ADVANCE(lex_ctx, 2); + DUK__ADVANCECHARS(lex_ctx, 2); int_only = 1; allow_hex = 1; #ifdef DUK_USE_OCTAL_SUPPORT @@ -66410,7 +76359,7 @@ void duk__parse_input_element_raw(duk_lexer_ctx *lex_ctx, */ DUK__APPENDBUFFER(lex_ctx, x); - DUK__ADVANCE(lex_ctx, 1); + DUK__ADVANCECHARS(lex_ctx, 1); int_only = 1; #endif } @@ -66450,7 +76399,7 @@ void duk__parse_input_element_raw(duk_lexer_ctx *lex_ctx, break; } DUK__APPENDBUFFER(lex_ctx, x); - DUK__ADVANCE(lex_ctx, 1); + DUK__ADVANCECHARS(lex_ctx, 1); } /* XXX: better coercion */ @@ -66485,215 +76434,32 @@ void duk__parse_input_element_raw(duk_lexer_ctx *lex_ctx, out_token->num = val; advtok = DUK__ADVTOK(0, DUK_TOK_NUMBER); - } else if (x == '"' || x == '\'') { - duk_small_int_t quote = x; /* Note: duk_uint8_t type yields larger code */ - duk_small_int_t adv; - - DUK__INITBUFFER(lex_ctx); - for (;;) { - DUK__ADVANCE(lex_ctx, 1); /* eat opening quote on first loop */ - x = DUK__L0(); - if (x < 0 || duk_unicode_is_line_terminator(x)) { - DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, - "eof or line terminator while parsing string literal"); - } - if (x == quote) { - DUK__ADVANCE(lex_ctx, 1); /* eat closing quote */ - break; - } - if (x == '\\') { - /* DUK__L0 -> '\' char - * DUK__L1 ... DUK__L5 -> more lookup - */ - - x = DUK__L1(); - y = DUK__L2(); - - /* How much to advance before next loop; note that next loop - * will advance by 1 anyway, so -1 from the total escape - * length (e.g. len('\uXXXX') - 1 = 6 - 1). As a default, - * 1 is good. - */ - adv = 2 - 1; /* note: long live range */ - - if (x < 0) { - DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, - "eof while parsing string literal"); - } - if (duk_unicode_is_line_terminator(x)) { - /* line continuation */ - if (x == 0x000d && y == 0x000a) { - /* CR LF again a special case */ - adv = 3 - 1; - } - } else if (x == '\'') { - DUK__APPENDBUFFER(lex_ctx, 0x0027); - } else if (x == '"') { - DUK__APPENDBUFFER(lex_ctx, 0x0022); - } else if (x == '\\') { - DUK__APPENDBUFFER(lex_ctx, 0x005c); - } else if (x == 'b') { - DUK__APPENDBUFFER(lex_ctx, 0x0008); - } else if (x == 'f') { - DUK__APPENDBUFFER(lex_ctx, 0x000c); - } else if (x == 'n') { - DUK__APPENDBUFFER(lex_ctx, 0x000a); - } else if (x == 'r') { - DUK__APPENDBUFFER(lex_ctx, 0x000d); - } else if (x == 't') { - DUK__APPENDBUFFER(lex_ctx, 0x0009); - } else if (x == 'v') { - DUK__APPENDBUFFER(lex_ctx, 0x000b); - } else if (x == 'x') { - adv = 4 - 1; - DUK__APPENDBUFFER(lex_ctx, duk__decode_hexesc_from_window(lex_ctx, 2)); - } else if (x == 'u') { - adv = 6 - 1; - DUK__APPENDBUFFER(lex_ctx, duk__decode_uniesc_from_window(lex_ctx, 2)); - } else if (DUK__ISDIGIT(x)) { - duk_codepoint_t ch = 0; /* initialized to avoid warnings of unused var */ - - /* - * Octal escape or zero escape: - * \0 (lookahead not DecimalDigit) - * \1 ... \7 (lookahead not DecimalDigit) - * \ZeroToThree OctalDigit (lookahead not DecimalDigit) - * \FourToSeven OctalDigit (no lookahead restrictions) - * \ZeroToThree OctalDigit OctalDigit (no lookahead restrictions) - * - * Zero escape is part of the standard syntax. Octal escapes are - * defined in E5 Section B.1.2, and are only allowed in non-strict mode. - * Any other productions starting with a decimal digit are invalid. - */ - - if (x == '0' && !DUK__ISDIGIT(y)) { - /* Zero escape (also allowed in non-strict mode) */ - ch = 0; - /* adv = 2 - 1 default OK */ -#ifdef DUK_USE_OCTAL_SUPPORT - } else if (strict_mode) { - /* No other escape beginning with a digit in strict mode */ - DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, - "invalid escape while parsing string literal"); - } else if (DUK__ISDIGIT03(x) && DUK__ISOCTDIGIT(y) && DUK__ISOCTDIGIT(DUK__L3())) { - /* Three digit octal escape, digits validated. */ - adv = 4 - 1; - ch = (duk__hexval(lex_ctx, x) << 6) + - (duk__hexval(lex_ctx, y) << 3) + - duk__hexval(lex_ctx, DUK__L3()); - } else if (((DUK__ISDIGIT03(x) && !DUK__ISDIGIT(DUK__L3())) || DUK__ISDIGIT47(x)) && - DUK__ISOCTDIGIT(y)) { - /* Two digit octal escape, digits validated. - * - * The if-condition is a bit tricky. We could catch e.g. - * '\039' in the three-digit escape and fail it there (by - * validating the digits), but we want to avoid extra - * additional validation code. - */ - adv = 3 - 1; - ch = (duk__hexval(lex_ctx, x) << 3) + - duk__hexval(lex_ctx, y); - } else if (DUK__ISDIGIT(x) && !DUK__ISDIGIT(y)) { - /* One digit octal escape, digit validated. */ - /* adv = 2 default OK */ - ch = duk__hexval(lex_ctx, x); -#else - /* fall through to error */ -#endif - } else { - DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, - "invalid escape while parsing string literal"); - } - - DUK__APPENDBUFFER(lex_ctx, ch); - } else { - /* escaped NonEscapeCharacter */ - DUK__APPENDBUFFER(lex_ctx, x); - } - DUK__ADVANCE(lex_ctx, adv); - - /* Track number of escapes; count not really needed but directive - * prologues need to detect whether there were any escapes or line - * continuations or not. - */ - out_token->num_escapes++; - } else { - /* part of string */ - DUK__APPENDBUFFER(lex_ctx, x); - } - } - - duk__internbuffer(lex_ctx, lex_ctx->slot1_idx); - out_token->str1 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx); - - DUK__INITBUFFER(lex_ctx); /* free some memory */ - - advtok = DUK__ADVTOK(0, DUK_TOK_STRING); + } else if (duk_unicode_is_whitespace(DUK__LOOKUP(lex_ctx, 0))) { + DUK__ADVANCECHARS(lex_ctx, 1); + goto restart; } else if (x < 0) { advtok = DUK__ADVTOK(0, DUK_TOK_EOF); } else { DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "error parsing token"); } + skip_slow_path: /* * Shared exit path */ - DUK__ADVANCE(lex_ctx, advtok >> 8); + DUK__ADVANCEBYTES(lex_ctx, advtok >> 8); out_token->t = advtok & 0xff; if (out_token->t_nores < 0) { out_token->t_nores = out_token->t; } -} - -/* - * Tokenize input until a non-whitespace, non-lineterm token is found. - * Note in the output token whether a lineterm token preceded the starting - * point (inclusive) and the result token. This information is needed for - * automatic semicolon insertion. - * - * Future work: - * - * * Merge with duk__parse_input_element_raw() because only this function is - * called in practice. - */ - -/* XXX: change mode flags into one flags argument? */ - -DUK_INTERNAL -void duk_lexer_parse_js_input_element(duk_lexer_ctx *lex_ctx, - duk_token *out_token, - duk_bool_t strict_mode, - duk_bool_t regexp_mode) { - duk_small_int_t tok; - duk_bool_t got_lineterm = 0; /* got lineterm preceding non-whitespace, non-lineterm token */ - - for (;;) { - duk__parse_input_element_raw(lex_ctx, out_token, strict_mode, regexp_mode); - tok = out_token->t; - - DUK_DDD(DUK_DDDPRINT("RAWTOKEN: %ld (line %ld)", - (long) tok, (long) out_token->start_line)); - - if (tok == DUK_TOK_COMMENT) { - /* single-line comment or multi-line comment without an internal lineterm */ - continue; - } else if (tok == DUK_TOK_LINETERM) { - /* lineterm or multi-line comment with an internal lineterm */ - got_lineterm = 1; - continue; - } else { - break; - } - } - out_token->lineterm = got_lineterm; /* Automatic semicolon insertion is allowed if a token is preceded * by line terminator(s), or terminates a statement list (right curly * or EOF). */ - if (got_lineterm || tok == DUK_TOK_RCURLY || tok == DUK_TOK_EOF) { + if (got_lineterm || out_token->t == DUK_TOK_RCURLY || out_token->t == DUK_TOK_EOF) { out_token->allow_auto_semi = 1; } else { out_token->allow_auto_semi = 0; @@ -66782,7 +76548,7 @@ DUK_INTERNAL void duk_lexer_parse_re_token(duk_lexer_ctx *lex_ctx, duk_re_token duk_uint_fast32_t val2 = DUK_RE_QUANTIFIER_INFINITE; duk_small_int_t digits = 0; for (;;) { - DUK__ADVANCE(lex_ctx, 1); /* eat '{' on entry */ + DUK__ADVANCECHARS(lex_ctx, 1); /* eat '{' on entry */ x = DUK__L0(); if (DUK__ISDIGIT(x)) { if (digits >= DUK__MAX_RE_QUANT_DIGITS) { @@ -66804,7 +76570,7 @@ DUK_INTERNAL void duk_lexer_parse_re_token(duk_lexer_ctx *lex_ctx, duk_re_token } out_token->qmin = val1; out_token->qmax = DUK_RE_QUANTIFIER_INFINITE; - DUK__ADVANCE(lex_ctx, 2); + DUK__ADVANCECHARS(lex_ctx, 2); break; } val2 = val1; @@ -66824,7 +76590,7 @@ DUK_INTERNAL void duk_lexer_parse_re_token(duk_lexer_ctx *lex_ctx, duk_re_token out_token->qmin = val1; out_token->qmax = val1; } - DUK__ADVANCE(lex_ctx, 1); + DUK__ADVANCECHARS(lex_ctx, 1); break; } else { DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, @@ -66833,7 +76599,7 @@ DUK_INTERNAL void duk_lexer_parse_re_token(duk_lexer_ctx *lex_ctx, duk_re_token } if (DUK__L0() == '?') { out_token->greedy = 0; - DUK__ADVANCE(lex_ctx, 1); + DUK__ADVANCECHARS(lex_ctx, 1); } else { out_token->greedy = 1; } @@ -66914,7 +76680,7 @@ DUK_INTERNAL void duk_lexer_parse_re_token(duk_lexer_ctx *lex_ctx, duk_re_token DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "invalid regexp escape (decimal escape too long)"); } - DUK__ADVANCE(lex_ctx, 1); /* eat backslash on entry */ + DUK__ADVANCECHARS(lex_ctx, 1); /* eat backslash on entry */ x = DUK__L0(); if (!DUK__ISDIGIT(x)) { break; @@ -67004,7 +76770,7 @@ DUK_INTERNAL void duk_lexer_parse_re_token(duk_lexer_ctx *lex_ctx, duk_re_token * Shared exit path */ - DUK__ADVANCE(lex_ctx, advtok >> 8); + DUK__ADVANCEBYTES(lex_ctx, advtok >> 8); out_token->t = advtok & 0xff; } @@ -67056,7 +76822,7 @@ DUK_INTERNAL void duk_lexer_parse_re_ranges(duk_lexer_ctx *lex_ctx, duk_re_range for (;;) { x = DUK__L0(); - DUK__ADVANCE(lex_ctx, 1); + DUK__ADVANCECHARS(lex_ctx, 1); ch = -1; /* not strictly necessary, but avoids "uninitialized variable" warnings */ DUK_UNREF(ch); @@ -67089,7 +76855,7 @@ DUK_INTERNAL void duk_lexer_parse_re_ranges(duk_lexer_ctx *lex_ctx, duk_re_range */ x = DUK__L0(); - DUK__ADVANCE(lex_ctx, 1); + DUK__ADVANCECHARS(lex_ctx, 1); if (x == 'b') { /* Note: '\b' in char class is different than outside (assertion), @@ -67109,7 +76875,7 @@ DUK_INTERNAL void duk_lexer_parse_re_ranges(duk_lexer_ctx *lex_ctx, duk_re_range ch = 0x000b; } else if (x == 'c') { x = DUK__L0(); - DUK__ADVANCE(lex_ctx, 1); + DUK__ADVANCECHARS(lex_ctx, 1); if ((x >= 'a' && x <= 'z') || (x >= 'A' && x <= 'Z')) { ch = (x % 32); @@ -67122,10 +76888,10 @@ DUK_INTERNAL void duk_lexer_parse_re_ranges(duk_lexer_ctx *lex_ctx, duk_re_range } } else if (x == 'x') { ch = duk__decode_hexesc_from_window(lex_ctx, 0); - DUK__ADVANCE(lex_ctx, 2); + DUK__ADVANCECHARS(lex_ctx, 2); } else if (x == 'u') { ch = duk__decode_uniesc_from_window(lex_ctx, 0); - DUK__ADVANCE(lex_ctx, 4); + DUK__ADVANCECHARS(lex_ctx, 4); } else if (x == 'd') { duk__emit_u16_direct_ranges(lex_ctx, gen_range, @@ -67245,7 +77011,7 @@ DUK_INTERNAL void duk_lexer_parse_re_ranges(duk_lexer_ctx *lex_ctx, duk_re_range * and uses a minimum number of digits. The big number arithmetic has a * fixed maximum size and does not require dynamic allocations. * - * See: doc/number-conversion.txt. + * See: doc/number-conversion.rst. */ /* include removed: duk_internal.h */ @@ -67374,7 +77140,7 @@ DUK_LOCAL void duk__bi_copy(duk__bigint *x, duk__bigint *y) { if (n == 0) { return; } - DUK_MEMCPY((void *) x->v, (void *) y->v, (size_t) (sizeof(duk_uint32_t) * n)); + DUK_MEMCPY((void *) x->v, (const void *) y->v, (size_t) (sizeof(duk_uint32_t) * n)); } DUK_LOCAL void duk__bi_set_small(duk__bigint *x, duk_uint32_t v) { @@ -67860,7 +77626,7 @@ DUK_LOCAL void duk__bi_exp_small(duk__bigint *x, duk_small_int_t b, duk_small_in * The same algorithm is used for number parsing (with b=10 and B=2) * by generating one extra digit and doing rounding manually. * - * See doc/number-conversion.txt for limitations. + * See doc/number-conversion.rst for limitations. */ /* Maximum number of digits generated. */ @@ -67936,7 +77702,7 @@ DUK_LOCAL duk_size_t duk__dragon4_format_uint32(duk_uint8_t *buf, duk_uint32_t x } len = (duk_size_t) ((buf + 32) - p); - DUK_MEMMOVE((void *) buf, (void *) p, (size_t) len); + DUK_MEMMOVE((void *) buf, (const void *) p, (size_t) len); return len; } @@ -68251,7 +78017,7 @@ DUK_LOCAL void duk__dragon4_generate(duk__numconv_stringify_ctx *nc_ctx) { tc1 = (duk__bi_compare(&nc_ctx->r, &nc_ctx->mm) <= (nc_ctx->low_ok ? 0 : -1)); duk__bi_add(&nc_ctx->t1, &nc_ctx->r, &nc_ctx->mp); /* t1 <- (+ r m+) */ - tc2 = (duk__bi_compare(&nc_ctx->t1, &nc_ctx->s) >= (&nc_ctx->high_ok ? 0 : 1)); + tc2 = (duk__bi_compare(&nc_ctx->t1, &nc_ctx->s) >= (nc_ctx->high_ok ? 0 : 1)); DUK_DDD(DUK_DDDPRINT("tc1=%ld, tc2=%ld", (long) tc1, (long) tc2)); } else { @@ -68405,7 +78171,7 @@ DUK_LOCAL duk_small_int_t duk__dragon4_fixed_format_round(duk__numconv_stringify if (p == &nc_ctx->digits[0]) { DUK_DDD(DUK_DDDPRINT("carry propagated to first digit -> special case handling")); DUK_MEMMOVE((void *) (&nc_ctx->digits[1]), - (void *) (&nc_ctx->digits[0]), + (const void *) (&nc_ctx->digits[0]), (size_t) (sizeof(char) * nc_ctx->count)); nc_ctx->digits[0] = 1; /* don't increase 'count' */ nc_ctx->k++; /* position of highest digit changed */ @@ -68421,7 +78187,7 @@ DUK_LOCAL duk_small_int_t duk__dragon4_fixed_format_round(duk__numconv_stringify DUK_DDD(DUK_DDDPRINT("digit before carry: %ld", (long) t)); if (++t < nc_ctx->B) { DUK_DDD(DUK_DDDPRINT("rounding carry terminated")); - *p = t; + *p = (duk_uint8_t) t; break; } @@ -69176,7 +78942,7 @@ DUK_INTERNAL void duk_numconv_parse(duk_context *ctx, duk_small_int_t radix, duk DUK_DDD(DUK_DDDPRINT("parse digits: p=%p, ch='%c' (%ld), expt=%ld, expt_adj=%ld, " "dig_whole=%ld, dig_frac=%ld, dig_expt=%ld, dig_lzero=%ld, dig_prec=%ld", - (void *) p, (int) ((ch >= 0x20 && ch <= 0x7e) ? ch : '?'), (long) ch, + (const void *) p, (int) ((ch >= 0x20 && ch <= 0x7e) ? ch : '?'), (long) ch, (long) expt, (long) expt_adj, (long) dig_whole, (long) dig_frac, (long) dig_expt, (long) dig_lzero, (long) dig_prec)); DUK__BI_PRINT("f", &nc_ctx->f); @@ -69506,7 +79272,7 @@ DUK_INTERNAL void duk_numconv_parse(duk_context *ctx, duk_small_int_t radix, duk /* * Regexp compilation. * - * See doc/regexp.txt for a discussion of the compilation approach and + * See doc/regexp.rst for a discussion of the compilation approach and * current limitations. * * Regexp bytecode assumes jumps can be expressed with signed 32-bit @@ -69531,11 +79297,11 @@ DUK_INTERNAL void duk_numconv_parse(duk_context *ctx, duk_small_int_t radix, duk * Helper macros */ -#ifdef DUK__BUFLEN -#undef DUK__BUFLEN -#endif +#define DUK__RE_INITIAL_BUFSIZE 64 -#define DUK__BUFLEN(re_ctx) DUK_HBUFFER_GET_SIZE((duk_hbuffer *) re_ctx->buf) +#undef DUK__RE_BUFLEN +#define DUK__RE_BUFLEN(re_ctx) \ + DUK_BW_GET_SIZE(re_ctx->thr, &re_ctx->bw) /* * Disjunction struct: result of parsing a disjunction @@ -69588,20 +79354,30 @@ DUK_LOCAL duk_uint32_t duk__encode_i32(duk_int32_t x) { * maximum size. */ DUK_LOCAL duk_uint32_t duk__insert_u32(duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_uint32_t x) { - return (duk_uint32_t) duk_hbuffer_insert_xutf8(re_ctx->thr, re_ctx->buf, offset, x); + duk_uint8_t buf[DUK_UNICODE_MAX_XUTF8_LENGTH]; + duk_small_int_t len; + + len = duk_unicode_encode_xutf8((duk_ucodepoint_t) x, buf); + DUK_BW_INSERT_ENSURE_BYTES(re_ctx->thr, &re_ctx->bw, offset, buf, len); + return (duk_uint32_t) len; } DUK_LOCAL duk_uint32_t duk__append_u32(duk_re_compiler_ctx *re_ctx, duk_uint32_t x) { - return (duk_uint32_t) duk_hbuffer_append_xutf8(re_ctx->thr, re_ctx->buf, x); + duk_uint8_t buf[DUK_UNICODE_MAX_XUTF8_LENGTH]; + duk_small_int_t len; + + len = duk_unicode_encode_xutf8((duk_ucodepoint_t) x, buf); + DUK_BW_WRITE_ENSURE_BYTES(re_ctx->thr, &re_ctx->bw, buf, len); + return (duk_uint32_t) len; } DUK_LOCAL duk_uint32_t duk__insert_i32(duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_int32_t x) { - return (duk_uint32_t) duk_hbuffer_insert_xutf8(re_ctx->thr, re_ctx->buf, offset, duk__encode_i32(x)); + return duk__insert_u32(re_ctx, offset, duk__encode_i32(x)); } #if 0 /* unused */ DUK_LOCAL duk_uint32_t duk__append_i32(duk_re_compiler_ctx *re_ctx, duk_int32_t x) { - return duk_hbuffer_append_xutf8(re_ctx->thr, re_ctx->buf, duk__encode_i32(x)); + return duk__append_u32(re_ctx, duk__encode_i32(x)); } #endif @@ -69615,15 +79391,15 @@ DUK_LOCAL void duk__append_u16_list(duk_re_compiler_ctx *re_ctx, duk_uint16_t *v } DUK_LOCAL void duk__insert_slice(duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_uint32_t data_offset, duk_uint32_t data_length) { - duk_hbuffer_insert_slice(re_ctx->thr, re_ctx->buf, offset, data_offset, (duk_size_t) data_length); + DUK_BW_INSERT_ENSURE_SLICE(re_ctx->thr, &re_ctx->bw, offset, data_offset, data_length); } DUK_LOCAL void duk__append_slice(duk_re_compiler_ctx *re_ctx, duk_uint32_t data_offset, duk_uint32_t data_length) { - duk_hbuffer_append_slice(re_ctx->thr, re_ctx->buf, data_offset, (duk_size_t) data_length); + DUK_BW_WRITE_ENSURE_SLICE(re_ctx->thr, &re_ctx->bw, data_offset, data_length); } -DUK_LOCAL void duk__remove_slice(duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_uint32_t length) { - duk_hbuffer_remove_slice(re_ctx->thr, re_ctx->buf, offset, (duk_size_t) length); +DUK_LOCAL void duk__remove_slice(duk_re_compiler_ctx *re_ctx, duk_uint32_t data_offset, duk_uint32_t data_length) { + DUK_BW_REMOVE_ENSURE_SLICE(re_ctx->thr, &re_ctx->bw, data_offset, data_length); } /* @@ -69637,7 +79413,7 @@ DUK_LOCAL void duk__remove_slice(duk_re_compiler_ctx *re_ctx, duk_uint32_t offse * * Computing the final (adjusted) skip value, which is relative to the * first byte of the next instruction, is a bit tricky because of the - * variable length UTF-8 encoding. See doc/regexp.txt for discussion. + * variable length UTF-8 encoding. See doc/regexp.rst for discussion. */ DUK_LOCAL duk_uint32_t duk__insert_jump_offset(duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_int32_t skip) { duk_small_int_t len; @@ -69655,7 +79431,7 @@ DUK_LOCAL duk_uint32_t duk__insert_jump_offset(duk_re_compiler_ctx *re_ctx, duk_ } DUK_LOCAL duk_uint32_t duk__append_jump_offset(duk_re_compiler_ctx *re_ctx, duk_int32_t skip) { - return (duk_uint32_t) duk__insert_jump_offset(re_ctx, (duk_uint32_t) DUK__BUFLEN(re_ctx), skip); + return (duk_uint32_t) duk__insert_jump_offset(re_ctx, (duk_uint32_t) DUK__RE_BUFLEN(re_ctx), skip); } /* @@ -69670,7 +79446,7 @@ DUK_LOCAL duk_uint32_t duk__append_jump_offset(duk_re_compiler_ctx *re_ctx, duk_ * continuous range is not necessarily continuous (e.g. [x-{] is * continuous but [X-{] is not). The current algorithm creates the * canonicalized range(s) space efficiently at the cost of compile - * time execution time (see doc/regexp.txt for discussion). + * time execution time (see doc/regexp.rst for discussion). * * Note that the ctx->nranges is a context-wide temporary value * (this is OK because there cannot be multiple character classes @@ -69736,7 +79512,7 @@ DUK_LOCAL void duk__generate_ranges(void *userdata, duk_codepoint_t r1, duk_code * lookaheads, capturing parentheses, and non-capturing parentheses. * * The function determines whether the entire disjunction is a 'simple atom' - * (see doc/regexp.txt discussion on 'simple quantifiers') and if so, + * (see doc/regexp.rst discussion on 'simple quantifiers') and if so, * returns the atom character length which is needed by the caller to keep * track of its own atom character length. A disjunction with more than one * alternative is never considered a simple atom (although in some cases @@ -69784,7 +79560,7 @@ DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t ex duk_uint32_t atom_start_captures = re_ctx->captures; /* value of re_ctx->captures at start of atom */ duk_int32_t unpatched_disjunction_split = -1; duk_int32_t unpatched_disjunction_jump = -1; - duk_uint32_t entry_offset = (duk_uint32_t) DUK__BUFLEN(re_ctx); + duk_uint32_t entry_offset = (duk_uint32_t) DUK__RE_BUFLEN(re_ctx); duk_int32_t res_charlen = 0; /* -1 if disjunction is complex, char length if simple */ duk__re_disjunction_info tmp_disj; @@ -69842,7 +79618,7 @@ DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t ex offset = unpatched_disjunction_jump; offset += duk__insert_jump_offset(re_ctx, offset, - (duk_int32_t) (DUK__BUFLEN(re_ctx) - offset)); + (duk_int32_t) (DUK__RE_BUFLEN(re_ctx) - offset)); /* offset is now target of the pending split (right after jump) */ duk__insert_jump_offset(re_ctx, unpatched_disjunction_split, @@ -69857,7 +79633,7 @@ DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t ex /* add a new pending match jump for latest finished alternative */ duk__append_u32(re_ctx, DUK_REOP_JUMP); - unpatched_disjunction_jump = (duk_int32_t) DUK__BUFLEN(re_ctx); + unpatched_disjunction_jump = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); /* 'taint' result as complex */ res_charlen = -1; @@ -69902,7 +79678,7 @@ DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t ex } duk__append_u32(re_ctx, DUK_REOP_MATCH); /* complete 'sub atom' */ - atom_code_length = (duk_int32_t) (DUK__BUFLEN(re_ctx) - atom_start_offset); + atom_code_length = (duk_int32_t) (DUK__RE_BUFLEN(re_ctx) - atom_start_offset); offset = atom_start_offset; if (re_ctx->curr_token.greedy) { @@ -69958,7 +79734,7 @@ DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t ex (long) atom_start_captures)); } - atom_code_length = (duk_int32_t) DUK__BUFLEN(re_ctx) - atom_start_offset; + atom_code_length = (duk_int32_t) DUK__RE_BUFLEN(re_ctx) - atom_start_offset; /* insert the required matches (qmin) by copying the atom */ tmp_qmin = re_ctx->curr_token.qmin; @@ -70007,7 +79783,7 @@ DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t ex * ... * LSEQ: */ - duk_uint32_t offset = (duk_uint32_t) DUK__BUFLEN(re_ctx); + duk_uint32_t offset = (duk_uint32_t) DUK__RE_BUFLEN(re_ctx); while (tmp_qmax > 0) { duk__insert_slice(re_ctx, offset, atom_start_offset, atom_code_length); if (re_ctx->curr_token.greedy) { @@ -70017,7 +79793,7 @@ DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t ex } duk__insert_jump_offset(re_ctx, offset + 1, /* +1 for opcode */ - (duk_int32_t) (DUK__BUFLEN(re_ctx) - (offset + 1))); + (duk_int32_t) (DUK__RE_BUFLEN(re_ctx) - (offset + 1))); tmp_qmax--; } } @@ -70052,14 +79828,14 @@ DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t ex duk_uint32_t opcode = (re_ctx->curr_token.t == DUK_RETOK_ASSERT_START_POS_LOOKAHEAD) ? DUK_REOP_LOOKPOS : DUK_REOP_LOOKNEG; - offset = (duk_uint32_t) DUK__BUFLEN(re_ctx); + offset = (duk_uint32_t) DUK__RE_BUFLEN(re_ctx); duk__parse_disjunction(re_ctx, 0, &tmp_disj); duk__append_u32(re_ctx, DUK_REOP_MATCH); (void) duk__insert_u32(re_ctx, offset, opcode); (void) duk__insert_jump_offset(re_ctx, offset + 1, /* +1 for opcode */ - (duk_int32_t) (DUK__BUFLEN(re_ctx) - (offset + 1))); + (duk_int32_t) (DUK__RE_BUFLEN(re_ctx) - (offset + 1))); /* 'taint' result as complex -- this is conservative, * as lookaheads do not backtrack. @@ -70069,7 +79845,7 @@ DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t ex } case DUK_RETOK_ATOM_PERIOD: { new_atom_char_length = 1; - new_atom_start_offset = (duk_int32_t) DUK__BUFLEN(re_ctx); + new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); duk__append_u32(re_ctx, DUK_REOP_PERIOD); break; } @@ -70081,7 +79857,7 @@ DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t ex duk_uint32_t ch; new_atom_char_length = 1; - new_atom_start_offset = (duk_int32_t) DUK__BUFLEN(re_ctx); + new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); duk__append_u32(re_ctx, DUK_REOP_CHAR); ch = re_ctx->curr_token.num; if (re_ctx->re_flags & DUK_RE_FLAG_IGNORE_CASE) { @@ -70093,7 +79869,7 @@ DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t ex case DUK_RETOK_ATOM_DIGIT: case DUK_RETOK_ATOM_NOT_DIGIT: { new_atom_char_length = 1; - new_atom_start_offset = (duk_int32_t) DUK__BUFLEN(re_ctx); + new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); duk__append_u32(re_ctx, (re_ctx->curr_token.t == DUK_RETOK_ATOM_DIGIT) ? DUK_REOP_RANGES : DUK_REOP_INVRANGES); @@ -70104,7 +79880,7 @@ DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t ex case DUK_RETOK_ATOM_WHITE: case DUK_RETOK_ATOM_NOT_WHITE: { new_atom_char_length = 1; - new_atom_start_offset = (duk_int32_t) DUK__BUFLEN(re_ctx); + new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); duk__append_u32(re_ctx, (re_ctx->curr_token.t == DUK_RETOK_ATOM_WHITE) ? DUK_REOP_RANGES : DUK_REOP_INVRANGES); @@ -70115,7 +79891,7 @@ DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t ex case DUK_RETOK_ATOM_WORD_CHAR: case DUK_RETOK_ATOM_NOT_WORD_CHAR: { new_atom_char_length = 1; - new_atom_start_offset = (duk_int32_t) DUK__BUFLEN(re_ctx); + new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); duk__append_u32(re_ctx, (re_ctx->curr_token.t == DUK_RETOK_ATOM_WORD_CHAR) ? DUK_REOP_RANGES : DUK_REOP_INVRANGES); @@ -70129,7 +79905,7 @@ DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t ex re_ctx->highest_backref = backref; } new_atom_char_length = -1; /* mark as complex */ - new_atom_start_offset = (duk_int32_t) DUK__BUFLEN(re_ctx); + new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); duk__append_u32(re_ctx, DUK_REOP_BACKREFERENCE); duk__append_u32(re_ctx, backref); break; @@ -70138,7 +79914,7 @@ DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t ex duk_uint32_t cap; new_atom_char_length = -1; /* mark as complex (capture handling) */ - new_atom_start_offset = (duk_int32_t) DUK__BUFLEN(re_ctx); + new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); cap = ++re_ctx->captures; duk__append_u32(re_ctx, DUK_REOP_SAVE); duk__append_u32(re_ctx, cap * 2); @@ -70148,7 +79924,7 @@ DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t ex break; } case DUK_RETOK_ATOM_START_NONCAPTURE_GROUP: { - new_atom_start_offset = (duk_int32_t) DUK__BUFLEN(re_ctx); + new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); duk__parse_disjunction(re_ctx, 0, &tmp_disj); new_atom_char_length = tmp_disj.charlen; break; @@ -70185,11 +79961,11 @@ DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t ex /* insert ranges instruction, range count patched in later */ new_atom_char_length = 1; - new_atom_start_offset = (duk_int32_t) DUK__BUFLEN(re_ctx); + new_atom_start_offset = (duk_int32_t) DUK__RE_BUFLEN(re_ctx); duk__append_u32(re_ctx, (re_ctx->curr_token.t == DUK_RETOK_ATOM_START_CHARCLASS) ? DUK_REOP_RANGES : DUK_REOP_INVRANGES); - offset = (duk_uint32_t) DUK__BUFLEN(re_ctx); /* patch in range count later */ + offset = (duk_uint32_t) DUK__RE_BUFLEN(re_ctx); /* patch in range count later */ /* parse ranges until character class ends */ re_ctx->nranges = 0; /* note: ctx-wide temporary */ @@ -70245,7 +80021,7 @@ DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t ex offset = unpatched_disjunction_jump; offset += duk__insert_jump_offset(re_ctx, offset, - (duk_int32_t) (DUK__BUFLEN(re_ctx) - offset)); + (duk_int32_t) (DUK__RE_BUFLEN(re_ctx) - offset)); /* offset is now target of the pending split (right after jump) */ duk__insert_jump_offset(re_ctx, unpatched_disjunction_split, @@ -70336,8 +80112,10 @@ DUK_LOCAL duk_uint32_t duk__parse_regexp_flags(duk_hthread *thr, duk_hstring *h) DUK_LOCAL void duk__create_escaped_source(duk_hthread *thr, int idx_pattern) { duk_context *ctx = (duk_context *) thr; duk_hstring *h; - duk_hbuffer_dynamic *buf; const duk_uint8_t *p; + duk_bufwriter_ctx bw_alloc; + duk_bufwriter_ctx *bw; + duk_uint8_t *q; duk_size_t i, n; duk_uint_fast8_t c_prev, c; @@ -70352,26 +80130,29 @@ DUK_LOCAL void duk__create_escaped_source(duk_hthread *thr, int idx_pattern) { return; } - duk_push_dynamic_buffer(ctx, 0); - buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1); - DUK_ASSERT(buf != NULL); + bw = &bw_alloc; + DUK_BW_INIT_PUSHBUF(thr, bw, n); + q = DUK_BW_GET_PTR(thr, bw); c_prev = (duk_uint_fast8_t) 0; for (i = 0; i < n; i++) { c = p[i]; + q = DUK_BW_ENSURE_RAW(thr, bw, 2, q); + if (c == (duk_uint_fast8_t) '/' && c_prev != (duk_uint_fast8_t) '\\') { /* Unescaped '/' ANYWHERE in the regexp (in disjunction, * inside a character class, ...) => same escape works. */ - duk_hbuffer_append_byte(thr, buf, (duk_uint8_t) '\\'); + *q++ = DUK_ASC_BACKSLASH; } - duk_hbuffer_append_byte(thr, buf, (duk_uint8_t) c); + *q++ = (duk_uint8_t) c; c_prev = c; } + DUK_BW_SETPTR_AND_COMPACT(thr, bw, q); duk_to_string(ctx, -1); /* -> [ ... escaped_source ] */ } @@ -70396,7 +80177,6 @@ DUK_INTERNAL void duk_regexp_compile(duk_hthread *thr) { duk_lexer_point lex_point; duk_hstring *h_pattern; duk_hstring *h_flags; - duk_hbuffer_dynamic *h_buffer; duk__re_disjunction_info ign_disj; DUK_ASSERT(thr != NULL); @@ -70424,10 +80204,6 @@ DUK_INTERNAL void duk_regexp_compile(duk_hthread *thr) { * Init compilation context */ - duk_push_dynamic_buffer(ctx, 0); - h_buffer = (duk_hbuffer_dynamic *) duk_require_hbuffer(ctx, -1); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(h_buffer)); - /* [ ... pattern flags escaped_source buffer ] */ DUK_MEMZERO(&re_ctx, sizeof(re_ctx)); @@ -70437,10 +80213,11 @@ DUK_INTERNAL void duk_regexp_compile(duk_hthread *thr) { re_ctx.lex.input = DUK_HSTRING_GET_DATA(h_pattern); re_ctx.lex.input_length = DUK_HSTRING_GET_BYTELEN(h_pattern); re_ctx.lex.token_limit = DUK_RE_COMPILE_TOKEN_LIMIT; - re_ctx.buf = h_buffer; - re_ctx.recursion_limit = DUK_RE_COMPILE_RECURSION_LIMIT; + re_ctx.recursion_limit = DUK_USE_REGEXP_COMPILER_RECLIMIT; re_ctx.re_flags = duk__parse_regexp_flags(thr, h_flags); + DUK_BW_INIT_PUSHBUF(thr, &re_ctx.bw, DUK__RE_INITIAL_BUFSIZE); + DUK_DD(DUK_DDPRINT("regexp compiler ctx initialized, flags=0x%08lx, recursion_limit=%ld", (unsigned long) re_ctx.re_flags, (long) re_ctx.recursion_limit)); @@ -70465,9 +80242,6 @@ DUK_INTERNAL void duk_regexp_compile(duk_hthread *thr) { duk__append_u32(&re_ctx, 1); duk__append_u32(&re_ctx, DUK_REOP_MATCH); - DUK_D(DUK_DPRINT("regexp bytecode size (before header) is %ld bytes", - (long) DUK_HBUFFER_GET_SIZE(re_ctx.buf))); - /* * Check for invalid backreferences; note that it is NOT an error * to back-reference a capture group which has not yet been introduced @@ -70489,12 +80263,9 @@ DUK_INTERNAL void duk_regexp_compile(duk_hthread *thr) { duk__insert_u32(&re_ctx, 0, (re_ctx.captures + 1) * 2); duk__insert_u32(&re_ctx, 0, re_ctx.re_flags); - DUK_D(DUK_DPRINT("regexp bytecode size (after header) is %ld bytes", - (long) DUK_HBUFFER_GET_SIZE(re_ctx.buf))); - DUK_DDD(DUK_DDDPRINT("compiled regexp: %!xO", (duk_heaphdr *) re_ctx.buf)); - /* [ ... pattern flags escaped_source buffer ] */ + DUK_BW_COMPACT(thr, &re_ctx.bw); duk_to_string(ctx, -1); /* coerce to string */ /* [ ... pattern flags escaped_source bytecode ] */ @@ -70570,7 +80341,7 @@ DUK_INTERNAL void duk_regexp_create_instance(duk_hthread *thr) { /* [ ... regexp_object ] */ } -#undef DUK__BUFLEN +#undef DUK__RE_BUFLEN #else /* DUK_USE_REGEXP_SUPPORT */ @@ -70759,7 +80530,7 @@ DUK_LOCAL const duk_uint8_t *duk__match_regexp(duk_re_matcher_ctx *re_ctx, const * * There is no opcode for matching multiple characters. The * regexp compiler has trouble joining strings efficiently - * during compilation. See doc/regexp.txt for more discussion. + * during compilation. See doc/regexp.rst for more discussion. */ duk_codepoint_t c1, c2; @@ -71293,12 +81064,12 @@ DUK_LOCAL void duk__regexp_match_helper(duk_hthread *thr, duk_small_int_t force_ DUK_MEMZERO(&re_ctx, sizeof(re_ctx)); re_ctx.thr = thr; - re_ctx.input = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input); + re_ctx.input = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input); re_ctx.input_end = re_ctx.input + DUK_HSTRING_GET_BYTELEN(h_input); - re_ctx.bytecode = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h_bytecode); + re_ctx.bytecode = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_bytecode); re_ctx.bytecode_end = re_ctx.bytecode + DUK_HSTRING_GET_BYTELEN(h_bytecode); re_ctx.saved = NULL; - re_ctx.recursion_limit = DUK_RE_EXECUTE_RECURSION_LIMIT; + re_ctx.recursion_limit = DUK_USE_REGEXP_EXECUTOR_RECLIMIT; re_ctx.steps_limit = DUK_RE_EXECUTE_STEPS_LIMIT; /* read header */ @@ -71392,8 +81163,8 @@ DUK_LOCAL void duk__regexp_match_helper(duk_hthread *thr, duk_small_int_t force_ DUK_ASSERT(re_ctx.recursion_depth == 0); DUK_DDD(DUK_DDDPRINT("attempt match at char offset %ld; %p [%p,%p]", - (long) char_offset, (void *) sp, (void *) re_ctx.input, - (void *) re_ctx.input_end)); + (long) char_offset, (const void *) sp, + (const void *) re_ctx.input, (const void *) re_ctx.input_end)); /* * Note: @@ -71500,7 +81271,7 @@ DUK_LOCAL void duk__regexp_match_helper(duk_hthread *thr, duk_small_int_t force_ duk_hstring *h_saved; duk_push_lstring(ctx, - (char *) re_ctx.saved[i], + (const char *) re_ctx.saved[i], (duk_size_t) (re_ctx.saved[i+1] - re_ctx.saved[i])); h_saved = duk_get_hstring(ctx, -1); DUK_ASSERT(h_saved != NULL); @@ -71592,15 +81363,15 @@ DUK_INTERNAL void duk_regexp_match_force_global(duk_hthread *thr) { /* include removed: duk_internal.h */ -#ifdef DUK_USE_COMPUTED_NAN +#if defined(DUK_USE_COMPUTED_NAN) DUK_INTERNAL double duk_computed_nan; #endif -#ifdef DUK_USE_COMPUTED_INFINITY +#if defined(DUK_USE_COMPUTED_INFINITY) DUK_INTERNAL double duk_computed_infinity; #endif -#ifdef DUK_USE_REPL_FPCLASSIFY +#if defined(DUK_USE_REPL_FPCLASSIFY) DUK_INTERNAL int duk_repl_fpclassify(double x) { duk_double_union u; duk_uint_fast16_t expt; @@ -71632,7 +81403,7 @@ DUK_INTERNAL int duk_repl_fpclassify(double x) { } #endif -#ifdef DUK_USE_REPL_SIGNBIT +#if defined(DUK_USE_REPL_SIGNBIT) DUK_INTERNAL int duk_repl_signbit(double x) { duk_double_union u; u.d = x; @@ -71640,7 +81411,7 @@ DUK_INTERNAL int duk_repl_signbit(double x) { } #endif -#ifdef DUK_USE_REPL_ISFINITE +#if defined(DUK_USE_REPL_ISFINITE) DUK_INTERNAL int duk_repl_isfinite(double x) { int c = DUK_FPCLASSIFY(x); if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) { @@ -71651,14 +81422,14 @@ DUK_INTERNAL int duk_repl_isfinite(double x) { } #endif -#ifdef DUK_USE_REPL_ISNAN +#if defined(DUK_USE_REPL_ISNAN) DUK_INTERNAL int duk_repl_isnan(double x) { int c = DUK_FPCLASSIFY(x); return (c == DUK_FP_NAN); } #endif -#ifdef DUK_USE_REPL_ISINF +#if defined(DUK_USE_REPL_ISINF) DUK_INTERNAL int duk_repl_isinf(double x) { int c = DUK_FPCLASSIFY(x); return (c == DUK_FP_INFINITE); @@ -71684,13 +81455,13 @@ typedef union { } duk__test_double_union; #define DUK__DBLUNION_CMP_TRUE(a,b) do { \ - if (DUK_MEMCMP((void *) (a), (void *) (b), sizeof(duk__test_double_union)) != 0) { \ + if (DUK_MEMCMP((const void *) (a), (const void *) (b), sizeof(duk__test_double_union)) != 0) { \ DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double union compares false (expected true)"); \ } \ } while (0) #define DUK__DBLUNION_CMP_FALSE(a,b) do { \ - if (DUK_MEMCMP((void *) (a), (void *) (b), sizeof(duk__test_double_union)) == 0) { \ + if (DUK_MEMCMP((const void *) (a), (const void *) (b), sizeof(duk__test_double_union)) == 0) { \ DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double union compares true (expected false)"); \ } \ } while (0) @@ -71750,7 +81521,11 @@ DUK_LOCAL void duk__selftest_packed_tval(void) { DUK_LOCAL void duk__selftest_twos_complement(void) { volatile int test; test = -1; - if (((duk_uint8_t *) &test)[0] != (duk_uint8_t) 0xff) { + + /* Note that byte order doesn't affect this test: all bytes in + * 'test' will be 0xFF for two's complement. + */ + if (((volatile duk_uint8_t *) &test)[0] != (duk_uint8_t) 0xff) { DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: two's complement arithmetic"); } } @@ -71829,7 +81604,7 @@ DUK_LOCAL void duk__selftest_bswap_macros(void) { du.uc[0] = 0x40; du.uc[1] = 0x00; du.uc[2] = 0x11; du.uc[3] = 0x22; du.uc[4] = 0x33; du.uc[5] = 0x44; du.uc[6] = 0x55; du.uc[7] = 0x66; - DUK_DBLUNION_BSWAP(&du); + DUK_DBLUNION_DOUBLE_NTOH(&du); du_diff = du.d - 2.008366013071895; #if 0 DUK_FPRINTF(DUK_STDERR, "du_diff: %lg\n", (double) du_diff); @@ -71840,13 +81615,13 @@ DUK_LOCAL void duk__selftest_bswap_macros(void) { * Linux gcc-4.8 -m32 at least). */ #if 0 - DUK_FPRINTF(DUK_STDERR, "Result of DUK_DBLUNION_BSWAP: %02x %02x %02x %02x %02x %02x %02x %02x\n", + DUK_FPRINTF(DUK_STDERR, "Result of DUK_DBLUNION_DOUBLE_NTOH: %02x %02x %02x %02x %02x %02x %02x %02x\n", (unsigned int) du.uc[0], (unsigned int) du.uc[1], (unsigned int) du.uc[2], (unsigned int) du.uc[3], (unsigned int) du.uc[4], (unsigned int) du.uc[5], (unsigned int) du.uc[6], (unsigned int) du.uc[7]); #endif - DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: DUK_DBLUNION_BSWAP"); + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: DUK_DBLUNION_DOUBLE_NTOH"); } } @@ -71871,15 +81646,12 @@ DUK_LOCAL void duk__selftest_double_aliasing(void) { * It's not an issue because the failure should only affect packed * duk_tval representation, which is not used with Emscripten. */ -#if defined(DUK_USE_NO_DOUBLE_ALIASING_SELFTEST) -#if defined(DUK_USE_PACKED_TVAL) -#error inconsistent defines: skipping double aliasing selftest when using packed duk_tval -#endif +#if !defined(DUK_USE_PACKED_TVAL) + DUK_D(DUK_DPRINT("skip double aliasing self test when duk_tval is not packed")); return; #endif - /* Test signaling NaN and alias assignment in all - * endianness combinations. + /* Test signaling NaN and alias assignment in all endianness combinations. */ /* little endian */ @@ -71906,7 +81678,7 @@ DUK_LOCAL void duk__selftest_double_aliasing(void) { */ DUK_LOCAL void duk__selftest_double_zero_sign(void) { - volatile duk__test_double_union a, b; + duk__test_double_union a, b; a.d = 0.0; b.d = -a.d; @@ -71921,16 +81693,18 @@ DUK_LOCAL void duk__selftest_double_zero_sign(void) { */ DUK_LOCAL void duk__selftest_struct_align(void) { -#if defined(DUK_USE_ALIGN_4) +#if (DUK_USE_ALIGN_BY == 4) if ((sizeof(duk_hbuffer_fixed) % 4) != 0) { DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: sizeof(duk_hbuffer_fixed) not aligned to 4"); } -#elif defined(DUK_USE_ALIGN_8) +#elif (DUK_USE_ALIGN_BY == 8) if ((sizeof(duk_hbuffer_fixed) % 8) != 0) { DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: sizeof(duk_hbuffer_fixed) not aligned to 8"); } -#else +#elif (DUK_USE_ALIGN_BY == 1) /* no check */ +#else +#error invalid DUK_USE_ALIGN_BY #endif } @@ -71961,7 +81735,7 @@ DUK_LOCAL void duk__selftest_64bit_arithmetic(void) { * Casting */ -DUK_LOCAL void duk__selftest_cast_double_to_uint(void) { +DUK_LOCAL void duk__selftest_cast_double_to_small_uint(void) { /* * https://github.com/svaarala/duktape/issues/127#issuecomment-77863473 */ @@ -71972,12 +81746,14 @@ DUK_LOCAL void duk__selftest_cast_double_to_uint(void) { duk_double_t d1v, d2v; duk_small_uint_t uv; + /* Test without volatiles */ + d1 = 1.0; u = (duk_small_uint_t) d1; d2 = (duk_double_t) u; if (!(d1 == 1.0 && u == 1 && d2 == 1.0 && d1 == d2)) { - DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double to uint cast failed"); + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double to duk_small_uint_t cast failed"); } /* Same test with volatiles */ @@ -71987,7 +81763,26 @@ DUK_LOCAL void duk__selftest_cast_double_to_uint(void) { d2v = (duk_double_t) uv; if (!(d1v == 1.0 && uv == 1 && d2v == 1.0 && d1v == d2v)) { - DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double to uint cast failed"); + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double to duk_small_uint_t cast failed"); + } +} + +DUK_LOCAL void duk__selftest_cast_double_to_uint32(void) { + /* + * This test fails on an exotic ARM target; double-to-uint + * cast is incorrectly clamped to -signed- int highest value. + * + * https://github.com/svaarala/duktape/issues/336 + */ + + duk_double_t dv; + duk_uint32_t uv; + + dv = 3735928559.0; /* 0xdeadbeef in decimal */ + uv = (duk_uint32_t) dv; + + if (uv != 0xdeadbeefUL) { + DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double to duk_uint32_t cast failed"); } } @@ -72006,7 +81801,8 @@ DUK_INTERNAL void duk_selftest_run_tests(void) { duk__selftest_double_zero_sign(); duk__selftest_struct_align(); duk__selftest_64bit_arithmetic(); - duk__selftest_cast_double_to_uint(); + duk__selftest_cast_double_to_small_uint(); + duk__selftest_cast_double_to_uint32(); } #undef DUK__DBLUNION_CMP_TRUE @@ -72435,6 +82231,5297 @@ const duk_uint8_t duk_unicode_caseconv_lc[616] = { 125,44,109,2,81,44,110,2,113,44,111,2,80,44,112,2,82,167,125,29,121,167, 141,2,101,2,2,97,0,52,129,131,128, }; + +#if defined(DUK_USE_REGEXP_CANON_WORKAROUND) +/* + * Automatically generated by extract_caseconv.py, do not edit! + */ + +const duk_uint16_t duk_unicode_re_canon_lookup[65536] = { +0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27, +28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52, +53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77, +78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,65,66,67,68,69,70, +71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,123,124,125, +126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, +144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161, +162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179, +180,924,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197, +198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215, +216,217,218,219,220,221,222,223,192,193,194,195,196,197,198,199,200,201, +202,203,204,205,206,207,208,209,210,211,212,213,214,247,216,217,218,219, +220,221,222,376,256,256,258,258,260,260,262,262,264,264,266,266,268,268, +270,270,272,272,274,274,276,276,278,278,280,280,282,282,284,284,286,286, +288,288,290,290,292,292,294,294,296,296,298,298,300,300,302,302,304,305, +306,306,308,308,310,310,312,313,313,315,315,317,317,319,319,321,321,323, +323,325,325,327,327,329,330,330,332,332,334,334,336,336,338,338,340,340, +342,342,344,344,346,346,348,348,350,350,352,352,354,354,356,356,358,358, +360,360,362,362,364,364,366,366,368,368,370,370,372,372,374,374,376,377, +377,379,379,381,381,383,579,385,386,386,388,388,390,391,391,393,394,395, +395,397,398,399,400,401,401,403,404,502,406,407,408,408,573,411,412,413, +544,415,416,416,418,418,420,420,422,423,423,425,426,427,428,428,430,431, +431,433,434,435,435,437,437,439,440,440,442,443,444,444,446,503,448,449, +450,451,452,452,452,455,455,455,458,458,458,461,461,463,463,465,465,467, +467,469,469,471,471,473,473,475,475,398,478,478,480,480,482,482,484,484, +486,486,488,488,490,490,492,492,494,494,496,497,497,497,500,500,502,503, +504,504,506,506,508,508,510,510,512,512,514,514,516,516,518,518,520,520, +522,522,524,524,526,526,528,528,530,530,532,532,534,534,536,536,538,538, +540,540,542,542,544,545,546,546,548,548,550,550,552,552,554,554,556,556, +558,558,560,560,562,562,564,565,566,567,568,569,570,571,571,573,574,11390, +11391,577,577,579,580,581,582,582,584,584,586,586,588,588,590,590,11375, +11373,11376,385,390,597,393,394,600,399,602,400,604,605,606,607,403,609, +610,404,612,42893,614,615,407,406,618,11362,620,621,622,412,624,11374,413, +627,628,415,630,631,632,633,634,635,636,11364,638,639,422,641,642,425,644, +645,646,647,430,580,433,434,581,653,654,655,656,657,439,659,660,661,662, +663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680, +681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698, +699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716, +717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734, +735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752, +753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770, +771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788, +789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806, +807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824, +825,826,827,828,829,830,831,832,833,834,835,836,921,838,839,840,841,842, +843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860, +861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878, +879,880,880,882,882,884,885,886,886,888,889,890,1021,1022,1023,894,895,896, +897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914, +915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932, +933,934,935,936,937,938,939,902,904,905,906,944,913,914,915,916,917,918, +919,920,921,922,923,924,925,926,927,928,929,931,931,932,933,934,935,936, +937,938,939,908,910,911,975,914,920,978,979,980,934,928,975,984,984,986, +986,988,988,990,990,992,992,994,994,996,996,998,998,1000,1000,1002,1002, +1004,1004,1006,1006,922,929,1017,1011,1012,917,1014,1015,1015,1017,1018, +1018,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033, +1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048, +1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063, +1064,1065,1066,1067,1068,1069,1070,1071,1040,1041,1042,1043,1044,1045,1046, +1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061, +1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1024,1025,1026,1027,1028, +1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1120,1120,1122,1122, +1124,1124,1126,1126,1128,1128,1130,1130,1132,1132,1134,1134,1136,1136,1138, +1138,1140,1140,1142,1142,1144,1144,1146,1146,1148,1148,1150,1150,1152,1152, +1154,1155,1156,1157,1158,1159,1160,1161,1162,1162,1164,1164,1166,1166,1168, +1168,1170,1170,1172,1172,1174,1174,1176,1176,1178,1178,1180,1180,1182,1182, +1184,1184,1186,1186,1188,1188,1190,1190,1192,1192,1194,1194,1196,1196,1198, +1198,1200,1200,1202,1202,1204,1204,1206,1206,1208,1208,1210,1210,1212,1212, +1214,1214,1216,1217,1217,1219,1219,1221,1221,1223,1223,1225,1225,1227,1227, +1229,1229,1216,1232,1232,1234,1234,1236,1236,1238,1238,1240,1240,1242,1242, +1244,1244,1246,1246,1248,1248,1250,1250,1252,1252,1254,1254,1256,1256,1258, +1258,1260,1260,1262,1262,1264,1264,1266,1266,1268,1268,1270,1270,1272,1272, +1274,1274,1276,1276,1278,1278,1280,1280,1282,1282,1284,1284,1286,1286,1288, +1288,1290,1290,1292,1292,1294,1294,1296,1296,1298,1298,1300,1300,1302,1302, +1304,1304,1306,1306,1308,1308,1310,1310,1312,1312,1314,1314,1316,1316,1318, +1318,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333, +1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348, +1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363, +1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1329,1330, +1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345, +1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360, +1361,1362,1363,1364,1365,1366,1415,1416,1417,1418,1419,1420,1421,1422,1423, +1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438, +1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453, +1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468, +1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483, +1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498, +1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513, +1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528, +1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543, +1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558, +1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573, +1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588, +1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603, +1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618, +1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633, +1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648, +1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663, +1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678, +1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693, +1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708, +1709,1710,1711,1712,1713,1714,1715,1716,1717,1718,1719,1720,1721,1722,1723, +1724,1725,1726,1727,1728,1729,1730,1731,1732,1733,1734,1735,1736,1737,1738, +1739,1740,1741,1742,1743,1744,1745,1746,1747,1748,1749,1750,1751,1752,1753, +1754,1755,1756,1757,1758,1759,1760,1761,1762,1763,1764,1765,1766,1767,1768, +1769,1770,1771,1772,1773,1774,1775,1776,1777,1778,1779,1780,1781,1782,1783, +1784,1785,1786,1787,1788,1789,1790,1791,1792,1793,1794,1795,1796,1797,1798, +1799,1800,1801,1802,1803,1804,1805,1806,1807,1808,1809,1810,1811,1812,1813, +1814,1815,1816,1817,1818,1819,1820,1821,1822,1823,1824,1825,1826,1827,1828, +1829,1830,1831,1832,1833,1834,1835,1836,1837,1838,1839,1840,1841,1842,1843, +1844,1845,1846,1847,1848,1849,1850,1851,1852,1853,1854,1855,1856,1857,1858, +1859,1860,1861,1862,1863,1864,1865,1866,1867,1868,1869,1870,1871,1872,1873, +1874,1875,1876,1877,1878,1879,1880,1881,1882,1883,1884,1885,1886,1887,1888, +1889,1890,1891,1892,1893,1894,1895,1896,1897,1898,1899,1900,1901,1902,1903, +1904,1905,1906,1907,1908,1909,1910,1911,1912,1913,1914,1915,1916,1917,1918, +1919,1920,1921,1922,1923,1924,1925,1926,1927,1928,1929,1930,1931,1932,1933, +1934,1935,1936,1937,1938,1939,1940,1941,1942,1943,1944,1945,1946,1947,1948, +1949,1950,1951,1952,1953,1954,1955,1956,1957,1958,1959,1960,1961,1962,1963, +1964,1965,1966,1967,1968,1969,1970,1971,1972,1973,1974,1975,1976,1977,1978, +1979,1980,1981,1982,1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993, +1994,1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008, +2009,2010,2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021,2022,2023, +2024,2025,2026,2027,2028,2029,2030,2031,2032,2033,2034,2035,2036,2037,2038, +2039,2040,2041,2042,2043,2044,2045,2046,2047,2048,2049,2050,2051,2052,2053, +2054,2055,2056,2057,2058,2059,2060,2061,2062,2063,2064,2065,2066,2067,2068, +2069,2070,2071,2072,2073,2074,2075,2076,2077,2078,2079,2080,2081,2082,2083, +2084,2085,2086,2087,2088,2089,2090,2091,2092,2093,2094,2095,2096,2097,2098, +2099,2100,2101,2102,2103,2104,2105,2106,2107,2108,2109,2110,2111,2112,2113, +2114,2115,2116,2117,2118,2119,2120,2121,2122,2123,2124,2125,2126,2127,2128, +2129,2130,2131,2132,2133,2134,2135,2136,2137,2138,2139,2140,2141,2142,2143, +2144,2145,2146,2147,2148,2149,2150,2151,2152,2153,2154,2155,2156,2157,2158, +2159,2160,2161,2162,2163,2164,2165,2166,2167,2168,2169,2170,2171,2172,2173, +2174,2175,2176,2177,2178,2179,2180,2181,2182,2183,2184,2185,2186,2187,2188, +2189,2190,2191,2192,2193,2194,2195,2196,2197,2198,2199,2200,2201,2202,2203, +2204,2205,2206,2207,2208,2209,2210,2211,2212,2213,2214,2215,2216,2217,2218, +2219,2220,2221,2222,2223,2224,2225,2226,2227,2228,2229,2230,2231,2232,2233, +2234,2235,2236,2237,2238,2239,2240,2241,2242,2243,2244,2245,2246,2247,2248, +2249,2250,2251,2252,2253,2254,2255,2256,2257,2258,2259,2260,2261,2262,2263, +2264,2265,2266,2267,2268,2269,2270,2271,2272,2273,2274,2275,2276,2277,2278, +2279,2280,2281,2282,2283,2284,2285,2286,2287,2288,2289,2290,2291,2292,2293, +2294,2295,2296,2297,2298,2299,2300,2301,2302,2303,2304,2305,2306,2307,2308, +2309,2310,2311,2312,2313,2314,2315,2316,2317,2318,2319,2320,2321,2322,2323, +2324,2325,2326,2327,2328,2329,2330,2331,2332,2333,2334,2335,2336,2337,2338, +2339,2340,2341,2342,2343,2344,2345,2346,2347,2348,2349,2350,2351,2352,2353, +2354,2355,2356,2357,2358,2359,2360,2361,2362,2363,2364,2365,2366,2367,2368, +2369,2370,2371,2372,2373,2374,2375,2376,2377,2378,2379,2380,2381,2382,2383, +2384,2385,2386,2387,2388,2389,2390,2391,2392,2393,2394,2395,2396,2397,2398, +2399,2400,2401,2402,2403,2404,2405,2406,2407,2408,2409,2410,2411,2412,2413, +2414,2415,2416,2417,2418,2419,2420,2421,2422,2423,2424,2425,2426,2427,2428, +2429,2430,2431,2432,2433,2434,2435,2436,2437,2438,2439,2440,2441,2442,2443, +2444,2445,2446,2447,2448,2449,2450,2451,2452,2453,2454,2455,2456,2457,2458, +2459,2460,2461,2462,2463,2464,2465,2466,2467,2468,2469,2470,2471,2472,2473, +2474,2475,2476,2477,2478,2479,2480,2481,2482,2483,2484,2485,2486,2487,2488, +2489,2490,2491,2492,2493,2494,2495,2496,2497,2498,2499,2500,2501,2502,2503, +2504,2505,2506,2507,2508,2509,2510,2511,2512,2513,2514,2515,2516,2517,2518, +2519,2520,2521,2522,2523,2524,2525,2526,2527,2528,2529,2530,2531,2532,2533, +2534,2535,2536,2537,2538,2539,2540,2541,2542,2543,2544,2545,2546,2547,2548, +2549,2550,2551,2552,2553,2554,2555,2556,2557,2558,2559,2560,2561,2562,2563, +2564,2565,2566,2567,2568,2569,2570,2571,2572,2573,2574,2575,2576,2577,2578, +2579,2580,2581,2582,2583,2584,2585,2586,2587,2588,2589,2590,2591,2592,2593, +2594,2595,2596,2597,2598,2599,2600,2601,2602,2603,2604,2605,2606,2607,2608, +2609,2610,2611,2612,2613,2614,2615,2616,2617,2618,2619,2620,2621,2622,2623, +2624,2625,2626,2627,2628,2629,2630,2631,2632,2633,2634,2635,2636,2637,2638, +2639,2640,2641,2642,2643,2644,2645,2646,2647,2648,2649,2650,2651,2652,2653, +2654,2655,2656,2657,2658,2659,2660,2661,2662,2663,2664,2665,2666,2667,2668, +2669,2670,2671,2672,2673,2674,2675,2676,2677,2678,2679,2680,2681,2682,2683, +2684,2685,2686,2687,2688,2689,2690,2691,2692,2693,2694,2695,2696,2697,2698, +2699,2700,2701,2702,2703,2704,2705,2706,2707,2708,2709,2710,2711,2712,2713, +2714,2715,2716,2717,2718,2719,2720,2721,2722,2723,2724,2725,2726,2727,2728, +2729,2730,2731,2732,2733,2734,2735,2736,2737,2738,2739,2740,2741,2742,2743, +2744,2745,2746,2747,2748,2749,2750,2751,2752,2753,2754,2755,2756,2757,2758, +2759,2760,2761,2762,2763,2764,2765,2766,2767,2768,2769,2770,2771,2772,2773, +2774,2775,2776,2777,2778,2779,2780,2781,2782,2783,2784,2785,2786,2787,2788, +2789,2790,2791,2792,2793,2794,2795,2796,2797,2798,2799,2800,2801,2802,2803, +2804,2805,2806,2807,2808,2809,2810,2811,2812,2813,2814,2815,2816,2817,2818, +2819,2820,2821,2822,2823,2824,2825,2826,2827,2828,2829,2830,2831,2832,2833, +2834,2835,2836,2837,2838,2839,2840,2841,2842,2843,2844,2845,2846,2847,2848, +2849,2850,2851,2852,2853,2854,2855,2856,2857,2858,2859,2860,2861,2862,2863, +2864,2865,2866,2867,2868,2869,2870,2871,2872,2873,2874,2875,2876,2877,2878, +2879,2880,2881,2882,2883,2884,2885,2886,2887,2888,2889,2890,2891,2892,2893, +2894,2895,2896,2897,2898,2899,2900,2901,2902,2903,2904,2905,2906,2907,2908, +2909,2910,2911,2912,2913,2914,2915,2916,2917,2918,2919,2920,2921,2922,2923, +2924,2925,2926,2927,2928,2929,2930,2931,2932,2933,2934,2935,2936,2937,2938, +2939,2940,2941,2942,2943,2944,2945,2946,2947,2948,2949,2950,2951,2952,2953, +2954,2955,2956,2957,2958,2959,2960,2961,2962,2963,2964,2965,2966,2967,2968, +2969,2970,2971,2972,2973,2974,2975,2976,2977,2978,2979,2980,2981,2982,2983, +2984,2985,2986,2987,2988,2989,2990,2991,2992,2993,2994,2995,2996,2997,2998, +2999,3000,3001,3002,3003,3004,3005,3006,3007,3008,3009,3010,3011,3012,3013, +3014,3015,3016,3017,3018,3019,3020,3021,3022,3023,3024,3025,3026,3027,3028, +3029,3030,3031,3032,3033,3034,3035,3036,3037,3038,3039,3040,3041,3042,3043, +3044,3045,3046,3047,3048,3049,3050,3051,3052,3053,3054,3055,3056,3057,3058, +3059,3060,3061,3062,3063,3064,3065,3066,3067,3068,3069,3070,3071,3072,3073, +3074,3075,3076,3077,3078,3079,3080,3081,3082,3083,3084,3085,3086,3087,3088, +3089,3090,3091,3092,3093,3094,3095,3096,3097,3098,3099,3100,3101,3102,3103, +3104,3105,3106,3107,3108,3109,3110,3111,3112,3113,3114,3115,3116,3117,3118, +3119,3120,3121,3122,3123,3124,3125,3126,3127,3128,3129,3130,3131,3132,3133, +3134,3135,3136,3137,3138,3139,3140,3141,3142,3143,3144,3145,3146,3147,3148, +3149,3150,3151,3152,3153,3154,3155,3156,3157,3158,3159,3160,3161,3162,3163, +3164,3165,3166,3167,3168,3169,3170,3171,3172,3173,3174,3175,3176,3177,3178, +3179,3180,3181,3182,3183,3184,3185,3186,3187,3188,3189,3190,3191,3192,3193, +3194,3195,3196,3197,3198,3199,3200,3201,3202,3203,3204,3205,3206,3207,3208, +3209,3210,3211,3212,3213,3214,3215,3216,3217,3218,3219,3220,3221,3222,3223, +3224,3225,3226,3227,3228,3229,3230,3231,3232,3233,3234,3235,3236,3237,3238, +3239,3240,3241,3242,3243,3244,3245,3246,3247,3248,3249,3250,3251,3252,3253, +3254,3255,3256,3257,3258,3259,3260,3261,3262,3263,3264,3265,3266,3267,3268, +3269,3270,3271,3272,3273,3274,3275,3276,3277,3278,3279,3280,3281,3282,3283, +3284,3285,3286,3287,3288,3289,3290,3291,3292,3293,3294,3295,3296,3297,3298, +3299,3300,3301,3302,3303,3304,3305,3306,3307,3308,3309,3310,3311,3312,3313, +3314,3315,3316,3317,3318,3319,3320,3321,3322,3323,3324,3325,3326,3327,3328, +3329,3330,3331,3332,3333,3334,3335,3336,3337,3338,3339,3340,3341,3342,3343, +3344,3345,3346,3347,3348,3349,3350,3351,3352,3353,3354,3355,3356,3357,3358, +3359,3360,3361,3362,3363,3364,3365,3366,3367,3368,3369,3370,3371,3372,3373, +3374,3375,3376,3377,3378,3379,3380,3381,3382,3383,3384,3385,3386,3387,3388, +3389,3390,3391,3392,3393,3394,3395,3396,3397,3398,3399,3400,3401,3402,3403, +3404,3405,3406,3407,3408,3409,3410,3411,3412,3413,3414,3415,3416,3417,3418, +3419,3420,3421,3422,3423,3424,3425,3426,3427,3428,3429,3430,3431,3432,3433, +3434,3435,3436,3437,3438,3439,3440,3441,3442,3443,3444,3445,3446,3447,3448, +3449,3450,3451,3452,3453,3454,3455,3456,3457,3458,3459,3460,3461,3462,3463, +3464,3465,3466,3467,3468,3469,3470,3471,3472,3473,3474,3475,3476,3477,3478, +3479,3480,3481,3482,3483,3484,3485,3486,3487,3488,3489,3490,3491,3492,3493, +3494,3495,3496,3497,3498,3499,3500,3501,3502,3503,3504,3505,3506,3507,3508, +3509,3510,3511,3512,3513,3514,3515,3516,3517,3518,3519,3520,3521,3522,3523, +3524,3525,3526,3527,3528,3529,3530,3531,3532,3533,3534,3535,3536,3537,3538, +3539,3540,3541,3542,3543,3544,3545,3546,3547,3548,3549,3550,3551,3552,3553, +3554,3555,3556,3557,3558,3559,3560,3561,3562,3563,3564,3565,3566,3567,3568, +3569,3570,3571,3572,3573,3574,3575,3576,3577,3578,3579,3580,3581,3582,3583, +3584,3585,3586,3587,3588,3589,3590,3591,3592,3593,3594,3595,3596,3597,3598, +3599,3600,3601,3602,3603,3604,3605,3606,3607,3608,3609,3610,3611,3612,3613, +3614,3615,3616,3617,3618,3619,3620,3621,3622,3623,3624,3625,3626,3627,3628, +3629,3630,3631,3632,3633,3634,3635,3636,3637,3638,3639,3640,3641,3642,3643, +3644,3645,3646,3647,3648,3649,3650,3651,3652,3653,3654,3655,3656,3657,3658, +3659,3660,3661,3662,3663,3664,3665,3666,3667,3668,3669,3670,3671,3672,3673, +3674,3675,3676,3677,3678,3679,3680,3681,3682,3683,3684,3685,3686,3687,3688, +3689,3690,3691,3692,3693,3694,3695,3696,3697,3698,3699,3700,3701,3702,3703, +3704,3705,3706,3707,3708,3709,3710,3711,3712,3713,3714,3715,3716,3717,3718, +3719,3720,3721,3722,3723,3724,3725,3726,3727,3728,3729,3730,3731,3732,3733, +3734,3735,3736,3737,3738,3739,3740,3741,3742,3743,3744,3745,3746,3747,3748, +3749,3750,3751,3752,3753,3754,3755,3756,3757,3758,3759,3760,3761,3762,3763, +3764,3765,3766,3767,3768,3769,3770,3771,3772,3773,3774,3775,3776,3777,3778, +3779,3780,3781,3782,3783,3784,3785,3786,3787,3788,3789,3790,3791,3792,3793, +3794,3795,3796,3797,3798,3799,3800,3801,3802,3803,3804,3805,3806,3807,3808, +3809,3810,3811,3812,3813,3814,3815,3816,3817,3818,3819,3820,3821,3822,3823, +3824,3825,3826,3827,3828,3829,3830,3831,3832,3833,3834,3835,3836,3837,3838, +3839,3840,3841,3842,3843,3844,3845,3846,3847,3848,3849,3850,3851,3852,3853, +3854,3855,3856,3857,3858,3859,3860,3861,3862,3863,3864,3865,3866,3867,3868, +3869,3870,3871,3872,3873,3874,3875,3876,3877,3878,3879,3880,3881,3882,3883, +3884,3885,3886,3887,3888,3889,3890,3891,3892,3893,3894,3895,3896,3897,3898, +3899,3900,3901,3902,3903,3904,3905,3906,3907,3908,3909,3910,3911,3912,3913, +3914,3915,3916,3917,3918,3919,3920,3921,3922,3923,3924,3925,3926,3927,3928, +3929,3930,3931,3932,3933,3934,3935,3936,3937,3938,3939,3940,3941,3942,3943, +3944,3945,3946,3947,3948,3949,3950,3951,3952,3953,3954,3955,3956,3957,3958, +3959,3960,3961,3962,3963,3964,3965,3966,3967,3968,3969,3970,3971,3972,3973, +3974,3975,3976,3977,3978,3979,3980,3981,3982,3983,3984,3985,3986,3987,3988, +3989,3990,3991,3992,3993,3994,3995,3996,3997,3998,3999,4000,4001,4002,4003, +4004,4005,4006,4007,4008,4009,4010,4011,4012,4013,4014,4015,4016,4017,4018, +4019,4020,4021,4022,4023,4024,4025,4026,4027,4028,4029,4030,4031,4032,4033, +4034,4035,4036,4037,4038,4039,4040,4041,4042,4043,4044,4045,4046,4047,4048, +4049,4050,4051,4052,4053,4054,4055,4056,4057,4058,4059,4060,4061,4062,4063, +4064,4065,4066,4067,4068,4069,4070,4071,4072,4073,4074,4075,4076,4077,4078, +4079,4080,4081,4082,4083,4084,4085,4086,4087,4088,4089,4090,4091,4092,4093, +4094,4095,4096,4097,4098,4099,4100,4101,4102,4103,4104,4105,4106,4107,4108, +4109,4110,4111,4112,4113,4114,4115,4116,4117,4118,4119,4120,4121,4122,4123, +4124,4125,4126,4127,4128,4129,4130,4131,4132,4133,4134,4135,4136,4137,4138, +4139,4140,4141,4142,4143,4144,4145,4146,4147,4148,4149,4150,4151,4152,4153, +4154,4155,4156,4157,4158,4159,4160,4161,4162,4163,4164,4165,4166,4167,4168, +4169,4170,4171,4172,4173,4174,4175,4176,4177,4178,4179,4180,4181,4182,4183, +4184,4185,4186,4187,4188,4189,4190,4191,4192,4193,4194,4195,4196,4197,4198, +4199,4200,4201,4202,4203,4204,4205,4206,4207,4208,4209,4210,4211,4212,4213, +4214,4215,4216,4217,4218,4219,4220,4221,4222,4223,4224,4225,4226,4227,4228, +4229,4230,4231,4232,4233,4234,4235,4236,4237,4238,4239,4240,4241,4242,4243, +4244,4245,4246,4247,4248,4249,4250,4251,4252,4253,4254,4255,4256,4257,4258, +4259,4260,4261,4262,4263,4264,4265,4266,4267,4268,4269,4270,4271,4272,4273, +4274,4275,4276,4277,4278,4279,4280,4281,4282,4283,4284,4285,4286,4287,4288, +4289,4290,4291,4292,4293,4294,4295,4296,4297,4298,4299,4300,4301,4302,4303, +4304,4305,4306,4307,4308,4309,4310,4311,4312,4313,4314,4315,4316,4317,4318, +4319,4320,4321,4322,4323,4324,4325,4326,4327,4328,4329,4330,4331,4332,4333, +4334,4335,4336,4337,4338,4339,4340,4341,4342,4343,4344,4345,4346,4347,4348, +4349,4350,4351,4352,4353,4354,4355,4356,4357,4358,4359,4360,4361,4362,4363, +4364,4365,4366,4367,4368,4369,4370,4371,4372,4373,4374,4375,4376,4377,4378, +4379,4380,4381,4382,4383,4384,4385,4386,4387,4388,4389,4390,4391,4392,4393, +4394,4395,4396,4397,4398,4399,4400,4401,4402,4403,4404,4405,4406,4407,4408, +4409,4410,4411,4412,4413,4414,4415,4416,4417,4418,4419,4420,4421,4422,4423, +4424,4425,4426,4427,4428,4429,4430,4431,4432,4433,4434,4435,4436,4437,4438, +4439,4440,4441,4442,4443,4444,4445,4446,4447,4448,4449,4450,4451,4452,4453, +4454,4455,4456,4457,4458,4459,4460,4461,4462,4463,4464,4465,4466,4467,4468, +4469,4470,4471,4472,4473,4474,4475,4476,4477,4478,4479,4480,4481,4482,4483, +4484,4485,4486,4487,4488,4489,4490,4491,4492,4493,4494,4495,4496,4497,4498, +4499,4500,4501,4502,4503,4504,4505,4506,4507,4508,4509,4510,4511,4512,4513, +4514,4515,4516,4517,4518,4519,4520,4521,4522,4523,4524,4525,4526,4527,4528, +4529,4530,4531,4532,4533,4534,4535,4536,4537,4538,4539,4540,4541,4542,4543, +4544,4545,4546,4547,4548,4549,4550,4551,4552,4553,4554,4555,4556,4557,4558, +4559,4560,4561,4562,4563,4564,4565,4566,4567,4568,4569,4570,4571,4572,4573, +4574,4575,4576,4577,4578,4579,4580,4581,4582,4583,4584,4585,4586,4587,4588, +4589,4590,4591,4592,4593,4594,4595,4596,4597,4598,4599,4600,4601,4602,4603, +4604,4605,4606,4607,4608,4609,4610,4611,4612,4613,4614,4615,4616,4617,4618, +4619,4620,4621,4622,4623,4624,4625,4626,4627,4628,4629,4630,4631,4632,4633, +4634,4635,4636,4637,4638,4639,4640,4641,4642,4643,4644,4645,4646,4647,4648, +4649,4650,4651,4652,4653,4654,4655,4656,4657,4658,4659,4660,4661,4662,4663, +4664,4665,4666,4667,4668,4669,4670,4671,4672,4673,4674,4675,4676,4677,4678, +4679,4680,4681,4682,4683,4684,4685,4686,4687,4688,4689,4690,4691,4692,4693, +4694,4695,4696,4697,4698,4699,4700,4701,4702,4703,4704,4705,4706,4707,4708, +4709,4710,4711,4712,4713,4714,4715,4716,4717,4718,4719,4720,4721,4722,4723, +4724,4725,4726,4727,4728,4729,4730,4731,4732,4733,4734,4735,4736,4737,4738, +4739,4740,4741,4742,4743,4744,4745,4746,4747,4748,4749,4750,4751,4752,4753, +4754,4755,4756,4757,4758,4759,4760,4761,4762,4763,4764,4765,4766,4767,4768, +4769,4770,4771,4772,4773,4774,4775,4776,4777,4778,4779,4780,4781,4782,4783, +4784,4785,4786,4787,4788,4789,4790,4791,4792,4793,4794,4795,4796,4797,4798, +4799,4800,4801,4802,4803,4804,4805,4806,4807,4808,4809,4810,4811,4812,4813, +4814,4815,4816,4817,4818,4819,4820,4821,4822,4823,4824,4825,4826,4827,4828, +4829,4830,4831,4832,4833,4834,4835,4836,4837,4838,4839,4840,4841,4842,4843, +4844,4845,4846,4847,4848,4849,4850,4851,4852,4853,4854,4855,4856,4857,4858, +4859,4860,4861,4862,4863,4864,4865,4866,4867,4868,4869,4870,4871,4872,4873, +4874,4875,4876,4877,4878,4879,4880,4881,4882,4883,4884,4885,4886,4887,4888, +4889,4890,4891,4892,4893,4894,4895,4896,4897,4898,4899,4900,4901,4902,4903, +4904,4905,4906,4907,4908,4909,4910,4911,4912,4913,4914,4915,4916,4917,4918, +4919,4920,4921,4922,4923,4924,4925,4926,4927,4928,4929,4930,4931,4932,4933, +4934,4935,4936,4937,4938,4939,4940,4941,4942,4943,4944,4945,4946,4947,4948, +4949,4950,4951,4952,4953,4954,4955,4956,4957,4958,4959,4960,4961,4962,4963, +4964,4965,4966,4967,4968,4969,4970,4971,4972,4973,4974,4975,4976,4977,4978, +4979,4980,4981,4982,4983,4984,4985,4986,4987,4988,4989,4990,4991,4992,4993, +4994,4995,4996,4997,4998,4999,5000,5001,5002,5003,5004,5005,5006,5007,5008, +5009,5010,5011,5012,5013,5014,5015,5016,5017,5018,5019,5020,5021,5022,5023, +5024,5025,5026,5027,5028,5029,5030,5031,5032,5033,5034,5035,5036,5037,5038, +5039,5040,5041,5042,5043,5044,5045,5046,5047,5048,5049,5050,5051,5052,5053, +5054,5055,5056,5057,5058,5059,5060,5061,5062,5063,5064,5065,5066,5067,5068, +5069,5070,5071,5072,5073,5074,5075,5076,5077,5078,5079,5080,5081,5082,5083, +5084,5085,5086,5087,5088,5089,5090,5091,5092,5093,5094,5095,5096,5097,5098, +5099,5100,5101,5102,5103,5104,5105,5106,5107,5108,5109,5110,5111,5112,5113, +5114,5115,5116,5117,5118,5119,5120,5121,5122,5123,5124,5125,5126,5127,5128, +5129,5130,5131,5132,5133,5134,5135,5136,5137,5138,5139,5140,5141,5142,5143, +5144,5145,5146,5147,5148,5149,5150,5151,5152,5153,5154,5155,5156,5157,5158, +5159,5160,5161,5162,5163,5164,5165,5166,5167,5168,5169,5170,5171,5172,5173, +5174,5175,5176,5177,5178,5179,5180,5181,5182,5183,5184,5185,5186,5187,5188, +5189,5190,5191,5192,5193,5194,5195,5196,5197,5198,5199,5200,5201,5202,5203, +5204,5205,5206,5207,5208,5209,5210,5211,5212,5213,5214,5215,5216,5217,5218, +5219,5220,5221,5222,5223,5224,5225,5226,5227,5228,5229,5230,5231,5232,5233, +5234,5235,5236,5237,5238,5239,5240,5241,5242,5243,5244,5245,5246,5247,5248, +5249,5250,5251,5252,5253,5254,5255,5256,5257,5258,5259,5260,5261,5262,5263, +5264,5265,5266,5267,5268,5269,5270,5271,5272,5273,5274,5275,5276,5277,5278, +5279,5280,5281,5282,5283,5284,5285,5286,5287,5288,5289,5290,5291,5292,5293, +5294,5295,5296,5297,5298,5299,5300,5301,5302,5303,5304,5305,5306,5307,5308, +5309,5310,5311,5312,5313,5314,5315,5316,5317,5318,5319,5320,5321,5322,5323, +5324,5325,5326,5327,5328,5329,5330,5331,5332,5333,5334,5335,5336,5337,5338, +5339,5340,5341,5342,5343,5344,5345,5346,5347,5348,5349,5350,5351,5352,5353, +5354,5355,5356,5357,5358,5359,5360,5361,5362,5363,5364,5365,5366,5367,5368, +5369,5370,5371,5372,5373,5374,5375,5376,5377,5378,5379,5380,5381,5382,5383, +5384,5385,5386,5387,5388,5389,5390,5391,5392,5393,5394,5395,5396,5397,5398, +5399,5400,5401,5402,5403,5404,5405,5406,5407,5408,5409,5410,5411,5412,5413, +5414,5415,5416,5417,5418,5419,5420,5421,5422,5423,5424,5425,5426,5427,5428, +5429,5430,5431,5432,5433,5434,5435,5436,5437,5438,5439,5440,5441,5442,5443, +5444,5445,5446,5447,5448,5449,5450,5451,5452,5453,5454,5455,5456,5457,5458, +5459,5460,5461,5462,5463,5464,5465,5466,5467,5468,5469,5470,5471,5472,5473, +5474,5475,5476,5477,5478,5479,5480,5481,5482,5483,5484,5485,5486,5487,5488, +5489,5490,5491,5492,5493,5494,5495,5496,5497,5498,5499,5500,5501,5502,5503, +5504,5505,5506,5507,5508,5509,5510,5511,5512,5513,5514,5515,5516,5517,5518, +5519,5520,5521,5522,5523,5524,5525,5526,5527,5528,5529,5530,5531,5532,5533, +5534,5535,5536,5537,5538,5539,5540,5541,5542,5543,5544,5545,5546,5547,5548, +5549,5550,5551,5552,5553,5554,5555,5556,5557,5558,5559,5560,5561,5562,5563, +5564,5565,5566,5567,5568,5569,5570,5571,5572,5573,5574,5575,5576,5577,5578, +5579,5580,5581,5582,5583,5584,5585,5586,5587,5588,5589,5590,5591,5592,5593, +5594,5595,5596,5597,5598,5599,5600,5601,5602,5603,5604,5605,5606,5607,5608, +5609,5610,5611,5612,5613,5614,5615,5616,5617,5618,5619,5620,5621,5622,5623, +5624,5625,5626,5627,5628,5629,5630,5631,5632,5633,5634,5635,5636,5637,5638, +5639,5640,5641,5642,5643,5644,5645,5646,5647,5648,5649,5650,5651,5652,5653, +5654,5655,5656,5657,5658,5659,5660,5661,5662,5663,5664,5665,5666,5667,5668, +5669,5670,5671,5672,5673,5674,5675,5676,5677,5678,5679,5680,5681,5682,5683, +5684,5685,5686,5687,5688,5689,5690,5691,5692,5693,5694,5695,5696,5697,5698, +5699,5700,5701,5702,5703,5704,5705,5706,5707,5708,5709,5710,5711,5712,5713, +5714,5715,5716,5717,5718,5719,5720,5721,5722,5723,5724,5725,5726,5727,5728, +5729,5730,5731,5732,5733,5734,5735,5736,5737,5738,5739,5740,5741,5742,5743, +5744,5745,5746,5747,5748,5749,5750,5751,5752,5753,5754,5755,5756,5757,5758, +5759,5760,5761,5762,5763,5764,5765,5766,5767,5768,5769,5770,5771,5772,5773, +5774,5775,5776,5777,5778,5779,5780,5781,5782,5783,5784,5785,5786,5787,5788, +5789,5790,5791,5792,5793,5794,5795,5796,5797,5798,5799,5800,5801,5802,5803, +5804,5805,5806,5807,5808,5809,5810,5811,5812,5813,5814,5815,5816,5817,5818, +5819,5820,5821,5822,5823,5824,5825,5826,5827,5828,5829,5830,5831,5832,5833, +5834,5835,5836,5837,5838,5839,5840,5841,5842,5843,5844,5845,5846,5847,5848, +5849,5850,5851,5852,5853,5854,5855,5856,5857,5858,5859,5860,5861,5862,5863, +5864,5865,5866,5867,5868,5869,5870,5871,5872,5873,5874,5875,5876,5877,5878, +5879,5880,5881,5882,5883,5884,5885,5886,5887,5888,5889,5890,5891,5892,5893, +5894,5895,5896,5897,5898,5899,5900,5901,5902,5903,5904,5905,5906,5907,5908, +5909,5910,5911,5912,5913,5914,5915,5916,5917,5918,5919,5920,5921,5922,5923, +5924,5925,5926,5927,5928,5929,5930,5931,5932,5933,5934,5935,5936,5937,5938, +5939,5940,5941,5942,5943,5944,5945,5946,5947,5948,5949,5950,5951,5952,5953, +5954,5955,5956,5957,5958,5959,5960,5961,5962,5963,5964,5965,5966,5967,5968, +5969,5970,5971,5972,5973,5974,5975,5976,5977,5978,5979,5980,5981,5982,5983, +5984,5985,5986,5987,5988,5989,5990,5991,5992,5993,5994,5995,5996,5997,5998, +5999,6000,6001,6002,6003,6004,6005,6006,6007,6008,6009,6010,6011,6012,6013, +6014,6015,6016,6017,6018,6019,6020,6021,6022,6023,6024,6025,6026,6027,6028, +6029,6030,6031,6032,6033,6034,6035,6036,6037,6038,6039,6040,6041,6042,6043, +6044,6045,6046,6047,6048,6049,6050,6051,6052,6053,6054,6055,6056,6057,6058, +6059,6060,6061,6062,6063,6064,6065,6066,6067,6068,6069,6070,6071,6072,6073, +6074,6075,6076,6077,6078,6079,6080,6081,6082,6083,6084,6085,6086,6087,6088, +6089,6090,6091,6092,6093,6094,6095,6096,6097,6098,6099,6100,6101,6102,6103, +6104,6105,6106,6107,6108,6109,6110,6111,6112,6113,6114,6115,6116,6117,6118, +6119,6120,6121,6122,6123,6124,6125,6126,6127,6128,6129,6130,6131,6132,6133, +6134,6135,6136,6137,6138,6139,6140,6141,6142,6143,6144,6145,6146,6147,6148, +6149,6150,6151,6152,6153,6154,6155,6156,6157,6158,6159,6160,6161,6162,6163, +6164,6165,6166,6167,6168,6169,6170,6171,6172,6173,6174,6175,6176,6177,6178, +6179,6180,6181,6182,6183,6184,6185,6186,6187,6188,6189,6190,6191,6192,6193, +6194,6195,6196,6197,6198,6199,6200,6201,6202,6203,6204,6205,6206,6207,6208, +6209,6210,6211,6212,6213,6214,6215,6216,6217,6218,6219,6220,6221,6222,6223, +6224,6225,6226,6227,6228,6229,6230,6231,6232,6233,6234,6235,6236,6237,6238, +6239,6240,6241,6242,6243,6244,6245,6246,6247,6248,6249,6250,6251,6252,6253, +6254,6255,6256,6257,6258,6259,6260,6261,6262,6263,6264,6265,6266,6267,6268, +6269,6270,6271,6272,6273,6274,6275,6276,6277,6278,6279,6280,6281,6282,6283, +6284,6285,6286,6287,6288,6289,6290,6291,6292,6293,6294,6295,6296,6297,6298, +6299,6300,6301,6302,6303,6304,6305,6306,6307,6308,6309,6310,6311,6312,6313, +6314,6315,6316,6317,6318,6319,6320,6321,6322,6323,6324,6325,6326,6327,6328, +6329,6330,6331,6332,6333,6334,6335,6336,6337,6338,6339,6340,6341,6342,6343, +6344,6345,6346,6347,6348,6349,6350,6351,6352,6353,6354,6355,6356,6357,6358, +6359,6360,6361,6362,6363,6364,6365,6366,6367,6368,6369,6370,6371,6372,6373, +6374,6375,6376,6377,6378,6379,6380,6381,6382,6383,6384,6385,6386,6387,6388, +6389,6390,6391,6392,6393,6394,6395,6396,6397,6398,6399,6400,6401,6402,6403, +6404,6405,6406,6407,6408,6409,6410,6411,6412,6413,6414,6415,6416,6417,6418, +6419,6420,6421,6422,6423,6424,6425,6426,6427,6428,6429,6430,6431,6432,6433, +6434,6435,6436,6437,6438,6439,6440,6441,6442,6443,6444,6445,6446,6447,6448, +6449,6450,6451,6452,6453,6454,6455,6456,6457,6458,6459,6460,6461,6462,6463, +6464,6465,6466,6467,6468,6469,6470,6471,6472,6473,6474,6475,6476,6477,6478, +6479,6480,6481,6482,6483,6484,6485,6486,6487,6488,6489,6490,6491,6492,6493, +6494,6495,6496,6497,6498,6499,6500,6501,6502,6503,6504,6505,6506,6507,6508, +6509,6510,6511,6512,6513,6514,6515,6516,6517,6518,6519,6520,6521,6522,6523, +6524,6525,6526,6527,6528,6529,6530,6531,6532,6533,6534,6535,6536,6537,6538, +6539,6540,6541,6542,6543,6544,6545,6546,6547,6548,6549,6550,6551,6552,6553, +6554,6555,6556,6557,6558,6559,6560,6561,6562,6563,6564,6565,6566,6567,6568, +6569,6570,6571,6572,6573,6574,6575,6576,6577,6578,6579,6580,6581,6582,6583, +6584,6585,6586,6587,6588,6589,6590,6591,6592,6593,6594,6595,6596,6597,6598, +6599,6600,6601,6602,6603,6604,6605,6606,6607,6608,6609,6610,6611,6612,6613, +6614,6615,6616,6617,6618,6619,6620,6621,6622,6623,6624,6625,6626,6627,6628, +6629,6630,6631,6632,6633,6634,6635,6636,6637,6638,6639,6640,6641,6642,6643, +6644,6645,6646,6647,6648,6649,6650,6651,6652,6653,6654,6655,6656,6657,6658, +6659,6660,6661,6662,6663,6664,6665,6666,6667,6668,6669,6670,6671,6672,6673, +6674,6675,6676,6677,6678,6679,6680,6681,6682,6683,6684,6685,6686,6687,6688, +6689,6690,6691,6692,6693,6694,6695,6696,6697,6698,6699,6700,6701,6702,6703, +6704,6705,6706,6707,6708,6709,6710,6711,6712,6713,6714,6715,6716,6717,6718, +6719,6720,6721,6722,6723,6724,6725,6726,6727,6728,6729,6730,6731,6732,6733, +6734,6735,6736,6737,6738,6739,6740,6741,6742,6743,6744,6745,6746,6747,6748, +6749,6750,6751,6752,6753,6754,6755,6756,6757,6758,6759,6760,6761,6762,6763, +6764,6765,6766,6767,6768,6769,6770,6771,6772,6773,6774,6775,6776,6777,6778, +6779,6780,6781,6782,6783,6784,6785,6786,6787,6788,6789,6790,6791,6792,6793, +6794,6795,6796,6797,6798,6799,6800,6801,6802,6803,6804,6805,6806,6807,6808, +6809,6810,6811,6812,6813,6814,6815,6816,6817,6818,6819,6820,6821,6822,6823, +6824,6825,6826,6827,6828,6829,6830,6831,6832,6833,6834,6835,6836,6837,6838, +6839,6840,6841,6842,6843,6844,6845,6846,6847,6848,6849,6850,6851,6852,6853, +6854,6855,6856,6857,6858,6859,6860,6861,6862,6863,6864,6865,6866,6867,6868, +6869,6870,6871,6872,6873,6874,6875,6876,6877,6878,6879,6880,6881,6882,6883, +6884,6885,6886,6887,6888,6889,6890,6891,6892,6893,6894,6895,6896,6897,6898, +6899,6900,6901,6902,6903,6904,6905,6906,6907,6908,6909,6910,6911,6912,6913, +6914,6915,6916,6917,6918,6919,6920,6921,6922,6923,6924,6925,6926,6927,6928, +6929,6930,6931,6932,6933,6934,6935,6936,6937,6938,6939,6940,6941,6942,6943, +6944,6945,6946,6947,6948,6949,6950,6951,6952,6953,6954,6955,6956,6957,6958, +6959,6960,6961,6962,6963,6964,6965,6966,6967,6968,6969,6970,6971,6972,6973, +6974,6975,6976,6977,6978,6979,6980,6981,6982,6983,6984,6985,6986,6987,6988, +6989,6990,6991,6992,6993,6994,6995,6996,6997,6998,6999,7000,7001,7002,7003, +7004,7005,7006,7007,7008,7009,7010,7011,7012,7013,7014,7015,7016,7017,7018, +7019,7020,7021,7022,7023,7024,7025,7026,7027,7028,7029,7030,7031,7032,7033, +7034,7035,7036,7037,7038,7039,7040,7041,7042,7043,7044,7045,7046,7047,7048, +7049,7050,7051,7052,7053,7054,7055,7056,7057,7058,7059,7060,7061,7062,7063, +7064,7065,7066,7067,7068,7069,7070,7071,7072,7073,7074,7075,7076,7077,7078, +7079,7080,7081,7082,7083,7084,7085,7086,7087,7088,7089,7090,7091,7092,7093, +7094,7095,7096,7097,7098,7099,7100,7101,7102,7103,7104,7105,7106,7107,7108, +7109,7110,7111,7112,7113,7114,7115,7116,7117,7118,7119,7120,7121,7122,7123, +7124,7125,7126,7127,7128,7129,7130,7131,7132,7133,7134,7135,7136,7137,7138, +7139,7140,7141,7142,7143,7144,7145,7146,7147,7148,7149,7150,7151,7152,7153, +7154,7155,7156,7157,7158,7159,7160,7161,7162,7163,7164,7165,7166,7167,7168, +7169,7170,7171,7172,7173,7174,7175,7176,7177,7178,7179,7180,7181,7182,7183, +7184,7185,7186,7187,7188,7189,7190,7191,7192,7193,7194,7195,7196,7197,7198, +7199,7200,7201,7202,7203,7204,7205,7206,7207,7208,7209,7210,7211,7212,7213, +7214,7215,7216,7217,7218,7219,7220,7221,7222,7223,7224,7225,7226,7227,7228, +7229,7230,7231,7232,7233,7234,7235,7236,7237,7238,7239,7240,7241,7242,7243, +7244,7245,7246,7247,7248,7249,7250,7251,7252,7253,7254,7255,7256,7257,7258, +7259,7260,7261,7262,7263,7264,7265,7266,7267,7268,7269,7270,7271,7272,7273, +7274,7275,7276,7277,7278,7279,7280,7281,7282,7283,7284,7285,7286,7287,7288, +7289,7290,7291,7292,7293,7294,7295,7296,7297,7298,7299,7300,7301,7302,7303, +7304,7305,7306,7307,7308,7309,7310,7311,7312,7313,7314,7315,7316,7317,7318, +7319,7320,7321,7322,7323,7324,7325,7326,7327,7328,7329,7330,7331,7332,7333, +7334,7335,7336,7337,7338,7339,7340,7341,7342,7343,7344,7345,7346,7347,7348, +7349,7350,7351,7352,7353,7354,7355,7356,7357,7358,7359,7360,7361,7362,7363, +7364,7365,7366,7367,7368,7369,7370,7371,7372,7373,7374,7375,7376,7377,7378, +7379,7380,7381,7382,7383,7384,7385,7386,7387,7388,7389,7390,7391,7392,7393, +7394,7395,7396,7397,7398,7399,7400,7401,7402,7403,7404,7405,7406,7407,7408, +7409,7410,7411,7412,7413,7414,7415,7416,7417,7418,7419,7420,7421,7422,7423, +7424,7425,7426,7427,7428,7429,7430,7431,7432,7433,7434,7435,7436,7437,7438, +7439,7440,7441,7442,7443,7444,7445,7446,7447,7448,7449,7450,7451,7452,7453, +7454,7455,7456,7457,7458,7459,7460,7461,7462,7463,7464,7465,7466,7467,7468, +7469,7470,7471,7472,7473,7474,7475,7476,7477,7478,7479,7480,7481,7482,7483, +7484,7485,7486,7487,7488,7489,7490,7491,7492,7493,7494,7495,7496,7497,7498, +7499,7500,7501,7502,7503,7504,7505,7506,7507,7508,7509,7510,7511,7512,7513, +7514,7515,7516,7517,7518,7519,7520,7521,7522,7523,7524,7525,7526,7527,7528, +7529,7530,7531,7532,7533,7534,7535,7536,7537,7538,7539,7540,7541,7542,7543, +7544,42877,7546,7547,7548,11363,7550,7551,7552,7553,7554,7555,7556,7557, +7558,7559,7560,7561,7562,7563,7564,7565,7566,7567,7568,7569,7570,7571,7572, +7573,7574,7575,7576,7577,7578,7579,7580,7581,7582,7583,7584,7585,7586,7587, +7588,7589,7590,7591,7592,7593,7594,7595,7596,7597,7598,7599,7600,7601,7602, +7603,7604,7605,7606,7607,7608,7609,7610,7611,7612,7613,7614,7615,7616,7617, +7618,7619,7620,7621,7622,7623,7624,7625,7626,7627,7628,7629,7630,7631,7632, +7633,7634,7635,7636,7637,7638,7639,7640,7641,7642,7643,7644,7645,7646,7647, +7648,7649,7650,7651,7652,7653,7654,7655,7656,7657,7658,7659,7660,7661,7662, +7663,7664,7665,7666,7667,7668,7669,7670,7671,7672,7673,7674,7675,7676,7677, +7678,7679,7680,7680,7682,7682,7684,7684,7686,7686,7688,7688,7690,7690,7692, +7692,7694,7694,7696,7696,7698,7698,7700,7700,7702,7702,7704,7704,7706,7706, +7708,7708,7710,7710,7712,7712,7714,7714,7716,7716,7718,7718,7720,7720,7722, +7722,7724,7724,7726,7726,7728,7728,7730,7730,7732,7732,7734,7734,7736,7736, +7738,7738,7740,7740,7742,7742,7744,7744,7746,7746,7748,7748,7750,7750,7752, +7752,7754,7754,7756,7756,7758,7758,7760,7760,7762,7762,7764,7764,7766,7766, +7768,7768,7770,7770,7772,7772,7774,7774,7776,7776,7778,7778,7780,7780,7782, +7782,7784,7784,7786,7786,7788,7788,7790,7790,7792,7792,7794,7794,7796,7796, +7798,7798,7800,7800,7802,7802,7804,7804,7806,7806,7808,7808,7810,7810,7812, +7812,7814,7814,7816,7816,7818,7818,7820,7820,7822,7822,7824,7824,7826,7826, +7828,7828,7830,7831,7832,7833,7834,7776,7836,7837,7838,7839,7840,7840,7842, +7842,7844,7844,7846,7846,7848,7848,7850,7850,7852,7852,7854,7854,7856,7856, +7858,7858,7860,7860,7862,7862,7864,7864,7866,7866,7868,7868,7870,7870,7872, +7872,7874,7874,7876,7876,7878,7878,7880,7880,7882,7882,7884,7884,7886,7886, +7888,7888,7890,7890,7892,7892,7894,7894,7896,7896,7898,7898,7900,7900,7902, +7902,7904,7904,7906,7906,7908,7908,7910,7910,7912,7912,7914,7914,7916,7916, +7918,7918,7920,7920,7922,7922,7924,7924,7926,7926,7928,7928,7930,7930,7932, +7932,7934,7934,7944,7945,7946,7947,7948,7949,7950,7951,7944,7945,7946,7947, +7948,7949,7950,7951,7960,7961,7962,7963,7964,7965,7958,7959,7960,7961,7962, +7963,7964,7965,7966,7967,7976,7977,7978,7979,7980,7981,7982,7983,7976,7977, +7978,7979,7980,7981,7982,7983,7992,7993,7994,7995,7996,7997,7998,7999,7992, +7993,7994,7995,7996,7997,7998,7999,8008,8009,8010,8011,8012,8013,8006,8007, +8008,8009,8010,8011,8012,8013,8014,8015,8016,8025,8018,8027,8020,8029,8022, +8031,8024,8025,8026,8027,8028,8029,8030,8031,8040,8041,8042,8043,8044,8045, +8046,8047,8040,8041,8042,8043,8044,8045,8046,8047,8122,8123,8136,8137,8138, +8139,8154,8155,8184,8185,8170,8171,8186,8187,8062,8063,8064,8065,8066,8067, +8068,8069,8070,8071,8072,8073,8074,8075,8076,8077,8078,8079,8080,8081,8082, +8083,8084,8085,8086,8087,8088,8089,8090,8091,8092,8093,8094,8095,8096,8097, +8098,8099,8100,8101,8102,8103,8104,8105,8106,8107,8108,8109,8110,8111,8120, +8121,8114,8115,8116,8117,8118,8119,8120,8121,8122,8123,8124,8125,921,8127, +8128,8129,8130,8131,8132,8133,8134,8135,8136,8137,8138,8139,8140,8141,8142, +8143,8152,8153,8146,8147,8148,8149,8150,8151,8152,8153,8154,8155,8156,8157, +8158,8159,8168,8169,8162,8163,8164,8172,8166,8167,8168,8169,8170,8171,8172, +8173,8174,8175,8176,8177,8178,8179,8180,8181,8182,8183,8184,8185,8186,8187, +8188,8189,8190,8191,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202, +8203,8204,8205,8206,8207,8208,8209,8210,8211,8212,8213,8214,8215,8216,8217, +8218,8219,8220,8221,8222,8223,8224,8225,8226,8227,8228,8229,8230,8231,8232, +8233,8234,8235,8236,8237,8238,8239,8240,8241,8242,8243,8244,8245,8246,8247, +8248,8249,8250,8251,8252,8253,8254,8255,8256,8257,8258,8259,8260,8261,8262, +8263,8264,8265,8266,8267,8268,8269,8270,8271,8272,8273,8274,8275,8276,8277, +8278,8279,8280,8281,8282,8283,8284,8285,8286,8287,8288,8289,8290,8291,8292, +8293,8294,8295,8296,8297,8298,8299,8300,8301,8302,8303,8304,8305,8306,8307, +8308,8309,8310,8311,8312,8313,8314,8315,8316,8317,8318,8319,8320,8321,8322, +8323,8324,8325,8326,8327,8328,8329,8330,8331,8332,8333,8334,8335,8336,8337, +8338,8339,8340,8341,8342,8343,8344,8345,8346,8347,8348,8349,8350,8351,8352, +8353,8354,8355,8356,8357,8358,8359,8360,8361,8362,8363,8364,8365,8366,8367, +8368,8369,8370,8371,8372,8373,8374,8375,8376,8377,8378,8379,8380,8381,8382, +8383,8384,8385,8386,8387,8388,8389,8390,8391,8392,8393,8394,8395,8396,8397, +8398,8399,8400,8401,8402,8403,8404,8405,8406,8407,8408,8409,8410,8411,8412, +8413,8414,8415,8416,8417,8418,8419,8420,8421,8422,8423,8424,8425,8426,8427, +8428,8429,8430,8431,8432,8433,8434,8435,8436,8437,8438,8439,8440,8441,8442, +8443,8444,8445,8446,8447,8448,8449,8450,8451,8452,8453,8454,8455,8456,8457, +8458,8459,8460,8461,8462,8463,8464,8465,8466,8467,8468,8469,8470,8471,8472, +8473,8474,8475,8476,8477,8478,8479,8480,8481,8482,8483,8484,8485,8486,8487, +8488,8489,8490,8491,8492,8493,8494,8495,8496,8497,8498,8499,8500,8501,8502, +8503,8504,8505,8506,8507,8508,8509,8510,8511,8512,8513,8514,8515,8516,8517, +8518,8519,8520,8521,8522,8523,8524,8525,8498,8527,8528,8529,8530,8531,8532, +8533,8534,8535,8536,8537,8538,8539,8540,8541,8542,8543,8544,8545,8546,8547, +8548,8549,8550,8551,8552,8553,8554,8555,8556,8557,8558,8559,8544,8545,8546, +8547,8548,8549,8550,8551,8552,8553,8554,8555,8556,8557,8558,8559,8576,8577, +8578,8579,8579,8581,8582,8583,8584,8585,8586,8587,8588,8589,8590,8591,8592, +8593,8594,8595,8596,8597,8598,8599,8600,8601,8602,8603,8604,8605,8606,8607, +8608,8609,8610,8611,8612,8613,8614,8615,8616,8617,8618,8619,8620,8621,8622, +8623,8624,8625,8626,8627,8628,8629,8630,8631,8632,8633,8634,8635,8636,8637, +8638,8639,8640,8641,8642,8643,8644,8645,8646,8647,8648,8649,8650,8651,8652, +8653,8654,8655,8656,8657,8658,8659,8660,8661,8662,8663,8664,8665,8666,8667, +8668,8669,8670,8671,8672,8673,8674,8675,8676,8677,8678,8679,8680,8681,8682, +8683,8684,8685,8686,8687,8688,8689,8690,8691,8692,8693,8694,8695,8696,8697, +8698,8699,8700,8701,8702,8703,8704,8705,8706,8707,8708,8709,8710,8711,8712, +8713,8714,8715,8716,8717,8718,8719,8720,8721,8722,8723,8724,8725,8726,8727, +8728,8729,8730,8731,8732,8733,8734,8735,8736,8737,8738,8739,8740,8741,8742, +8743,8744,8745,8746,8747,8748,8749,8750,8751,8752,8753,8754,8755,8756,8757, +8758,8759,8760,8761,8762,8763,8764,8765,8766,8767,8768,8769,8770,8771,8772, +8773,8774,8775,8776,8777,8778,8779,8780,8781,8782,8783,8784,8785,8786,8787, +8788,8789,8790,8791,8792,8793,8794,8795,8796,8797,8798,8799,8800,8801,8802, +8803,8804,8805,8806,8807,8808,8809,8810,8811,8812,8813,8814,8815,8816,8817, +8818,8819,8820,8821,8822,8823,8824,8825,8826,8827,8828,8829,8830,8831,8832, +8833,8834,8835,8836,8837,8838,8839,8840,8841,8842,8843,8844,8845,8846,8847, +8848,8849,8850,8851,8852,8853,8854,8855,8856,8857,8858,8859,8860,8861,8862, +8863,8864,8865,8866,8867,8868,8869,8870,8871,8872,8873,8874,8875,8876,8877, +8878,8879,8880,8881,8882,8883,8884,8885,8886,8887,8888,8889,8890,8891,8892, +8893,8894,8895,8896,8897,8898,8899,8900,8901,8902,8903,8904,8905,8906,8907, +8908,8909,8910,8911,8912,8913,8914,8915,8916,8917,8918,8919,8920,8921,8922, +8923,8924,8925,8926,8927,8928,8929,8930,8931,8932,8933,8934,8935,8936,8937, +8938,8939,8940,8941,8942,8943,8944,8945,8946,8947,8948,8949,8950,8951,8952, +8953,8954,8955,8956,8957,8958,8959,8960,8961,8962,8963,8964,8965,8966,8967, +8968,8969,8970,8971,8972,8973,8974,8975,8976,8977,8978,8979,8980,8981,8982, +8983,8984,8985,8986,8987,8988,8989,8990,8991,8992,8993,8994,8995,8996,8997, +8998,8999,9000,9001,9002,9003,9004,9005,9006,9007,9008,9009,9010,9011,9012, +9013,9014,9015,9016,9017,9018,9019,9020,9021,9022,9023,9024,9025,9026,9027, +9028,9029,9030,9031,9032,9033,9034,9035,9036,9037,9038,9039,9040,9041,9042, +9043,9044,9045,9046,9047,9048,9049,9050,9051,9052,9053,9054,9055,9056,9057, +9058,9059,9060,9061,9062,9063,9064,9065,9066,9067,9068,9069,9070,9071,9072, +9073,9074,9075,9076,9077,9078,9079,9080,9081,9082,9083,9084,9085,9086,9087, +9088,9089,9090,9091,9092,9093,9094,9095,9096,9097,9098,9099,9100,9101,9102, +9103,9104,9105,9106,9107,9108,9109,9110,9111,9112,9113,9114,9115,9116,9117, +9118,9119,9120,9121,9122,9123,9124,9125,9126,9127,9128,9129,9130,9131,9132, +9133,9134,9135,9136,9137,9138,9139,9140,9141,9142,9143,9144,9145,9146,9147, +9148,9149,9150,9151,9152,9153,9154,9155,9156,9157,9158,9159,9160,9161,9162, +9163,9164,9165,9166,9167,9168,9169,9170,9171,9172,9173,9174,9175,9176,9177, +9178,9179,9180,9181,9182,9183,9184,9185,9186,9187,9188,9189,9190,9191,9192, +9193,9194,9195,9196,9197,9198,9199,9200,9201,9202,9203,9204,9205,9206,9207, +9208,9209,9210,9211,9212,9213,9214,9215,9216,9217,9218,9219,9220,9221,9222, +9223,9224,9225,9226,9227,9228,9229,9230,9231,9232,9233,9234,9235,9236,9237, +9238,9239,9240,9241,9242,9243,9244,9245,9246,9247,9248,9249,9250,9251,9252, +9253,9254,9255,9256,9257,9258,9259,9260,9261,9262,9263,9264,9265,9266,9267, +9268,9269,9270,9271,9272,9273,9274,9275,9276,9277,9278,9279,9280,9281,9282, +9283,9284,9285,9286,9287,9288,9289,9290,9291,9292,9293,9294,9295,9296,9297, +9298,9299,9300,9301,9302,9303,9304,9305,9306,9307,9308,9309,9310,9311,9312, +9313,9314,9315,9316,9317,9318,9319,9320,9321,9322,9323,9324,9325,9326,9327, +9328,9329,9330,9331,9332,9333,9334,9335,9336,9337,9338,9339,9340,9341,9342, +9343,9344,9345,9346,9347,9348,9349,9350,9351,9352,9353,9354,9355,9356,9357, +9358,9359,9360,9361,9362,9363,9364,9365,9366,9367,9368,9369,9370,9371,9372, +9373,9374,9375,9376,9377,9378,9379,9380,9381,9382,9383,9384,9385,9386,9387, +9388,9389,9390,9391,9392,9393,9394,9395,9396,9397,9398,9399,9400,9401,9402, +9403,9404,9405,9406,9407,9408,9409,9410,9411,9412,9413,9414,9415,9416,9417, +9418,9419,9420,9421,9422,9423,9398,9399,9400,9401,9402,9403,9404,9405,9406, +9407,9408,9409,9410,9411,9412,9413,9414,9415,9416,9417,9418,9419,9420,9421, +9422,9423,9450,9451,9452,9453,9454,9455,9456,9457,9458,9459,9460,9461,9462, +9463,9464,9465,9466,9467,9468,9469,9470,9471,9472,9473,9474,9475,9476,9477, +9478,9479,9480,9481,9482,9483,9484,9485,9486,9487,9488,9489,9490,9491,9492, +9493,9494,9495,9496,9497,9498,9499,9500,9501,9502,9503,9504,9505,9506,9507, +9508,9509,9510,9511,9512,9513,9514,9515,9516,9517,9518,9519,9520,9521,9522, +9523,9524,9525,9526,9527,9528,9529,9530,9531,9532,9533,9534,9535,9536,9537, +9538,9539,9540,9541,9542,9543,9544,9545,9546,9547,9548,9549,9550,9551,9552, +9553,9554,9555,9556,9557,9558,9559,9560,9561,9562,9563,9564,9565,9566,9567, +9568,9569,9570,9571,9572,9573,9574,9575,9576,9577,9578,9579,9580,9581,9582, +9583,9584,9585,9586,9587,9588,9589,9590,9591,9592,9593,9594,9595,9596,9597, +9598,9599,9600,9601,9602,9603,9604,9605,9606,9607,9608,9609,9610,9611,9612, +9613,9614,9615,9616,9617,9618,9619,9620,9621,9622,9623,9624,9625,9626,9627, +9628,9629,9630,9631,9632,9633,9634,9635,9636,9637,9638,9639,9640,9641,9642, +9643,9644,9645,9646,9647,9648,9649,9650,9651,9652,9653,9654,9655,9656,9657, +9658,9659,9660,9661,9662,9663,9664,9665,9666,9667,9668,9669,9670,9671,9672, +9673,9674,9675,9676,9677,9678,9679,9680,9681,9682,9683,9684,9685,9686,9687, +9688,9689,9690,9691,9692,9693,9694,9695,9696,9697,9698,9699,9700,9701,9702, +9703,9704,9705,9706,9707,9708,9709,9710,9711,9712,9713,9714,9715,9716,9717, +9718,9719,9720,9721,9722,9723,9724,9725,9726,9727,9728,9729,9730,9731,9732, +9733,9734,9735,9736,9737,9738,9739,9740,9741,9742,9743,9744,9745,9746,9747, +9748,9749,9750,9751,9752,9753,9754,9755,9756,9757,9758,9759,9760,9761,9762, +9763,9764,9765,9766,9767,9768,9769,9770,9771,9772,9773,9774,9775,9776,9777, +9778,9779,9780,9781,9782,9783,9784,9785,9786,9787,9788,9789,9790,9791,9792, +9793,9794,9795,9796,9797,9798,9799,9800,9801,9802,9803,9804,9805,9806,9807, +9808,9809,9810,9811,9812,9813,9814,9815,9816,9817,9818,9819,9820,9821,9822, +9823,9824,9825,9826,9827,9828,9829,9830,9831,9832,9833,9834,9835,9836,9837, +9838,9839,9840,9841,9842,9843,9844,9845,9846,9847,9848,9849,9850,9851,9852, +9853,9854,9855,9856,9857,9858,9859,9860,9861,9862,9863,9864,9865,9866,9867, +9868,9869,9870,9871,9872,9873,9874,9875,9876,9877,9878,9879,9880,9881,9882, +9883,9884,9885,9886,9887,9888,9889,9890,9891,9892,9893,9894,9895,9896,9897, +9898,9899,9900,9901,9902,9903,9904,9905,9906,9907,9908,9909,9910,9911,9912, +9913,9914,9915,9916,9917,9918,9919,9920,9921,9922,9923,9924,9925,9926,9927, +9928,9929,9930,9931,9932,9933,9934,9935,9936,9937,9938,9939,9940,9941,9942, +9943,9944,9945,9946,9947,9948,9949,9950,9951,9952,9953,9954,9955,9956,9957, +9958,9959,9960,9961,9962,9963,9964,9965,9966,9967,9968,9969,9970,9971,9972, +9973,9974,9975,9976,9977,9978,9979,9980,9981,9982,9983,9984,9985,9986,9987, +9988,9989,9990,9991,9992,9993,9994,9995,9996,9997,9998,9999,10000,10001, +10002,10003,10004,10005,10006,10007,10008,10009,10010,10011,10012,10013, +10014,10015,10016,10017,10018,10019,10020,10021,10022,10023,10024,10025, +10026,10027,10028,10029,10030,10031,10032,10033,10034,10035,10036,10037, +10038,10039,10040,10041,10042,10043,10044,10045,10046,10047,10048,10049, +10050,10051,10052,10053,10054,10055,10056,10057,10058,10059,10060,10061, +10062,10063,10064,10065,10066,10067,10068,10069,10070,10071,10072,10073, +10074,10075,10076,10077,10078,10079,10080,10081,10082,10083,10084,10085, +10086,10087,10088,10089,10090,10091,10092,10093,10094,10095,10096,10097, +10098,10099,10100,10101,10102,10103,10104,10105,10106,10107,10108,10109, +10110,10111,10112,10113,10114,10115,10116,10117,10118,10119,10120,10121, +10122,10123,10124,10125,10126,10127,10128,10129,10130,10131,10132,10133, +10134,10135,10136,10137,10138,10139,10140,10141,10142,10143,10144,10145, +10146,10147,10148,10149,10150,10151,10152,10153,10154,10155,10156,10157, +10158,10159,10160,10161,10162,10163,10164,10165,10166,10167,10168,10169, +10170,10171,10172,10173,10174,10175,10176,10177,10178,10179,10180,10181, +10182,10183,10184,10185,10186,10187,10188,10189,10190,10191,10192,10193, +10194,10195,10196,10197,10198,10199,10200,10201,10202,10203,10204,10205, +10206,10207,10208,10209,10210,10211,10212,10213,10214,10215,10216,10217, +10218,10219,10220,10221,10222,10223,10224,10225,10226,10227,10228,10229, +10230,10231,10232,10233,10234,10235,10236,10237,10238,10239,10240,10241, +10242,10243,10244,10245,10246,10247,10248,10249,10250,10251,10252,10253, +10254,10255,10256,10257,10258,10259,10260,10261,10262,10263,10264,10265, +10266,10267,10268,10269,10270,10271,10272,10273,10274,10275,10276,10277, +10278,10279,10280,10281,10282,10283,10284,10285,10286,10287,10288,10289, +10290,10291,10292,10293,10294,10295,10296,10297,10298,10299,10300,10301, +10302,10303,10304,10305,10306,10307,10308,10309,10310,10311,10312,10313, +10314,10315,10316,10317,10318,10319,10320,10321,10322,10323,10324,10325, +10326,10327,10328,10329,10330,10331,10332,10333,10334,10335,10336,10337, +10338,10339,10340,10341,10342,10343,10344,10345,10346,10347,10348,10349, +10350,10351,10352,10353,10354,10355,10356,10357,10358,10359,10360,10361, +10362,10363,10364,10365,10366,10367,10368,10369,10370,10371,10372,10373, +10374,10375,10376,10377,10378,10379,10380,10381,10382,10383,10384,10385, +10386,10387,10388,10389,10390,10391,10392,10393,10394,10395,10396,10397, +10398,10399,10400,10401,10402,10403,10404,10405,10406,10407,10408,10409, +10410,10411,10412,10413,10414,10415,10416,10417,10418,10419,10420,10421, +10422,10423,10424,10425,10426,10427,10428,10429,10430,10431,10432,10433, +10434,10435,10436,10437,10438,10439,10440,10441,10442,10443,10444,10445, +10446,10447,10448,10449,10450,10451,10452,10453,10454,10455,10456,10457, +10458,10459,10460,10461,10462,10463,10464,10465,10466,10467,10468,10469, +10470,10471,10472,10473,10474,10475,10476,10477,10478,10479,10480,10481, +10482,10483,10484,10485,10486,10487,10488,10489,10490,10491,10492,10493, +10494,10495,10496,10497,10498,10499,10500,10501,10502,10503,10504,10505, +10506,10507,10508,10509,10510,10511,10512,10513,10514,10515,10516,10517, +10518,10519,10520,10521,10522,10523,10524,10525,10526,10527,10528,10529, +10530,10531,10532,10533,10534,10535,10536,10537,10538,10539,10540,10541, +10542,10543,10544,10545,10546,10547,10548,10549,10550,10551,10552,10553, +10554,10555,10556,10557,10558,10559,10560,10561,10562,10563,10564,10565, +10566,10567,10568,10569,10570,10571,10572,10573,10574,10575,10576,10577, +10578,10579,10580,10581,10582,10583,10584,10585,10586,10587,10588,10589, +10590,10591,10592,10593,10594,10595,10596,10597,10598,10599,10600,10601, +10602,10603,10604,10605,10606,10607,10608,10609,10610,10611,10612,10613, +10614,10615,10616,10617,10618,10619,10620,10621,10622,10623,10624,10625, +10626,10627,10628,10629,10630,10631,10632,10633,10634,10635,10636,10637, +10638,10639,10640,10641,10642,10643,10644,10645,10646,10647,10648,10649, +10650,10651,10652,10653,10654,10655,10656,10657,10658,10659,10660,10661, +10662,10663,10664,10665,10666,10667,10668,10669,10670,10671,10672,10673, +10674,10675,10676,10677,10678,10679,10680,10681,10682,10683,10684,10685, +10686,10687,10688,10689,10690,10691,10692,10693,10694,10695,10696,10697, +10698,10699,10700,10701,10702,10703,10704,10705,10706,10707,10708,10709, +10710,10711,10712,10713,10714,10715,10716,10717,10718,10719,10720,10721, +10722,10723,10724,10725,10726,10727,10728,10729,10730,10731,10732,10733, +10734,10735,10736,10737,10738,10739,10740,10741,10742,10743,10744,10745, +10746,10747,10748,10749,10750,10751,10752,10753,10754,10755,10756,10757, +10758,10759,10760,10761,10762,10763,10764,10765,10766,10767,10768,10769, +10770,10771,10772,10773,10774,10775,10776,10777,10778,10779,10780,10781, +10782,10783,10784,10785,10786,10787,10788,10789,10790,10791,10792,10793, +10794,10795,10796,10797,10798,10799,10800,10801,10802,10803,10804,10805, +10806,10807,10808,10809,10810,10811,10812,10813,10814,10815,10816,10817, +10818,10819,10820,10821,10822,10823,10824,10825,10826,10827,10828,10829, +10830,10831,10832,10833,10834,10835,10836,10837,10838,10839,10840,10841, +10842,10843,10844,10845,10846,10847,10848,10849,10850,10851,10852,10853, +10854,10855,10856,10857,10858,10859,10860,10861,10862,10863,10864,10865, +10866,10867,10868,10869,10870,10871,10872,10873,10874,10875,10876,10877, +10878,10879,10880,10881,10882,10883,10884,10885,10886,10887,10888,10889, +10890,10891,10892,10893,10894,10895,10896,10897,10898,10899,10900,10901, +10902,10903,10904,10905,10906,10907,10908,10909,10910,10911,10912,10913, +10914,10915,10916,10917,10918,10919,10920,10921,10922,10923,10924,10925, +10926,10927,10928,10929,10930,10931,10932,10933,10934,10935,10936,10937, +10938,10939,10940,10941,10942,10943,10944,10945,10946,10947,10948,10949, +10950,10951,10952,10953,10954,10955,10956,10957,10958,10959,10960,10961, +10962,10963,10964,10965,10966,10967,10968,10969,10970,10971,10972,10973, +10974,10975,10976,10977,10978,10979,10980,10981,10982,10983,10984,10985, +10986,10987,10988,10989,10990,10991,10992,10993,10994,10995,10996,10997, +10998,10999,11000,11001,11002,11003,11004,11005,11006,11007,11008,11009, +11010,11011,11012,11013,11014,11015,11016,11017,11018,11019,11020,11021, +11022,11023,11024,11025,11026,11027,11028,11029,11030,11031,11032,11033, +11034,11035,11036,11037,11038,11039,11040,11041,11042,11043,11044,11045, +11046,11047,11048,11049,11050,11051,11052,11053,11054,11055,11056,11057, +11058,11059,11060,11061,11062,11063,11064,11065,11066,11067,11068,11069, +11070,11071,11072,11073,11074,11075,11076,11077,11078,11079,11080,11081, +11082,11083,11084,11085,11086,11087,11088,11089,11090,11091,11092,11093, +11094,11095,11096,11097,11098,11099,11100,11101,11102,11103,11104,11105, +11106,11107,11108,11109,11110,11111,11112,11113,11114,11115,11116,11117, +11118,11119,11120,11121,11122,11123,11124,11125,11126,11127,11128,11129, +11130,11131,11132,11133,11134,11135,11136,11137,11138,11139,11140,11141, +11142,11143,11144,11145,11146,11147,11148,11149,11150,11151,11152,11153, +11154,11155,11156,11157,11158,11159,11160,11161,11162,11163,11164,11165, +11166,11167,11168,11169,11170,11171,11172,11173,11174,11175,11176,11177, +11178,11179,11180,11181,11182,11183,11184,11185,11186,11187,11188,11189, +11190,11191,11192,11193,11194,11195,11196,11197,11198,11199,11200,11201, +11202,11203,11204,11205,11206,11207,11208,11209,11210,11211,11212,11213, +11214,11215,11216,11217,11218,11219,11220,11221,11222,11223,11224,11225, +11226,11227,11228,11229,11230,11231,11232,11233,11234,11235,11236,11237, +11238,11239,11240,11241,11242,11243,11244,11245,11246,11247,11248,11249, +11250,11251,11252,11253,11254,11255,11256,11257,11258,11259,11260,11261, +11262,11263,11264,11265,11266,11267,11268,11269,11270,11271,11272,11273, +11274,11275,11276,11277,11278,11279,11280,11281,11282,11283,11284,11285, +11286,11287,11288,11289,11290,11291,11292,11293,11294,11295,11296,11297, +11298,11299,11300,11301,11302,11303,11304,11305,11306,11307,11308,11309, +11310,11311,11264,11265,11266,11267,11268,11269,11270,11271,11272,11273, +11274,11275,11276,11277,11278,11279,11280,11281,11282,11283,11284,11285, +11286,11287,11288,11289,11290,11291,11292,11293,11294,11295,11296,11297, +11298,11299,11300,11301,11302,11303,11304,11305,11306,11307,11308,11309, +11310,11359,11360,11360,11362,11363,11364,570,574,11367,11367,11369,11369, +11371,11371,11373,11374,11375,11376,11377,11378,11378,11380,11381,11381, +11383,11384,11385,11386,11387,11388,11389,11390,11391,11392,11392,11394, +11394,11396,11396,11398,11398,11400,11400,11402,11402,11404,11404,11406, +11406,11408,11408,11410,11410,11412,11412,11414,11414,11416,11416,11418, +11418,11420,11420,11422,11422,11424,11424,11426,11426,11428,11428,11430, +11430,11432,11432,11434,11434,11436,11436,11438,11438,11440,11440,11442, +11442,11444,11444,11446,11446,11448,11448,11450,11450,11452,11452,11454, +11454,11456,11456,11458,11458,11460,11460,11462,11462,11464,11464,11466, +11466,11468,11468,11470,11470,11472,11472,11474,11474,11476,11476,11478, +11478,11480,11480,11482,11482,11484,11484,11486,11486,11488,11488,11490, +11490,11492,11493,11494,11495,11496,11497,11498,11499,11499,11501,11501, +11503,11504,11505,11506,11507,11508,11509,11510,11511,11512,11513,11514, +11515,11516,11517,11518,11519,4256,4257,4258,4259,4260,4261,4262,4263,4264, +4265,4266,4267,4268,4269,4270,4271,4272,4273,4274,4275,4276,4277,4278,4279, +4280,4281,4282,4283,4284,4285,4286,4287,4288,4289,4290,4291,4292,4293, +11558,11559,11560,11561,11562,11563,11564,11565,11566,11567,11568,11569, +11570,11571,11572,11573,11574,11575,11576,11577,11578,11579,11580,11581, +11582,11583,11584,11585,11586,11587,11588,11589,11590,11591,11592,11593, +11594,11595,11596,11597,11598,11599,11600,11601,11602,11603,11604,11605, +11606,11607,11608,11609,11610,11611,11612,11613,11614,11615,11616,11617, +11618,11619,11620,11621,11622,11623,11624,11625,11626,11627,11628,11629, +11630,11631,11632,11633,11634,11635,11636,11637,11638,11639,11640,11641, +11642,11643,11644,11645,11646,11647,11648,11649,11650,11651,11652,11653, +11654,11655,11656,11657,11658,11659,11660,11661,11662,11663,11664,11665, +11666,11667,11668,11669,11670,11671,11672,11673,11674,11675,11676,11677, +11678,11679,11680,11681,11682,11683,11684,11685,11686,11687,11688,11689, +11690,11691,11692,11693,11694,11695,11696,11697,11698,11699,11700,11701, +11702,11703,11704,11705,11706,11707,11708,11709,11710,11711,11712,11713, +11714,11715,11716,11717,11718,11719,11720,11721,11722,11723,11724,11725, +11726,11727,11728,11729,11730,11731,11732,11733,11734,11735,11736,11737, +11738,11739,11740,11741,11742,11743,11744,11745,11746,11747,11748,11749, +11750,11751,11752,11753,11754,11755,11756,11757,11758,11759,11760,11761, +11762,11763,11764,11765,11766,11767,11768,11769,11770,11771,11772,11773, +11774,11775,11776,11777,11778,11779,11780,11781,11782,11783,11784,11785, +11786,11787,11788,11789,11790,11791,11792,11793,11794,11795,11796,11797, +11798,11799,11800,11801,11802,11803,11804,11805,11806,11807,11808,11809, +11810,11811,11812,11813,11814,11815,11816,11817,11818,11819,11820,11821, +11822,11823,11824,11825,11826,11827,11828,11829,11830,11831,11832,11833, +11834,11835,11836,11837,11838,11839,11840,11841,11842,11843,11844,11845, +11846,11847,11848,11849,11850,11851,11852,11853,11854,11855,11856,11857, +11858,11859,11860,11861,11862,11863,11864,11865,11866,11867,11868,11869, +11870,11871,11872,11873,11874,11875,11876,11877,11878,11879,11880,11881, +11882,11883,11884,11885,11886,11887,11888,11889,11890,11891,11892,11893, +11894,11895,11896,11897,11898,11899,11900,11901,11902,11903,11904,11905, +11906,11907,11908,11909,11910,11911,11912,11913,11914,11915,11916,11917, +11918,11919,11920,11921,11922,11923,11924,11925,11926,11927,11928,11929, +11930,11931,11932,11933,11934,11935,11936,11937,11938,11939,11940,11941, +11942,11943,11944,11945,11946,11947,11948,11949,11950,11951,11952,11953, +11954,11955,11956,11957,11958,11959,11960,11961,11962,11963,11964,11965, +11966,11967,11968,11969,11970,11971,11972,11973,11974,11975,11976,11977, +11978,11979,11980,11981,11982,11983,11984,11985,11986,11987,11988,11989, +11990,11991,11992,11993,11994,11995,11996,11997,11998,11999,12000,12001, +12002,12003,12004,12005,12006,12007,12008,12009,12010,12011,12012,12013, +12014,12015,12016,12017,12018,12019,12020,12021,12022,12023,12024,12025, +12026,12027,12028,12029,12030,12031,12032,12033,12034,12035,12036,12037, +12038,12039,12040,12041,12042,12043,12044,12045,12046,12047,12048,12049, +12050,12051,12052,12053,12054,12055,12056,12057,12058,12059,12060,12061, +12062,12063,12064,12065,12066,12067,12068,12069,12070,12071,12072,12073, +12074,12075,12076,12077,12078,12079,12080,12081,12082,12083,12084,12085, +12086,12087,12088,12089,12090,12091,12092,12093,12094,12095,12096,12097, +12098,12099,12100,12101,12102,12103,12104,12105,12106,12107,12108,12109, +12110,12111,12112,12113,12114,12115,12116,12117,12118,12119,12120,12121, +12122,12123,12124,12125,12126,12127,12128,12129,12130,12131,12132,12133, +12134,12135,12136,12137,12138,12139,12140,12141,12142,12143,12144,12145, +12146,12147,12148,12149,12150,12151,12152,12153,12154,12155,12156,12157, +12158,12159,12160,12161,12162,12163,12164,12165,12166,12167,12168,12169, +12170,12171,12172,12173,12174,12175,12176,12177,12178,12179,12180,12181, +12182,12183,12184,12185,12186,12187,12188,12189,12190,12191,12192,12193, +12194,12195,12196,12197,12198,12199,12200,12201,12202,12203,12204,12205, +12206,12207,12208,12209,12210,12211,12212,12213,12214,12215,12216,12217, +12218,12219,12220,12221,12222,12223,12224,12225,12226,12227,12228,12229, +12230,12231,12232,12233,12234,12235,12236,12237,12238,12239,12240,12241, +12242,12243,12244,12245,12246,12247,12248,12249,12250,12251,12252,12253, +12254,12255,12256,12257,12258,12259,12260,12261,12262,12263,12264,12265, +12266,12267,12268,12269,12270,12271,12272,12273,12274,12275,12276,12277, +12278,12279,12280,12281,12282,12283,12284,12285,12286,12287,12288,12289, +12290,12291,12292,12293,12294,12295,12296,12297,12298,12299,12300,12301, +12302,12303,12304,12305,12306,12307,12308,12309,12310,12311,12312,12313, +12314,12315,12316,12317,12318,12319,12320,12321,12322,12323,12324,12325, +12326,12327,12328,12329,12330,12331,12332,12333,12334,12335,12336,12337, +12338,12339,12340,12341,12342,12343,12344,12345,12346,12347,12348,12349, +12350,12351,12352,12353,12354,12355,12356,12357,12358,12359,12360,12361, +12362,12363,12364,12365,12366,12367,12368,12369,12370,12371,12372,12373, +12374,12375,12376,12377,12378,12379,12380,12381,12382,12383,12384,12385, +12386,12387,12388,12389,12390,12391,12392,12393,12394,12395,12396,12397, +12398,12399,12400,12401,12402,12403,12404,12405,12406,12407,12408,12409, +12410,12411,12412,12413,12414,12415,12416,12417,12418,12419,12420,12421, +12422,12423,12424,12425,12426,12427,12428,12429,12430,12431,12432,12433, +12434,12435,12436,12437,12438,12439,12440,12441,12442,12443,12444,12445, +12446,12447,12448,12449,12450,12451,12452,12453,12454,12455,12456,12457, +12458,12459,12460,12461,12462,12463,12464,12465,12466,12467,12468,12469, +12470,12471,12472,12473,12474,12475,12476,12477,12478,12479,12480,12481, +12482,12483,12484,12485,12486,12487,12488,12489,12490,12491,12492,12493, +12494,12495,12496,12497,12498,12499,12500,12501,12502,12503,12504,12505, +12506,12507,12508,12509,12510,12511,12512,12513,12514,12515,12516,12517, +12518,12519,12520,12521,12522,12523,12524,12525,12526,12527,12528,12529, +12530,12531,12532,12533,12534,12535,12536,12537,12538,12539,12540,12541, +12542,12543,12544,12545,12546,12547,12548,12549,12550,12551,12552,12553, +12554,12555,12556,12557,12558,12559,12560,12561,12562,12563,12564,12565, +12566,12567,12568,12569,12570,12571,12572,12573,12574,12575,12576,12577, +12578,12579,12580,12581,12582,12583,12584,12585,12586,12587,12588,12589, +12590,12591,12592,12593,12594,12595,12596,12597,12598,12599,12600,12601, +12602,12603,12604,12605,12606,12607,12608,12609,12610,12611,12612,12613, +12614,12615,12616,12617,12618,12619,12620,12621,12622,12623,12624,12625, +12626,12627,12628,12629,12630,12631,12632,12633,12634,12635,12636,12637, +12638,12639,12640,12641,12642,12643,12644,12645,12646,12647,12648,12649, +12650,12651,12652,12653,12654,12655,12656,12657,12658,12659,12660,12661, +12662,12663,12664,12665,12666,12667,12668,12669,12670,12671,12672,12673, +12674,12675,12676,12677,12678,12679,12680,12681,12682,12683,12684,12685, +12686,12687,12688,12689,12690,12691,12692,12693,12694,12695,12696,12697, +12698,12699,12700,12701,12702,12703,12704,12705,12706,12707,12708,12709, +12710,12711,12712,12713,12714,12715,12716,12717,12718,12719,12720,12721, +12722,12723,12724,12725,12726,12727,12728,12729,12730,12731,12732,12733, +12734,12735,12736,12737,12738,12739,12740,12741,12742,12743,12744,12745, +12746,12747,12748,12749,12750,12751,12752,12753,12754,12755,12756,12757, +12758,12759,12760,12761,12762,12763,12764,12765,12766,12767,12768,12769, +12770,12771,12772,12773,12774,12775,12776,12777,12778,12779,12780,12781, +12782,12783,12784,12785,12786,12787,12788,12789,12790,12791,12792,12793, +12794,12795,12796,12797,12798,12799,12800,12801,12802,12803,12804,12805, +12806,12807,12808,12809,12810,12811,12812,12813,12814,12815,12816,12817, +12818,12819,12820,12821,12822,12823,12824,12825,12826,12827,12828,12829, +12830,12831,12832,12833,12834,12835,12836,12837,12838,12839,12840,12841, +12842,12843,12844,12845,12846,12847,12848,12849,12850,12851,12852,12853, +12854,12855,12856,12857,12858,12859,12860,12861,12862,12863,12864,12865, +12866,12867,12868,12869,12870,12871,12872,12873,12874,12875,12876,12877, +12878,12879,12880,12881,12882,12883,12884,12885,12886,12887,12888,12889, +12890,12891,12892,12893,12894,12895,12896,12897,12898,12899,12900,12901, +12902,12903,12904,12905,12906,12907,12908,12909,12910,12911,12912,12913, +12914,12915,12916,12917,12918,12919,12920,12921,12922,12923,12924,12925, +12926,12927,12928,12929,12930,12931,12932,12933,12934,12935,12936,12937, +12938,12939,12940,12941,12942,12943,12944,12945,12946,12947,12948,12949, +12950,12951,12952,12953,12954,12955,12956,12957,12958,12959,12960,12961, +12962,12963,12964,12965,12966,12967,12968,12969,12970,12971,12972,12973, +12974,12975,12976,12977,12978,12979,12980,12981,12982,12983,12984,12985, +12986,12987,12988,12989,12990,12991,12992,12993,12994,12995,12996,12997, +12998,12999,13000,13001,13002,13003,13004,13005,13006,13007,13008,13009, +13010,13011,13012,13013,13014,13015,13016,13017,13018,13019,13020,13021, +13022,13023,13024,13025,13026,13027,13028,13029,13030,13031,13032,13033, +13034,13035,13036,13037,13038,13039,13040,13041,13042,13043,13044,13045, +13046,13047,13048,13049,13050,13051,13052,13053,13054,13055,13056,13057, +13058,13059,13060,13061,13062,13063,13064,13065,13066,13067,13068,13069, +13070,13071,13072,13073,13074,13075,13076,13077,13078,13079,13080,13081, +13082,13083,13084,13085,13086,13087,13088,13089,13090,13091,13092,13093, +13094,13095,13096,13097,13098,13099,13100,13101,13102,13103,13104,13105, +13106,13107,13108,13109,13110,13111,13112,13113,13114,13115,13116,13117, +13118,13119,13120,13121,13122,13123,13124,13125,13126,13127,13128,13129, +13130,13131,13132,13133,13134,13135,13136,13137,13138,13139,13140,13141, +13142,13143,13144,13145,13146,13147,13148,13149,13150,13151,13152,13153, +13154,13155,13156,13157,13158,13159,13160,13161,13162,13163,13164,13165, +13166,13167,13168,13169,13170,13171,13172,13173,13174,13175,13176,13177, +13178,13179,13180,13181,13182,13183,13184,13185,13186,13187,13188,13189, +13190,13191,13192,13193,13194,13195,13196,13197,13198,13199,13200,13201, +13202,13203,13204,13205,13206,13207,13208,13209,13210,13211,13212,13213, +13214,13215,13216,13217,13218,13219,13220,13221,13222,13223,13224,13225, +13226,13227,13228,13229,13230,13231,13232,13233,13234,13235,13236,13237, +13238,13239,13240,13241,13242,13243,13244,13245,13246,13247,13248,13249, +13250,13251,13252,13253,13254,13255,13256,13257,13258,13259,13260,13261, +13262,13263,13264,13265,13266,13267,13268,13269,13270,13271,13272,13273, +13274,13275,13276,13277,13278,13279,13280,13281,13282,13283,13284,13285, +13286,13287,13288,13289,13290,13291,13292,13293,13294,13295,13296,13297, +13298,13299,13300,13301,13302,13303,13304,13305,13306,13307,13308,13309, +13310,13311,13312,13313,13314,13315,13316,13317,13318,13319,13320,13321, +13322,13323,13324,13325,13326,13327,13328,13329,13330,13331,13332,13333, +13334,13335,13336,13337,13338,13339,13340,13341,13342,13343,13344,13345, +13346,13347,13348,13349,13350,13351,13352,13353,13354,13355,13356,13357, +13358,13359,13360,13361,13362,13363,13364,13365,13366,13367,13368,13369, +13370,13371,13372,13373,13374,13375,13376,13377,13378,13379,13380,13381, +13382,13383,13384,13385,13386,13387,13388,13389,13390,13391,13392,13393, +13394,13395,13396,13397,13398,13399,13400,13401,13402,13403,13404,13405, +13406,13407,13408,13409,13410,13411,13412,13413,13414,13415,13416,13417, +13418,13419,13420,13421,13422,13423,13424,13425,13426,13427,13428,13429, +13430,13431,13432,13433,13434,13435,13436,13437,13438,13439,13440,13441, +13442,13443,13444,13445,13446,13447,13448,13449,13450,13451,13452,13453, +13454,13455,13456,13457,13458,13459,13460,13461,13462,13463,13464,13465, +13466,13467,13468,13469,13470,13471,13472,13473,13474,13475,13476,13477, +13478,13479,13480,13481,13482,13483,13484,13485,13486,13487,13488,13489, +13490,13491,13492,13493,13494,13495,13496,13497,13498,13499,13500,13501, +13502,13503,13504,13505,13506,13507,13508,13509,13510,13511,13512,13513, +13514,13515,13516,13517,13518,13519,13520,13521,13522,13523,13524,13525, +13526,13527,13528,13529,13530,13531,13532,13533,13534,13535,13536,13537, +13538,13539,13540,13541,13542,13543,13544,13545,13546,13547,13548,13549, +13550,13551,13552,13553,13554,13555,13556,13557,13558,13559,13560,13561, +13562,13563,13564,13565,13566,13567,13568,13569,13570,13571,13572,13573, +13574,13575,13576,13577,13578,13579,13580,13581,13582,13583,13584,13585, +13586,13587,13588,13589,13590,13591,13592,13593,13594,13595,13596,13597, +13598,13599,13600,13601,13602,13603,13604,13605,13606,13607,13608,13609, +13610,13611,13612,13613,13614,13615,13616,13617,13618,13619,13620,13621, +13622,13623,13624,13625,13626,13627,13628,13629,13630,13631,13632,13633, +13634,13635,13636,13637,13638,13639,13640,13641,13642,13643,13644,13645, +13646,13647,13648,13649,13650,13651,13652,13653,13654,13655,13656,13657, +13658,13659,13660,13661,13662,13663,13664,13665,13666,13667,13668,13669, +13670,13671,13672,13673,13674,13675,13676,13677,13678,13679,13680,13681, +13682,13683,13684,13685,13686,13687,13688,13689,13690,13691,13692,13693, +13694,13695,13696,13697,13698,13699,13700,13701,13702,13703,13704,13705, +13706,13707,13708,13709,13710,13711,13712,13713,13714,13715,13716,13717, +13718,13719,13720,13721,13722,13723,13724,13725,13726,13727,13728,13729, +13730,13731,13732,13733,13734,13735,13736,13737,13738,13739,13740,13741, +13742,13743,13744,13745,13746,13747,13748,13749,13750,13751,13752,13753, +13754,13755,13756,13757,13758,13759,13760,13761,13762,13763,13764,13765, +13766,13767,13768,13769,13770,13771,13772,13773,13774,13775,13776,13777, +13778,13779,13780,13781,13782,13783,13784,13785,13786,13787,13788,13789, +13790,13791,13792,13793,13794,13795,13796,13797,13798,13799,13800,13801, +13802,13803,13804,13805,13806,13807,13808,13809,13810,13811,13812,13813, +13814,13815,13816,13817,13818,13819,13820,13821,13822,13823,13824,13825, +13826,13827,13828,13829,13830,13831,13832,13833,13834,13835,13836,13837, +13838,13839,13840,13841,13842,13843,13844,13845,13846,13847,13848,13849, +13850,13851,13852,13853,13854,13855,13856,13857,13858,13859,13860,13861, +13862,13863,13864,13865,13866,13867,13868,13869,13870,13871,13872,13873, +13874,13875,13876,13877,13878,13879,13880,13881,13882,13883,13884,13885, +13886,13887,13888,13889,13890,13891,13892,13893,13894,13895,13896,13897, +13898,13899,13900,13901,13902,13903,13904,13905,13906,13907,13908,13909, +13910,13911,13912,13913,13914,13915,13916,13917,13918,13919,13920,13921, +13922,13923,13924,13925,13926,13927,13928,13929,13930,13931,13932,13933, +13934,13935,13936,13937,13938,13939,13940,13941,13942,13943,13944,13945, +13946,13947,13948,13949,13950,13951,13952,13953,13954,13955,13956,13957, +13958,13959,13960,13961,13962,13963,13964,13965,13966,13967,13968,13969, +13970,13971,13972,13973,13974,13975,13976,13977,13978,13979,13980,13981, +13982,13983,13984,13985,13986,13987,13988,13989,13990,13991,13992,13993, +13994,13995,13996,13997,13998,13999,14000,14001,14002,14003,14004,14005, +14006,14007,14008,14009,14010,14011,14012,14013,14014,14015,14016,14017, +14018,14019,14020,14021,14022,14023,14024,14025,14026,14027,14028,14029, +14030,14031,14032,14033,14034,14035,14036,14037,14038,14039,14040,14041, +14042,14043,14044,14045,14046,14047,14048,14049,14050,14051,14052,14053, +14054,14055,14056,14057,14058,14059,14060,14061,14062,14063,14064,14065, +14066,14067,14068,14069,14070,14071,14072,14073,14074,14075,14076,14077, +14078,14079,14080,14081,14082,14083,14084,14085,14086,14087,14088,14089, +14090,14091,14092,14093,14094,14095,14096,14097,14098,14099,14100,14101, +14102,14103,14104,14105,14106,14107,14108,14109,14110,14111,14112,14113, +14114,14115,14116,14117,14118,14119,14120,14121,14122,14123,14124,14125, +14126,14127,14128,14129,14130,14131,14132,14133,14134,14135,14136,14137, +14138,14139,14140,14141,14142,14143,14144,14145,14146,14147,14148,14149, +14150,14151,14152,14153,14154,14155,14156,14157,14158,14159,14160,14161, +14162,14163,14164,14165,14166,14167,14168,14169,14170,14171,14172,14173, +14174,14175,14176,14177,14178,14179,14180,14181,14182,14183,14184,14185, +14186,14187,14188,14189,14190,14191,14192,14193,14194,14195,14196,14197, +14198,14199,14200,14201,14202,14203,14204,14205,14206,14207,14208,14209, +14210,14211,14212,14213,14214,14215,14216,14217,14218,14219,14220,14221, +14222,14223,14224,14225,14226,14227,14228,14229,14230,14231,14232,14233, +14234,14235,14236,14237,14238,14239,14240,14241,14242,14243,14244,14245, +14246,14247,14248,14249,14250,14251,14252,14253,14254,14255,14256,14257, +14258,14259,14260,14261,14262,14263,14264,14265,14266,14267,14268,14269, +14270,14271,14272,14273,14274,14275,14276,14277,14278,14279,14280,14281, +14282,14283,14284,14285,14286,14287,14288,14289,14290,14291,14292,14293, +14294,14295,14296,14297,14298,14299,14300,14301,14302,14303,14304,14305, +14306,14307,14308,14309,14310,14311,14312,14313,14314,14315,14316,14317, +14318,14319,14320,14321,14322,14323,14324,14325,14326,14327,14328,14329, +14330,14331,14332,14333,14334,14335,14336,14337,14338,14339,14340,14341, +14342,14343,14344,14345,14346,14347,14348,14349,14350,14351,14352,14353, +14354,14355,14356,14357,14358,14359,14360,14361,14362,14363,14364,14365, +14366,14367,14368,14369,14370,14371,14372,14373,14374,14375,14376,14377, +14378,14379,14380,14381,14382,14383,14384,14385,14386,14387,14388,14389, +14390,14391,14392,14393,14394,14395,14396,14397,14398,14399,14400,14401, +14402,14403,14404,14405,14406,14407,14408,14409,14410,14411,14412,14413, +14414,14415,14416,14417,14418,14419,14420,14421,14422,14423,14424,14425, +14426,14427,14428,14429,14430,14431,14432,14433,14434,14435,14436,14437, +14438,14439,14440,14441,14442,14443,14444,14445,14446,14447,14448,14449, +14450,14451,14452,14453,14454,14455,14456,14457,14458,14459,14460,14461, +14462,14463,14464,14465,14466,14467,14468,14469,14470,14471,14472,14473, +14474,14475,14476,14477,14478,14479,14480,14481,14482,14483,14484,14485, +14486,14487,14488,14489,14490,14491,14492,14493,14494,14495,14496,14497, +14498,14499,14500,14501,14502,14503,14504,14505,14506,14507,14508,14509, +14510,14511,14512,14513,14514,14515,14516,14517,14518,14519,14520,14521, +14522,14523,14524,14525,14526,14527,14528,14529,14530,14531,14532,14533, +14534,14535,14536,14537,14538,14539,14540,14541,14542,14543,14544,14545, +14546,14547,14548,14549,14550,14551,14552,14553,14554,14555,14556,14557, +14558,14559,14560,14561,14562,14563,14564,14565,14566,14567,14568,14569, +14570,14571,14572,14573,14574,14575,14576,14577,14578,14579,14580,14581, +14582,14583,14584,14585,14586,14587,14588,14589,14590,14591,14592,14593, +14594,14595,14596,14597,14598,14599,14600,14601,14602,14603,14604,14605, +14606,14607,14608,14609,14610,14611,14612,14613,14614,14615,14616,14617, +14618,14619,14620,14621,14622,14623,14624,14625,14626,14627,14628,14629, +14630,14631,14632,14633,14634,14635,14636,14637,14638,14639,14640,14641, +14642,14643,14644,14645,14646,14647,14648,14649,14650,14651,14652,14653, +14654,14655,14656,14657,14658,14659,14660,14661,14662,14663,14664,14665, +14666,14667,14668,14669,14670,14671,14672,14673,14674,14675,14676,14677, +14678,14679,14680,14681,14682,14683,14684,14685,14686,14687,14688,14689, +14690,14691,14692,14693,14694,14695,14696,14697,14698,14699,14700,14701, +14702,14703,14704,14705,14706,14707,14708,14709,14710,14711,14712,14713, +14714,14715,14716,14717,14718,14719,14720,14721,14722,14723,14724,14725, +14726,14727,14728,14729,14730,14731,14732,14733,14734,14735,14736,14737, +14738,14739,14740,14741,14742,14743,14744,14745,14746,14747,14748,14749, +14750,14751,14752,14753,14754,14755,14756,14757,14758,14759,14760,14761, +14762,14763,14764,14765,14766,14767,14768,14769,14770,14771,14772,14773, +14774,14775,14776,14777,14778,14779,14780,14781,14782,14783,14784,14785, +14786,14787,14788,14789,14790,14791,14792,14793,14794,14795,14796,14797, +14798,14799,14800,14801,14802,14803,14804,14805,14806,14807,14808,14809, +14810,14811,14812,14813,14814,14815,14816,14817,14818,14819,14820,14821, +14822,14823,14824,14825,14826,14827,14828,14829,14830,14831,14832,14833, +14834,14835,14836,14837,14838,14839,14840,14841,14842,14843,14844,14845, +14846,14847,14848,14849,14850,14851,14852,14853,14854,14855,14856,14857, +14858,14859,14860,14861,14862,14863,14864,14865,14866,14867,14868,14869, +14870,14871,14872,14873,14874,14875,14876,14877,14878,14879,14880,14881, +14882,14883,14884,14885,14886,14887,14888,14889,14890,14891,14892,14893, +14894,14895,14896,14897,14898,14899,14900,14901,14902,14903,14904,14905, +14906,14907,14908,14909,14910,14911,14912,14913,14914,14915,14916,14917, +14918,14919,14920,14921,14922,14923,14924,14925,14926,14927,14928,14929, +14930,14931,14932,14933,14934,14935,14936,14937,14938,14939,14940,14941, +14942,14943,14944,14945,14946,14947,14948,14949,14950,14951,14952,14953, +14954,14955,14956,14957,14958,14959,14960,14961,14962,14963,14964,14965, +14966,14967,14968,14969,14970,14971,14972,14973,14974,14975,14976,14977, +14978,14979,14980,14981,14982,14983,14984,14985,14986,14987,14988,14989, +14990,14991,14992,14993,14994,14995,14996,14997,14998,14999,15000,15001, +15002,15003,15004,15005,15006,15007,15008,15009,15010,15011,15012,15013, +15014,15015,15016,15017,15018,15019,15020,15021,15022,15023,15024,15025, +15026,15027,15028,15029,15030,15031,15032,15033,15034,15035,15036,15037, +15038,15039,15040,15041,15042,15043,15044,15045,15046,15047,15048,15049, +15050,15051,15052,15053,15054,15055,15056,15057,15058,15059,15060,15061, +15062,15063,15064,15065,15066,15067,15068,15069,15070,15071,15072,15073, +15074,15075,15076,15077,15078,15079,15080,15081,15082,15083,15084,15085, +15086,15087,15088,15089,15090,15091,15092,15093,15094,15095,15096,15097, +15098,15099,15100,15101,15102,15103,15104,15105,15106,15107,15108,15109, +15110,15111,15112,15113,15114,15115,15116,15117,15118,15119,15120,15121, +15122,15123,15124,15125,15126,15127,15128,15129,15130,15131,15132,15133, +15134,15135,15136,15137,15138,15139,15140,15141,15142,15143,15144,15145, +15146,15147,15148,15149,15150,15151,15152,15153,15154,15155,15156,15157, +15158,15159,15160,15161,15162,15163,15164,15165,15166,15167,15168,15169, +15170,15171,15172,15173,15174,15175,15176,15177,15178,15179,15180,15181, +15182,15183,15184,15185,15186,15187,15188,15189,15190,15191,15192,15193, +15194,15195,15196,15197,15198,15199,15200,15201,15202,15203,15204,15205, +15206,15207,15208,15209,15210,15211,15212,15213,15214,15215,15216,15217, +15218,15219,15220,15221,15222,15223,15224,15225,15226,15227,15228,15229, +15230,15231,15232,15233,15234,15235,15236,15237,15238,15239,15240,15241, +15242,15243,15244,15245,15246,15247,15248,15249,15250,15251,15252,15253, +15254,15255,15256,15257,15258,15259,15260,15261,15262,15263,15264,15265, +15266,15267,15268,15269,15270,15271,15272,15273,15274,15275,15276,15277, +15278,15279,15280,15281,15282,15283,15284,15285,15286,15287,15288,15289, +15290,15291,15292,15293,15294,15295,15296,15297,15298,15299,15300,15301, +15302,15303,15304,15305,15306,15307,15308,15309,15310,15311,15312,15313, +15314,15315,15316,15317,15318,15319,15320,15321,15322,15323,15324,15325, +15326,15327,15328,15329,15330,15331,15332,15333,15334,15335,15336,15337, +15338,15339,15340,15341,15342,15343,15344,15345,15346,15347,15348,15349, +15350,15351,15352,15353,15354,15355,15356,15357,15358,15359,15360,15361, +15362,15363,15364,15365,15366,15367,15368,15369,15370,15371,15372,15373, +15374,15375,15376,15377,15378,15379,15380,15381,15382,15383,15384,15385, +15386,15387,15388,15389,15390,15391,15392,15393,15394,15395,15396,15397, +15398,15399,15400,15401,15402,15403,15404,15405,15406,15407,15408,15409, +15410,15411,15412,15413,15414,15415,15416,15417,15418,15419,15420,15421, +15422,15423,15424,15425,15426,15427,15428,15429,15430,15431,15432,15433, +15434,15435,15436,15437,15438,15439,15440,15441,15442,15443,15444,15445, +15446,15447,15448,15449,15450,15451,15452,15453,15454,15455,15456,15457, +15458,15459,15460,15461,15462,15463,15464,15465,15466,15467,15468,15469, +15470,15471,15472,15473,15474,15475,15476,15477,15478,15479,15480,15481, +15482,15483,15484,15485,15486,15487,15488,15489,15490,15491,15492,15493, +15494,15495,15496,15497,15498,15499,15500,15501,15502,15503,15504,15505, +15506,15507,15508,15509,15510,15511,15512,15513,15514,15515,15516,15517, +15518,15519,15520,15521,15522,15523,15524,15525,15526,15527,15528,15529, +15530,15531,15532,15533,15534,15535,15536,15537,15538,15539,15540,15541, +15542,15543,15544,15545,15546,15547,15548,15549,15550,15551,15552,15553, +15554,15555,15556,15557,15558,15559,15560,15561,15562,15563,15564,15565, +15566,15567,15568,15569,15570,15571,15572,15573,15574,15575,15576,15577, +15578,15579,15580,15581,15582,15583,15584,15585,15586,15587,15588,15589, +15590,15591,15592,15593,15594,15595,15596,15597,15598,15599,15600,15601, +15602,15603,15604,15605,15606,15607,15608,15609,15610,15611,15612,15613, +15614,15615,15616,15617,15618,15619,15620,15621,15622,15623,15624,15625, +15626,15627,15628,15629,15630,15631,15632,15633,15634,15635,15636,15637, +15638,15639,15640,15641,15642,15643,15644,15645,15646,15647,15648,15649, +15650,15651,15652,15653,15654,15655,15656,15657,15658,15659,15660,15661, +15662,15663,15664,15665,15666,15667,15668,15669,15670,15671,15672,15673, +15674,15675,15676,15677,15678,15679,15680,15681,15682,15683,15684,15685, +15686,15687,15688,15689,15690,15691,15692,15693,15694,15695,15696,15697, +15698,15699,15700,15701,15702,15703,15704,15705,15706,15707,15708,15709, +15710,15711,15712,15713,15714,15715,15716,15717,15718,15719,15720,15721, +15722,15723,15724,15725,15726,15727,15728,15729,15730,15731,15732,15733, +15734,15735,15736,15737,15738,15739,15740,15741,15742,15743,15744,15745, +15746,15747,15748,15749,15750,15751,15752,15753,15754,15755,15756,15757, +15758,15759,15760,15761,15762,15763,15764,15765,15766,15767,15768,15769, +15770,15771,15772,15773,15774,15775,15776,15777,15778,15779,15780,15781, +15782,15783,15784,15785,15786,15787,15788,15789,15790,15791,15792,15793, +15794,15795,15796,15797,15798,15799,15800,15801,15802,15803,15804,15805, +15806,15807,15808,15809,15810,15811,15812,15813,15814,15815,15816,15817, +15818,15819,15820,15821,15822,15823,15824,15825,15826,15827,15828,15829, +15830,15831,15832,15833,15834,15835,15836,15837,15838,15839,15840,15841, +15842,15843,15844,15845,15846,15847,15848,15849,15850,15851,15852,15853, +15854,15855,15856,15857,15858,15859,15860,15861,15862,15863,15864,15865, +15866,15867,15868,15869,15870,15871,15872,15873,15874,15875,15876,15877, +15878,15879,15880,15881,15882,15883,15884,15885,15886,15887,15888,15889, +15890,15891,15892,15893,15894,15895,15896,15897,15898,15899,15900,15901, +15902,15903,15904,15905,15906,15907,15908,15909,15910,15911,15912,15913, +15914,15915,15916,15917,15918,15919,15920,15921,15922,15923,15924,15925, +15926,15927,15928,15929,15930,15931,15932,15933,15934,15935,15936,15937, +15938,15939,15940,15941,15942,15943,15944,15945,15946,15947,15948,15949, +15950,15951,15952,15953,15954,15955,15956,15957,15958,15959,15960,15961, +15962,15963,15964,15965,15966,15967,15968,15969,15970,15971,15972,15973, +15974,15975,15976,15977,15978,15979,15980,15981,15982,15983,15984,15985, +15986,15987,15988,15989,15990,15991,15992,15993,15994,15995,15996,15997, +15998,15999,16000,16001,16002,16003,16004,16005,16006,16007,16008,16009, +16010,16011,16012,16013,16014,16015,16016,16017,16018,16019,16020,16021, +16022,16023,16024,16025,16026,16027,16028,16029,16030,16031,16032,16033, +16034,16035,16036,16037,16038,16039,16040,16041,16042,16043,16044,16045, +16046,16047,16048,16049,16050,16051,16052,16053,16054,16055,16056,16057, +16058,16059,16060,16061,16062,16063,16064,16065,16066,16067,16068,16069, +16070,16071,16072,16073,16074,16075,16076,16077,16078,16079,16080,16081, +16082,16083,16084,16085,16086,16087,16088,16089,16090,16091,16092,16093, +16094,16095,16096,16097,16098,16099,16100,16101,16102,16103,16104,16105, +16106,16107,16108,16109,16110,16111,16112,16113,16114,16115,16116,16117, +16118,16119,16120,16121,16122,16123,16124,16125,16126,16127,16128,16129, +16130,16131,16132,16133,16134,16135,16136,16137,16138,16139,16140,16141, +16142,16143,16144,16145,16146,16147,16148,16149,16150,16151,16152,16153, +16154,16155,16156,16157,16158,16159,16160,16161,16162,16163,16164,16165, +16166,16167,16168,16169,16170,16171,16172,16173,16174,16175,16176,16177, +16178,16179,16180,16181,16182,16183,16184,16185,16186,16187,16188,16189, +16190,16191,16192,16193,16194,16195,16196,16197,16198,16199,16200,16201, +16202,16203,16204,16205,16206,16207,16208,16209,16210,16211,16212,16213, +16214,16215,16216,16217,16218,16219,16220,16221,16222,16223,16224,16225, +16226,16227,16228,16229,16230,16231,16232,16233,16234,16235,16236,16237, +16238,16239,16240,16241,16242,16243,16244,16245,16246,16247,16248,16249, +16250,16251,16252,16253,16254,16255,16256,16257,16258,16259,16260,16261, +16262,16263,16264,16265,16266,16267,16268,16269,16270,16271,16272,16273, +16274,16275,16276,16277,16278,16279,16280,16281,16282,16283,16284,16285, +16286,16287,16288,16289,16290,16291,16292,16293,16294,16295,16296,16297, +16298,16299,16300,16301,16302,16303,16304,16305,16306,16307,16308,16309, +16310,16311,16312,16313,16314,16315,16316,16317,16318,16319,16320,16321, +16322,16323,16324,16325,16326,16327,16328,16329,16330,16331,16332,16333, +16334,16335,16336,16337,16338,16339,16340,16341,16342,16343,16344,16345, +16346,16347,16348,16349,16350,16351,16352,16353,16354,16355,16356,16357, +16358,16359,16360,16361,16362,16363,16364,16365,16366,16367,16368,16369, +16370,16371,16372,16373,16374,16375,16376,16377,16378,16379,16380,16381, +16382,16383,16384,16385,16386,16387,16388,16389,16390,16391,16392,16393, +16394,16395,16396,16397,16398,16399,16400,16401,16402,16403,16404,16405, +16406,16407,16408,16409,16410,16411,16412,16413,16414,16415,16416,16417, +16418,16419,16420,16421,16422,16423,16424,16425,16426,16427,16428,16429, +16430,16431,16432,16433,16434,16435,16436,16437,16438,16439,16440,16441, +16442,16443,16444,16445,16446,16447,16448,16449,16450,16451,16452,16453, +16454,16455,16456,16457,16458,16459,16460,16461,16462,16463,16464,16465, +16466,16467,16468,16469,16470,16471,16472,16473,16474,16475,16476,16477, +16478,16479,16480,16481,16482,16483,16484,16485,16486,16487,16488,16489, +16490,16491,16492,16493,16494,16495,16496,16497,16498,16499,16500,16501, +16502,16503,16504,16505,16506,16507,16508,16509,16510,16511,16512,16513, +16514,16515,16516,16517,16518,16519,16520,16521,16522,16523,16524,16525, +16526,16527,16528,16529,16530,16531,16532,16533,16534,16535,16536,16537, +16538,16539,16540,16541,16542,16543,16544,16545,16546,16547,16548,16549, +16550,16551,16552,16553,16554,16555,16556,16557,16558,16559,16560,16561, +16562,16563,16564,16565,16566,16567,16568,16569,16570,16571,16572,16573, +16574,16575,16576,16577,16578,16579,16580,16581,16582,16583,16584,16585, +16586,16587,16588,16589,16590,16591,16592,16593,16594,16595,16596,16597, +16598,16599,16600,16601,16602,16603,16604,16605,16606,16607,16608,16609, +16610,16611,16612,16613,16614,16615,16616,16617,16618,16619,16620,16621, +16622,16623,16624,16625,16626,16627,16628,16629,16630,16631,16632,16633, +16634,16635,16636,16637,16638,16639,16640,16641,16642,16643,16644,16645, +16646,16647,16648,16649,16650,16651,16652,16653,16654,16655,16656,16657, +16658,16659,16660,16661,16662,16663,16664,16665,16666,16667,16668,16669, +16670,16671,16672,16673,16674,16675,16676,16677,16678,16679,16680,16681, +16682,16683,16684,16685,16686,16687,16688,16689,16690,16691,16692,16693, +16694,16695,16696,16697,16698,16699,16700,16701,16702,16703,16704,16705, +16706,16707,16708,16709,16710,16711,16712,16713,16714,16715,16716,16717, +16718,16719,16720,16721,16722,16723,16724,16725,16726,16727,16728,16729, +16730,16731,16732,16733,16734,16735,16736,16737,16738,16739,16740,16741, +16742,16743,16744,16745,16746,16747,16748,16749,16750,16751,16752,16753, +16754,16755,16756,16757,16758,16759,16760,16761,16762,16763,16764,16765, +16766,16767,16768,16769,16770,16771,16772,16773,16774,16775,16776,16777, +16778,16779,16780,16781,16782,16783,16784,16785,16786,16787,16788,16789, +16790,16791,16792,16793,16794,16795,16796,16797,16798,16799,16800,16801, +16802,16803,16804,16805,16806,16807,16808,16809,16810,16811,16812,16813, +16814,16815,16816,16817,16818,16819,16820,16821,16822,16823,16824,16825, +16826,16827,16828,16829,16830,16831,16832,16833,16834,16835,16836,16837, +16838,16839,16840,16841,16842,16843,16844,16845,16846,16847,16848,16849, +16850,16851,16852,16853,16854,16855,16856,16857,16858,16859,16860,16861, +16862,16863,16864,16865,16866,16867,16868,16869,16870,16871,16872,16873, +16874,16875,16876,16877,16878,16879,16880,16881,16882,16883,16884,16885, +16886,16887,16888,16889,16890,16891,16892,16893,16894,16895,16896,16897, +16898,16899,16900,16901,16902,16903,16904,16905,16906,16907,16908,16909, +16910,16911,16912,16913,16914,16915,16916,16917,16918,16919,16920,16921, +16922,16923,16924,16925,16926,16927,16928,16929,16930,16931,16932,16933, +16934,16935,16936,16937,16938,16939,16940,16941,16942,16943,16944,16945, +16946,16947,16948,16949,16950,16951,16952,16953,16954,16955,16956,16957, +16958,16959,16960,16961,16962,16963,16964,16965,16966,16967,16968,16969, +16970,16971,16972,16973,16974,16975,16976,16977,16978,16979,16980,16981, +16982,16983,16984,16985,16986,16987,16988,16989,16990,16991,16992,16993, +16994,16995,16996,16997,16998,16999,17000,17001,17002,17003,17004,17005, +17006,17007,17008,17009,17010,17011,17012,17013,17014,17015,17016,17017, +17018,17019,17020,17021,17022,17023,17024,17025,17026,17027,17028,17029, +17030,17031,17032,17033,17034,17035,17036,17037,17038,17039,17040,17041, +17042,17043,17044,17045,17046,17047,17048,17049,17050,17051,17052,17053, +17054,17055,17056,17057,17058,17059,17060,17061,17062,17063,17064,17065, +17066,17067,17068,17069,17070,17071,17072,17073,17074,17075,17076,17077, +17078,17079,17080,17081,17082,17083,17084,17085,17086,17087,17088,17089, +17090,17091,17092,17093,17094,17095,17096,17097,17098,17099,17100,17101, +17102,17103,17104,17105,17106,17107,17108,17109,17110,17111,17112,17113, +17114,17115,17116,17117,17118,17119,17120,17121,17122,17123,17124,17125, +17126,17127,17128,17129,17130,17131,17132,17133,17134,17135,17136,17137, +17138,17139,17140,17141,17142,17143,17144,17145,17146,17147,17148,17149, +17150,17151,17152,17153,17154,17155,17156,17157,17158,17159,17160,17161, +17162,17163,17164,17165,17166,17167,17168,17169,17170,17171,17172,17173, +17174,17175,17176,17177,17178,17179,17180,17181,17182,17183,17184,17185, +17186,17187,17188,17189,17190,17191,17192,17193,17194,17195,17196,17197, +17198,17199,17200,17201,17202,17203,17204,17205,17206,17207,17208,17209, +17210,17211,17212,17213,17214,17215,17216,17217,17218,17219,17220,17221, +17222,17223,17224,17225,17226,17227,17228,17229,17230,17231,17232,17233, +17234,17235,17236,17237,17238,17239,17240,17241,17242,17243,17244,17245, +17246,17247,17248,17249,17250,17251,17252,17253,17254,17255,17256,17257, +17258,17259,17260,17261,17262,17263,17264,17265,17266,17267,17268,17269, +17270,17271,17272,17273,17274,17275,17276,17277,17278,17279,17280,17281, +17282,17283,17284,17285,17286,17287,17288,17289,17290,17291,17292,17293, +17294,17295,17296,17297,17298,17299,17300,17301,17302,17303,17304,17305, +17306,17307,17308,17309,17310,17311,17312,17313,17314,17315,17316,17317, +17318,17319,17320,17321,17322,17323,17324,17325,17326,17327,17328,17329, +17330,17331,17332,17333,17334,17335,17336,17337,17338,17339,17340,17341, +17342,17343,17344,17345,17346,17347,17348,17349,17350,17351,17352,17353, +17354,17355,17356,17357,17358,17359,17360,17361,17362,17363,17364,17365, +17366,17367,17368,17369,17370,17371,17372,17373,17374,17375,17376,17377, +17378,17379,17380,17381,17382,17383,17384,17385,17386,17387,17388,17389, +17390,17391,17392,17393,17394,17395,17396,17397,17398,17399,17400,17401, +17402,17403,17404,17405,17406,17407,17408,17409,17410,17411,17412,17413, +17414,17415,17416,17417,17418,17419,17420,17421,17422,17423,17424,17425, +17426,17427,17428,17429,17430,17431,17432,17433,17434,17435,17436,17437, +17438,17439,17440,17441,17442,17443,17444,17445,17446,17447,17448,17449, +17450,17451,17452,17453,17454,17455,17456,17457,17458,17459,17460,17461, +17462,17463,17464,17465,17466,17467,17468,17469,17470,17471,17472,17473, +17474,17475,17476,17477,17478,17479,17480,17481,17482,17483,17484,17485, +17486,17487,17488,17489,17490,17491,17492,17493,17494,17495,17496,17497, +17498,17499,17500,17501,17502,17503,17504,17505,17506,17507,17508,17509, +17510,17511,17512,17513,17514,17515,17516,17517,17518,17519,17520,17521, +17522,17523,17524,17525,17526,17527,17528,17529,17530,17531,17532,17533, +17534,17535,17536,17537,17538,17539,17540,17541,17542,17543,17544,17545, +17546,17547,17548,17549,17550,17551,17552,17553,17554,17555,17556,17557, +17558,17559,17560,17561,17562,17563,17564,17565,17566,17567,17568,17569, +17570,17571,17572,17573,17574,17575,17576,17577,17578,17579,17580,17581, +17582,17583,17584,17585,17586,17587,17588,17589,17590,17591,17592,17593, +17594,17595,17596,17597,17598,17599,17600,17601,17602,17603,17604,17605, +17606,17607,17608,17609,17610,17611,17612,17613,17614,17615,17616,17617, +17618,17619,17620,17621,17622,17623,17624,17625,17626,17627,17628,17629, +17630,17631,17632,17633,17634,17635,17636,17637,17638,17639,17640,17641, +17642,17643,17644,17645,17646,17647,17648,17649,17650,17651,17652,17653, +17654,17655,17656,17657,17658,17659,17660,17661,17662,17663,17664,17665, +17666,17667,17668,17669,17670,17671,17672,17673,17674,17675,17676,17677, +17678,17679,17680,17681,17682,17683,17684,17685,17686,17687,17688,17689, +17690,17691,17692,17693,17694,17695,17696,17697,17698,17699,17700,17701, +17702,17703,17704,17705,17706,17707,17708,17709,17710,17711,17712,17713, +17714,17715,17716,17717,17718,17719,17720,17721,17722,17723,17724,17725, +17726,17727,17728,17729,17730,17731,17732,17733,17734,17735,17736,17737, +17738,17739,17740,17741,17742,17743,17744,17745,17746,17747,17748,17749, +17750,17751,17752,17753,17754,17755,17756,17757,17758,17759,17760,17761, +17762,17763,17764,17765,17766,17767,17768,17769,17770,17771,17772,17773, +17774,17775,17776,17777,17778,17779,17780,17781,17782,17783,17784,17785, +17786,17787,17788,17789,17790,17791,17792,17793,17794,17795,17796,17797, +17798,17799,17800,17801,17802,17803,17804,17805,17806,17807,17808,17809, +17810,17811,17812,17813,17814,17815,17816,17817,17818,17819,17820,17821, +17822,17823,17824,17825,17826,17827,17828,17829,17830,17831,17832,17833, +17834,17835,17836,17837,17838,17839,17840,17841,17842,17843,17844,17845, +17846,17847,17848,17849,17850,17851,17852,17853,17854,17855,17856,17857, +17858,17859,17860,17861,17862,17863,17864,17865,17866,17867,17868,17869, +17870,17871,17872,17873,17874,17875,17876,17877,17878,17879,17880,17881, +17882,17883,17884,17885,17886,17887,17888,17889,17890,17891,17892,17893, +17894,17895,17896,17897,17898,17899,17900,17901,17902,17903,17904,17905, +17906,17907,17908,17909,17910,17911,17912,17913,17914,17915,17916,17917, +17918,17919,17920,17921,17922,17923,17924,17925,17926,17927,17928,17929, +17930,17931,17932,17933,17934,17935,17936,17937,17938,17939,17940,17941, +17942,17943,17944,17945,17946,17947,17948,17949,17950,17951,17952,17953, +17954,17955,17956,17957,17958,17959,17960,17961,17962,17963,17964,17965, +17966,17967,17968,17969,17970,17971,17972,17973,17974,17975,17976,17977, +17978,17979,17980,17981,17982,17983,17984,17985,17986,17987,17988,17989, +17990,17991,17992,17993,17994,17995,17996,17997,17998,17999,18000,18001, +18002,18003,18004,18005,18006,18007,18008,18009,18010,18011,18012,18013, +18014,18015,18016,18017,18018,18019,18020,18021,18022,18023,18024,18025, +18026,18027,18028,18029,18030,18031,18032,18033,18034,18035,18036,18037, +18038,18039,18040,18041,18042,18043,18044,18045,18046,18047,18048,18049, +18050,18051,18052,18053,18054,18055,18056,18057,18058,18059,18060,18061, +18062,18063,18064,18065,18066,18067,18068,18069,18070,18071,18072,18073, +18074,18075,18076,18077,18078,18079,18080,18081,18082,18083,18084,18085, +18086,18087,18088,18089,18090,18091,18092,18093,18094,18095,18096,18097, +18098,18099,18100,18101,18102,18103,18104,18105,18106,18107,18108,18109, +18110,18111,18112,18113,18114,18115,18116,18117,18118,18119,18120,18121, +18122,18123,18124,18125,18126,18127,18128,18129,18130,18131,18132,18133, +18134,18135,18136,18137,18138,18139,18140,18141,18142,18143,18144,18145, +18146,18147,18148,18149,18150,18151,18152,18153,18154,18155,18156,18157, +18158,18159,18160,18161,18162,18163,18164,18165,18166,18167,18168,18169, +18170,18171,18172,18173,18174,18175,18176,18177,18178,18179,18180,18181, +18182,18183,18184,18185,18186,18187,18188,18189,18190,18191,18192,18193, +18194,18195,18196,18197,18198,18199,18200,18201,18202,18203,18204,18205, +18206,18207,18208,18209,18210,18211,18212,18213,18214,18215,18216,18217, +18218,18219,18220,18221,18222,18223,18224,18225,18226,18227,18228,18229, +18230,18231,18232,18233,18234,18235,18236,18237,18238,18239,18240,18241, +18242,18243,18244,18245,18246,18247,18248,18249,18250,18251,18252,18253, +18254,18255,18256,18257,18258,18259,18260,18261,18262,18263,18264,18265, +18266,18267,18268,18269,18270,18271,18272,18273,18274,18275,18276,18277, +18278,18279,18280,18281,18282,18283,18284,18285,18286,18287,18288,18289, +18290,18291,18292,18293,18294,18295,18296,18297,18298,18299,18300,18301, +18302,18303,18304,18305,18306,18307,18308,18309,18310,18311,18312,18313, +18314,18315,18316,18317,18318,18319,18320,18321,18322,18323,18324,18325, +18326,18327,18328,18329,18330,18331,18332,18333,18334,18335,18336,18337, +18338,18339,18340,18341,18342,18343,18344,18345,18346,18347,18348,18349, +18350,18351,18352,18353,18354,18355,18356,18357,18358,18359,18360,18361, +18362,18363,18364,18365,18366,18367,18368,18369,18370,18371,18372,18373, +18374,18375,18376,18377,18378,18379,18380,18381,18382,18383,18384,18385, +18386,18387,18388,18389,18390,18391,18392,18393,18394,18395,18396,18397, +18398,18399,18400,18401,18402,18403,18404,18405,18406,18407,18408,18409, +18410,18411,18412,18413,18414,18415,18416,18417,18418,18419,18420,18421, +18422,18423,18424,18425,18426,18427,18428,18429,18430,18431,18432,18433, +18434,18435,18436,18437,18438,18439,18440,18441,18442,18443,18444,18445, +18446,18447,18448,18449,18450,18451,18452,18453,18454,18455,18456,18457, +18458,18459,18460,18461,18462,18463,18464,18465,18466,18467,18468,18469, +18470,18471,18472,18473,18474,18475,18476,18477,18478,18479,18480,18481, +18482,18483,18484,18485,18486,18487,18488,18489,18490,18491,18492,18493, +18494,18495,18496,18497,18498,18499,18500,18501,18502,18503,18504,18505, +18506,18507,18508,18509,18510,18511,18512,18513,18514,18515,18516,18517, +18518,18519,18520,18521,18522,18523,18524,18525,18526,18527,18528,18529, +18530,18531,18532,18533,18534,18535,18536,18537,18538,18539,18540,18541, +18542,18543,18544,18545,18546,18547,18548,18549,18550,18551,18552,18553, +18554,18555,18556,18557,18558,18559,18560,18561,18562,18563,18564,18565, +18566,18567,18568,18569,18570,18571,18572,18573,18574,18575,18576,18577, +18578,18579,18580,18581,18582,18583,18584,18585,18586,18587,18588,18589, +18590,18591,18592,18593,18594,18595,18596,18597,18598,18599,18600,18601, +18602,18603,18604,18605,18606,18607,18608,18609,18610,18611,18612,18613, +18614,18615,18616,18617,18618,18619,18620,18621,18622,18623,18624,18625, +18626,18627,18628,18629,18630,18631,18632,18633,18634,18635,18636,18637, +18638,18639,18640,18641,18642,18643,18644,18645,18646,18647,18648,18649, +18650,18651,18652,18653,18654,18655,18656,18657,18658,18659,18660,18661, +18662,18663,18664,18665,18666,18667,18668,18669,18670,18671,18672,18673, +18674,18675,18676,18677,18678,18679,18680,18681,18682,18683,18684,18685, +18686,18687,18688,18689,18690,18691,18692,18693,18694,18695,18696,18697, +18698,18699,18700,18701,18702,18703,18704,18705,18706,18707,18708,18709, +18710,18711,18712,18713,18714,18715,18716,18717,18718,18719,18720,18721, +18722,18723,18724,18725,18726,18727,18728,18729,18730,18731,18732,18733, +18734,18735,18736,18737,18738,18739,18740,18741,18742,18743,18744,18745, +18746,18747,18748,18749,18750,18751,18752,18753,18754,18755,18756,18757, +18758,18759,18760,18761,18762,18763,18764,18765,18766,18767,18768,18769, +18770,18771,18772,18773,18774,18775,18776,18777,18778,18779,18780,18781, +18782,18783,18784,18785,18786,18787,18788,18789,18790,18791,18792,18793, +18794,18795,18796,18797,18798,18799,18800,18801,18802,18803,18804,18805, +18806,18807,18808,18809,18810,18811,18812,18813,18814,18815,18816,18817, +18818,18819,18820,18821,18822,18823,18824,18825,18826,18827,18828,18829, +18830,18831,18832,18833,18834,18835,18836,18837,18838,18839,18840,18841, +18842,18843,18844,18845,18846,18847,18848,18849,18850,18851,18852,18853, +18854,18855,18856,18857,18858,18859,18860,18861,18862,18863,18864,18865, +18866,18867,18868,18869,18870,18871,18872,18873,18874,18875,18876,18877, +18878,18879,18880,18881,18882,18883,18884,18885,18886,18887,18888,18889, +18890,18891,18892,18893,18894,18895,18896,18897,18898,18899,18900,18901, +18902,18903,18904,18905,18906,18907,18908,18909,18910,18911,18912,18913, +18914,18915,18916,18917,18918,18919,18920,18921,18922,18923,18924,18925, +18926,18927,18928,18929,18930,18931,18932,18933,18934,18935,18936,18937, +18938,18939,18940,18941,18942,18943,18944,18945,18946,18947,18948,18949, +18950,18951,18952,18953,18954,18955,18956,18957,18958,18959,18960,18961, +18962,18963,18964,18965,18966,18967,18968,18969,18970,18971,18972,18973, +18974,18975,18976,18977,18978,18979,18980,18981,18982,18983,18984,18985, +18986,18987,18988,18989,18990,18991,18992,18993,18994,18995,18996,18997, +18998,18999,19000,19001,19002,19003,19004,19005,19006,19007,19008,19009, +19010,19011,19012,19013,19014,19015,19016,19017,19018,19019,19020,19021, +19022,19023,19024,19025,19026,19027,19028,19029,19030,19031,19032,19033, +19034,19035,19036,19037,19038,19039,19040,19041,19042,19043,19044,19045, +19046,19047,19048,19049,19050,19051,19052,19053,19054,19055,19056,19057, +19058,19059,19060,19061,19062,19063,19064,19065,19066,19067,19068,19069, +19070,19071,19072,19073,19074,19075,19076,19077,19078,19079,19080,19081, +19082,19083,19084,19085,19086,19087,19088,19089,19090,19091,19092,19093, +19094,19095,19096,19097,19098,19099,19100,19101,19102,19103,19104,19105, +19106,19107,19108,19109,19110,19111,19112,19113,19114,19115,19116,19117, +19118,19119,19120,19121,19122,19123,19124,19125,19126,19127,19128,19129, +19130,19131,19132,19133,19134,19135,19136,19137,19138,19139,19140,19141, +19142,19143,19144,19145,19146,19147,19148,19149,19150,19151,19152,19153, +19154,19155,19156,19157,19158,19159,19160,19161,19162,19163,19164,19165, +19166,19167,19168,19169,19170,19171,19172,19173,19174,19175,19176,19177, +19178,19179,19180,19181,19182,19183,19184,19185,19186,19187,19188,19189, +19190,19191,19192,19193,19194,19195,19196,19197,19198,19199,19200,19201, +19202,19203,19204,19205,19206,19207,19208,19209,19210,19211,19212,19213, +19214,19215,19216,19217,19218,19219,19220,19221,19222,19223,19224,19225, +19226,19227,19228,19229,19230,19231,19232,19233,19234,19235,19236,19237, +19238,19239,19240,19241,19242,19243,19244,19245,19246,19247,19248,19249, +19250,19251,19252,19253,19254,19255,19256,19257,19258,19259,19260,19261, +19262,19263,19264,19265,19266,19267,19268,19269,19270,19271,19272,19273, +19274,19275,19276,19277,19278,19279,19280,19281,19282,19283,19284,19285, +19286,19287,19288,19289,19290,19291,19292,19293,19294,19295,19296,19297, +19298,19299,19300,19301,19302,19303,19304,19305,19306,19307,19308,19309, +19310,19311,19312,19313,19314,19315,19316,19317,19318,19319,19320,19321, +19322,19323,19324,19325,19326,19327,19328,19329,19330,19331,19332,19333, +19334,19335,19336,19337,19338,19339,19340,19341,19342,19343,19344,19345, +19346,19347,19348,19349,19350,19351,19352,19353,19354,19355,19356,19357, +19358,19359,19360,19361,19362,19363,19364,19365,19366,19367,19368,19369, +19370,19371,19372,19373,19374,19375,19376,19377,19378,19379,19380,19381, +19382,19383,19384,19385,19386,19387,19388,19389,19390,19391,19392,19393, +19394,19395,19396,19397,19398,19399,19400,19401,19402,19403,19404,19405, +19406,19407,19408,19409,19410,19411,19412,19413,19414,19415,19416,19417, +19418,19419,19420,19421,19422,19423,19424,19425,19426,19427,19428,19429, +19430,19431,19432,19433,19434,19435,19436,19437,19438,19439,19440,19441, +19442,19443,19444,19445,19446,19447,19448,19449,19450,19451,19452,19453, +19454,19455,19456,19457,19458,19459,19460,19461,19462,19463,19464,19465, +19466,19467,19468,19469,19470,19471,19472,19473,19474,19475,19476,19477, +19478,19479,19480,19481,19482,19483,19484,19485,19486,19487,19488,19489, +19490,19491,19492,19493,19494,19495,19496,19497,19498,19499,19500,19501, +19502,19503,19504,19505,19506,19507,19508,19509,19510,19511,19512,19513, +19514,19515,19516,19517,19518,19519,19520,19521,19522,19523,19524,19525, +19526,19527,19528,19529,19530,19531,19532,19533,19534,19535,19536,19537, +19538,19539,19540,19541,19542,19543,19544,19545,19546,19547,19548,19549, +19550,19551,19552,19553,19554,19555,19556,19557,19558,19559,19560,19561, +19562,19563,19564,19565,19566,19567,19568,19569,19570,19571,19572,19573, +19574,19575,19576,19577,19578,19579,19580,19581,19582,19583,19584,19585, +19586,19587,19588,19589,19590,19591,19592,19593,19594,19595,19596,19597, +19598,19599,19600,19601,19602,19603,19604,19605,19606,19607,19608,19609, +19610,19611,19612,19613,19614,19615,19616,19617,19618,19619,19620,19621, +19622,19623,19624,19625,19626,19627,19628,19629,19630,19631,19632,19633, +19634,19635,19636,19637,19638,19639,19640,19641,19642,19643,19644,19645, +19646,19647,19648,19649,19650,19651,19652,19653,19654,19655,19656,19657, +19658,19659,19660,19661,19662,19663,19664,19665,19666,19667,19668,19669, +19670,19671,19672,19673,19674,19675,19676,19677,19678,19679,19680,19681, +19682,19683,19684,19685,19686,19687,19688,19689,19690,19691,19692,19693, +19694,19695,19696,19697,19698,19699,19700,19701,19702,19703,19704,19705, +19706,19707,19708,19709,19710,19711,19712,19713,19714,19715,19716,19717, +19718,19719,19720,19721,19722,19723,19724,19725,19726,19727,19728,19729, +19730,19731,19732,19733,19734,19735,19736,19737,19738,19739,19740,19741, +19742,19743,19744,19745,19746,19747,19748,19749,19750,19751,19752,19753, +19754,19755,19756,19757,19758,19759,19760,19761,19762,19763,19764,19765, +19766,19767,19768,19769,19770,19771,19772,19773,19774,19775,19776,19777, +19778,19779,19780,19781,19782,19783,19784,19785,19786,19787,19788,19789, +19790,19791,19792,19793,19794,19795,19796,19797,19798,19799,19800,19801, +19802,19803,19804,19805,19806,19807,19808,19809,19810,19811,19812,19813, +19814,19815,19816,19817,19818,19819,19820,19821,19822,19823,19824,19825, +19826,19827,19828,19829,19830,19831,19832,19833,19834,19835,19836,19837, +19838,19839,19840,19841,19842,19843,19844,19845,19846,19847,19848,19849, +19850,19851,19852,19853,19854,19855,19856,19857,19858,19859,19860,19861, +19862,19863,19864,19865,19866,19867,19868,19869,19870,19871,19872,19873, +19874,19875,19876,19877,19878,19879,19880,19881,19882,19883,19884,19885, +19886,19887,19888,19889,19890,19891,19892,19893,19894,19895,19896,19897, +19898,19899,19900,19901,19902,19903,19904,19905,19906,19907,19908,19909, +19910,19911,19912,19913,19914,19915,19916,19917,19918,19919,19920,19921, +19922,19923,19924,19925,19926,19927,19928,19929,19930,19931,19932,19933, +19934,19935,19936,19937,19938,19939,19940,19941,19942,19943,19944,19945, +19946,19947,19948,19949,19950,19951,19952,19953,19954,19955,19956,19957, +19958,19959,19960,19961,19962,19963,19964,19965,19966,19967,19968,19969, +19970,19971,19972,19973,19974,19975,19976,19977,19978,19979,19980,19981, +19982,19983,19984,19985,19986,19987,19988,19989,19990,19991,19992,19993, +19994,19995,19996,19997,19998,19999,20000,20001,20002,20003,20004,20005, +20006,20007,20008,20009,20010,20011,20012,20013,20014,20015,20016,20017, +20018,20019,20020,20021,20022,20023,20024,20025,20026,20027,20028,20029, +20030,20031,20032,20033,20034,20035,20036,20037,20038,20039,20040,20041, +20042,20043,20044,20045,20046,20047,20048,20049,20050,20051,20052,20053, +20054,20055,20056,20057,20058,20059,20060,20061,20062,20063,20064,20065, +20066,20067,20068,20069,20070,20071,20072,20073,20074,20075,20076,20077, +20078,20079,20080,20081,20082,20083,20084,20085,20086,20087,20088,20089, +20090,20091,20092,20093,20094,20095,20096,20097,20098,20099,20100,20101, +20102,20103,20104,20105,20106,20107,20108,20109,20110,20111,20112,20113, +20114,20115,20116,20117,20118,20119,20120,20121,20122,20123,20124,20125, +20126,20127,20128,20129,20130,20131,20132,20133,20134,20135,20136,20137, +20138,20139,20140,20141,20142,20143,20144,20145,20146,20147,20148,20149, +20150,20151,20152,20153,20154,20155,20156,20157,20158,20159,20160,20161, +20162,20163,20164,20165,20166,20167,20168,20169,20170,20171,20172,20173, +20174,20175,20176,20177,20178,20179,20180,20181,20182,20183,20184,20185, +20186,20187,20188,20189,20190,20191,20192,20193,20194,20195,20196,20197, +20198,20199,20200,20201,20202,20203,20204,20205,20206,20207,20208,20209, +20210,20211,20212,20213,20214,20215,20216,20217,20218,20219,20220,20221, +20222,20223,20224,20225,20226,20227,20228,20229,20230,20231,20232,20233, +20234,20235,20236,20237,20238,20239,20240,20241,20242,20243,20244,20245, +20246,20247,20248,20249,20250,20251,20252,20253,20254,20255,20256,20257, +20258,20259,20260,20261,20262,20263,20264,20265,20266,20267,20268,20269, +20270,20271,20272,20273,20274,20275,20276,20277,20278,20279,20280,20281, +20282,20283,20284,20285,20286,20287,20288,20289,20290,20291,20292,20293, +20294,20295,20296,20297,20298,20299,20300,20301,20302,20303,20304,20305, +20306,20307,20308,20309,20310,20311,20312,20313,20314,20315,20316,20317, +20318,20319,20320,20321,20322,20323,20324,20325,20326,20327,20328,20329, +20330,20331,20332,20333,20334,20335,20336,20337,20338,20339,20340,20341, +20342,20343,20344,20345,20346,20347,20348,20349,20350,20351,20352,20353, +20354,20355,20356,20357,20358,20359,20360,20361,20362,20363,20364,20365, +20366,20367,20368,20369,20370,20371,20372,20373,20374,20375,20376,20377, +20378,20379,20380,20381,20382,20383,20384,20385,20386,20387,20388,20389, +20390,20391,20392,20393,20394,20395,20396,20397,20398,20399,20400,20401, +20402,20403,20404,20405,20406,20407,20408,20409,20410,20411,20412,20413, +20414,20415,20416,20417,20418,20419,20420,20421,20422,20423,20424,20425, +20426,20427,20428,20429,20430,20431,20432,20433,20434,20435,20436,20437, +20438,20439,20440,20441,20442,20443,20444,20445,20446,20447,20448,20449, +20450,20451,20452,20453,20454,20455,20456,20457,20458,20459,20460,20461, +20462,20463,20464,20465,20466,20467,20468,20469,20470,20471,20472,20473, +20474,20475,20476,20477,20478,20479,20480,20481,20482,20483,20484,20485, +20486,20487,20488,20489,20490,20491,20492,20493,20494,20495,20496,20497, +20498,20499,20500,20501,20502,20503,20504,20505,20506,20507,20508,20509, +20510,20511,20512,20513,20514,20515,20516,20517,20518,20519,20520,20521, +20522,20523,20524,20525,20526,20527,20528,20529,20530,20531,20532,20533, +20534,20535,20536,20537,20538,20539,20540,20541,20542,20543,20544,20545, +20546,20547,20548,20549,20550,20551,20552,20553,20554,20555,20556,20557, +20558,20559,20560,20561,20562,20563,20564,20565,20566,20567,20568,20569, +20570,20571,20572,20573,20574,20575,20576,20577,20578,20579,20580,20581, +20582,20583,20584,20585,20586,20587,20588,20589,20590,20591,20592,20593, +20594,20595,20596,20597,20598,20599,20600,20601,20602,20603,20604,20605, +20606,20607,20608,20609,20610,20611,20612,20613,20614,20615,20616,20617, +20618,20619,20620,20621,20622,20623,20624,20625,20626,20627,20628,20629, +20630,20631,20632,20633,20634,20635,20636,20637,20638,20639,20640,20641, +20642,20643,20644,20645,20646,20647,20648,20649,20650,20651,20652,20653, +20654,20655,20656,20657,20658,20659,20660,20661,20662,20663,20664,20665, +20666,20667,20668,20669,20670,20671,20672,20673,20674,20675,20676,20677, +20678,20679,20680,20681,20682,20683,20684,20685,20686,20687,20688,20689, +20690,20691,20692,20693,20694,20695,20696,20697,20698,20699,20700,20701, +20702,20703,20704,20705,20706,20707,20708,20709,20710,20711,20712,20713, +20714,20715,20716,20717,20718,20719,20720,20721,20722,20723,20724,20725, +20726,20727,20728,20729,20730,20731,20732,20733,20734,20735,20736,20737, +20738,20739,20740,20741,20742,20743,20744,20745,20746,20747,20748,20749, +20750,20751,20752,20753,20754,20755,20756,20757,20758,20759,20760,20761, +20762,20763,20764,20765,20766,20767,20768,20769,20770,20771,20772,20773, +20774,20775,20776,20777,20778,20779,20780,20781,20782,20783,20784,20785, +20786,20787,20788,20789,20790,20791,20792,20793,20794,20795,20796,20797, +20798,20799,20800,20801,20802,20803,20804,20805,20806,20807,20808,20809, +20810,20811,20812,20813,20814,20815,20816,20817,20818,20819,20820,20821, +20822,20823,20824,20825,20826,20827,20828,20829,20830,20831,20832,20833, +20834,20835,20836,20837,20838,20839,20840,20841,20842,20843,20844,20845, +20846,20847,20848,20849,20850,20851,20852,20853,20854,20855,20856,20857, +20858,20859,20860,20861,20862,20863,20864,20865,20866,20867,20868,20869, +20870,20871,20872,20873,20874,20875,20876,20877,20878,20879,20880,20881, +20882,20883,20884,20885,20886,20887,20888,20889,20890,20891,20892,20893, +20894,20895,20896,20897,20898,20899,20900,20901,20902,20903,20904,20905, +20906,20907,20908,20909,20910,20911,20912,20913,20914,20915,20916,20917, +20918,20919,20920,20921,20922,20923,20924,20925,20926,20927,20928,20929, +20930,20931,20932,20933,20934,20935,20936,20937,20938,20939,20940,20941, +20942,20943,20944,20945,20946,20947,20948,20949,20950,20951,20952,20953, +20954,20955,20956,20957,20958,20959,20960,20961,20962,20963,20964,20965, +20966,20967,20968,20969,20970,20971,20972,20973,20974,20975,20976,20977, +20978,20979,20980,20981,20982,20983,20984,20985,20986,20987,20988,20989, +20990,20991,20992,20993,20994,20995,20996,20997,20998,20999,21000,21001, +21002,21003,21004,21005,21006,21007,21008,21009,21010,21011,21012,21013, +21014,21015,21016,21017,21018,21019,21020,21021,21022,21023,21024,21025, +21026,21027,21028,21029,21030,21031,21032,21033,21034,21035,21036,21037, +21038,21039,21040,21041,21042,21043,21044,21045,21046,21047,21048,21049, +21050,21051,21052,21053,21054,21055,21056,21057,21058,21059,21060,21061, +21062,21063,21064,21065,21066,21067,21068,21069,21070,21071,21072,21073, +21074,21075,21076,21077,21078,21079,21080,21081,21082,21083,21084,21085, +21086,21087,21088,21089,21090,21091,21092,21093,21094,21095,21096,21097, +21098,21099,21100,21101,21102,21103,21104,21105,21106,21107,21108,21109, +21110,21111,21112,21113,21114,21115,21116,21117,21118,21119,21120,21121, +21122,21123,21124,21125,21126,21127,21128,21129,21130,21131,21132,21133, +21134,21135,21136,21137,21138,21139,21140,21141,21142,21143,21144,21145, +21146,21147,21148,21149,21150,21151,21152,21153,21154,21155,21156,21157, +21158,21159,21160,21161,21162,21163,21164,21165,21166,21167,21168,21169, +21170,21171,21172,21173,21174,21175,21176,21177,21178,21179,21180,21181, +21182,21183,21184,21185,21186,21187,21188,21189,21190,21191,21192,21193, +21194,21195,21196,21197,21198,21199,21200,21201,21202,21203,21204,21205, +21206,21207,21208,21209,21210,21211,21212,21213,21214,21215,21216,21217, +21218,21219,21220,21221,21222,21223,21224,21225,21226,21227,21228,21229, +21230,21231,21232,21233,21234,21235,21236,21237,21238,21239,21240,21241, +21242,21243,21244,21245,21246,21247,21248,21249,21250,21251,21252,21253, +21254,21255,21256,21257,21258,21259,21260,21261,21262,21263,21264,21265, +21266,21267,21268,21269,21270,21271,21272,21273,21274,21275,21276,21277, +21278,21279,21280,21281,21282,21283,21284,21285,21286,21287,21288,21289, +21290,21291,21292,21293,21294,21295,21296,21297,21298,21299,21300,21301, +21302,21303,21304,21305,21306,21307,21308,21309,21310,21311,21312,21313, +21314,21315,21316,21317,21318,21319,21320,21321,21322,21323,21324,21325, +21326,21327,21328,21329,21330,21331,21332,21333,21334,21335,21336,21337, +21338,21339,21340,21341,21342,21343,21344,21345,21346,21347,21348,21349, +21350,21351,21352,21353,21354,21355,21356,21357,21358,21359,21360,21361, +21362,21363,21364,21365,21366,21367,21368,21369,21370,21371,21372,21373, +21374,21375,21376,21377,21378,21379,21380,21381,21382,21383,21384,21385, +21386,21387,21388,21389,21390,21391,21392,21393,21394,21395,21396,21397, +21398,21399,21400,21401,21402,21403,21404,21405,21406,21407,21408,21409, +21410,21411,21412,21413,21414,21415,21416,21417,21418,21419,21420,21421, +21422,21423,21424,21425,21426,21427,21428,21429,21430,21431,21432,21433, +21434,21435,21436,21437,21438,21439,21440,21441,21442,21443,21444,21445, +21446,21447,21448,21449,21450,21451,21452,21453,21454,21455,21456,21457, +21458,21459,21460,21461,21462,21463,21464,21465,21466,21467,21468,21469, +21470,21471,21472,21473,21474,21475,21476,21477,21478,21479,21480,21481, +21482,21483,21484,21485,21486,21487,21488,21489,21490,21491,21492,21493, +21494,21495,21496,21497,21498,21499,21500,21501,21502,21503,21504,21505, +21506,21507,21508,21509,21510,21511,21512,21513,21514,21515,21516,21517, +21518,21519,21520,21521,21522,21523,21524,21525,21526,21527,21528,21529, +21530,21531,21532,21533,21534,21535,21536,21537,21538,21539,21540,21541, +21542,21543,21544,21545,21546,21547,21548,21549,21550,21551,21552,21553, +21554,21555,21556,21557,21558,21559,21560,21561,21562,21563,21564,21565, +21566,21567,21568,21569,21570,21571,21572,21573,21574,21575,21576,21577, +21578,21579,21580,21581,21582,21583,21584,21585,21586,21587,21588,21589, +21590,21591,21592,21593,21594,21595,21596,21597,21598,21599,21600,21601, +21602,21603,21604,21605,21606,21607,21608,21609,21610,21611,21612,21613, +21614,21615,21616,21617,21618,21619,21620,21621,21622,21623,21624,21625, +21626,21627,21628,21629,21630,21631,21632,21633,21634,21635,21636,21637, +21638,21639,21640,21641,21642,21643,21644,21645,21646,21647,21648,21649, +21650,21651,21652,21653,21654,21655,21656,21657,21658,21659,21660,21661, +21662,21663,21664,21665,21666,21667,21668,21669,21670,21671,21672,21673, +21674,21675,21676,21677,21678,21679,21680,21681,21682,21683,21684,21685, +21686,21687,21688,21689,21690,21691,21692,21693,21694,21695,21696,21697, +21698,21699,21700,21701,21702,21703,21704,21705,21706,21707,21708,21709, +21710,21711,21712,21713,21714,21715,21716,21717,21718,21719,21720,21721, +21722,21723,21724,21725,21726,21727,21728,21729,21730,21731,21732,21733, +21734,21735,21736,21737,21738,21739,21740,21741,21742,21743,21744,21745, +21746,21747,21748,21749,21750,21751,21752,21753,21754,21755,21756,21757, +21758,21759,21760,21761,21762,21763,21764,21765,21766,21767,21768,21769, +21770,21771,21772,21773,21774,21775,21776,21777,21778,21779,21780,21781, +21782,21783,21784,21785,21786,21787,21788,21789,21790,21791,21792,21793, +21794,21795,21796,21797,21798,21799,21800,21801,21802,21803,21804,21805, +21806,21807,21808,21809,21810,21811,21812,21813,21814,21815,21816,21817, +21818,21819,21820,21821,21822,21823,21824,21825,21826,21827,21828,21829, +21830,21831,21832,21833,21834,21835,21836,21837,21838,21839,21840,21841, +21842,21843,21844,21845,21846,21847,21848,21849,21850,21851,21852,21853, +21854,21855,21856,21857,21858,21859,21860,21861,21862,21863,21864,21865, +21866,21867,21868,21869,21870,21871,21872,21873,21874,21875,21876,21877, +21878,21879,21880,21881,21882,21883,21884,21885,21886,21887,21888,21889, +21890,21891,21892,21893,21894,21895,21896,21897,21898,21899,21900,21901, +21902,21903,21904,21905,21906,21907,21908,21909,21910,21911,21912,21913, +21914,21915,21916,21917,21918,21919,21920,21921,21922,21923,21924,21925, +21926,21927,21928,21929,21930,21931,21932,21933,21934,21935,21936,21937, +21938,21939,21940,21941,21942,21943,21944,21945,21946,21947,21948,21949, +21950,21951,21952,21953,21954,21955,21956,21957,21958,21959,21960,21961, +21962,21963,21964,21965,21966,21967,21968,21969,21970,21971,21972,21973, +21974,21975,21976,21977,21978,21979,21980,21981,21982,21983,21984,21985, +21986,21987,21988,21989,21990,21991,21992,21993,21994,21995,21996,21997, +21998,21999,22000,22001,22002,22003,22004,22005,22006,22007,22008,22009, +22010,22011,22012,22013,22014,22015,22016,22017,22018,22019,22020,22021, +22022,22023,22024,22025,22026,22027,22028,22029,22030,22031,22032,22033, +22034,22035,22036,22037,22038,22039,22040,22041,22042,22043,22044,22045, +22046,22047,22048,22049,22050,22051,22052,22053,22054,22055,22056,22057, +22058,22059,22060,22061,22062,22063,22064,22065,22066,22067,22068,22069, +22070,22071,22072,22073,22074,22075,22076,22077,22078,22079,22080,22081, +22082,22083,22084,22085,22086,22087,22088,22089,22090,22091,22092,22093, +22094,22095,22096,22097,22098,22099,22100,22101,22102,22103,22104,22105, +22106,22107,22108,22109,22110,22111,22112,22113,22114,22115,22116,22117, +22118,22119,22120,22121,22122,22123,22124,22125,22126,22127,22128,22129, +22130,22131,22132,22133,22134,22135,22136,22137,22138,22139,22140,22141, +22142,22143,22144,22145,22146,22147,22148,22149,22150,22151,22152,22153, +22154,22155,22156,22157,22158,22159,22160,22161,22162,22163,22164,22165, +22166,22167,22168,22169,22170,22171,22172,22173,22174,22175,22176,22177, +22178,22179,22180,22181,22182,22183,22184,22185,22186,22187,22188,22189, +22190,22191,22192,22193,22194,22195,22196,22197,22198,22199,22200,22201, +22202,22203,22204,22205,22206,22207,22208,22209,22210,22211,22212,22213, +22214,22215,22216,22217,22218,22219,22220,22221,22222,22223,22224,22225, +22226,22227,22228,22229,22230,22231,22232,22233,22234,22235,22236,22237, +22238,22239,22240,22241,22242,22243,22244,22245,22246,22247,22248,22249, +22250,22251,22252,22253,22254,22255,22256,22257,22258,22259,22260,22261, +22262,22263,22264,22265,22266,22267,22268,22269,22270,22271,22272,22273, +22274,22275,22276,22277,22278,22279,22280,22281,22282,22283,22284,22285, +22286,22287,22288,22289,22290,22291,22292,22293,22294,22295,22296,22297, +22298,22299,22300,22301,22302,22303,22304,22305,22306,22307,22308,22309, +22310,22311,22312,22313,22314,22315,22316,22317,22318,22319,22320,22321, +22322,22323,22324,22325,22326,22327,22328,22329,22330,22331,22332,22333, +22334,22335,22336,22337,22338,22339,22340,22341,22342,22343,22344,22345, +22346,22347,22348,22349,22350,22351,22352,22353,22354,22355,22356,22357, +22358,22359,22360,22361,22362,22363,22364,22365,22366,22367,22368,22369, +22370,22371,22372,22373,22374,22375,22376,22377,22378,22379,22380,22381, +22382,22383,22384,22385,22386,22387,22388,22389,22390,22391,22392,22393, +22394,22395,22396,22397,22398,22399,22400,22401,22402,22403,22404,22405, +22406,22407,22408,22409,22410,22411,22412,22413,22414,22415,22416,22417, +22418,22419,22420,22421,22422,22423,22424,22425,22426,22427,22428,22429, +22430,22431,22432,22433,22434,22435,22436,22437,22438,22439,22440,22441, +22442,22443,22444,22445,22446,22447,22448,22449,22450,22451,22452,22453, +22454,22455,22456,22457,22458,22459,22460,22461,22462,22463,22464,22465, +22466,22467,22468,22469,22470,22471,22472,22473,22474,22475,22476,22477, +22478,22479,22480,22481,22482,22483,22484,22485,22486,22487,22488,22489, +22490,22491,22492,22493,22494,22495,22496,22497,22498,22499,22500,22501, +22502,22503,22504,22505,22506,22507,22508,22509,22510,22511,22512,22513, +22514,22515,22516,22517,22518,22519,22520,22521,22522,22523,22524,22525, +22526,22527,22528,22529,22530,22531,22532,22533,22534,22535,22536,22537, +22538,22539,22540,22541,22542,22543,22544,22545,22546,22547,22548,22549, +22550,22551,22552,22553,22554,22555,22556,22557,22558,22559,22560,22561, +22562,22563,22564,22565,22566,22567,22568,22569,22570,22571,22572,22573, +22574,22575,22576,22577,22578,22579,22580,22581,22582,22583,22584,22585, +22586,22587,22588,22589,22590,22591,22592,22593,22594,22595,22596,22597, +22598,22599,22600,22601,22602,22603,22604,22605,22606,22607,22608,22609, +22610,22611,22612,22613,22614,22615,22616,22617,22618,22619,22620,22621, +22622,22623,22624,22625,22626,22627,22628,22629,22630,22631,22632,22633, +22634,22635,22636,22637,22638,22639,22640,22641,22642,22643,22644,22645, +22646,22647,22648,22649,22650,22651,22652,22653,22654,22655,22656,22657, +22658,22659,22660,22661,22662,22663,22664,22665,22666,22667,22668,22669, +22670,22671,22672,22673,22674,22675,22676,22677,22678,22679,22680,22681, +22682,22683,22684,22685,22686,22687,22688,22689,22690,22691,22692,22693, +22694,22695,22696,22697,22698,22699,22700,22701,22702,22703,22704,22705, +22706,22707,22708,22709,22710,22711,22712,22713,22714,22715,22716,22717, +22718,22719,22720,22721,22722,22723,22724,22725,22726,22727,22728,22729, +22730,22731,22732,22733,22734,22735,22736,22737,22738,22739,22740,22741, +22742,22743,22744,22745,22746,22747,22748,22749,22750,22751,22752,22753, +22754,22755,22756,22757,22758,22759,22760,22761,22762,22763,22764,22765, +22766,22767,22768,22769,22770,22771,22772,22773,22774,22775,22776,22777, +22778,22779,22780,22781,22782,22783,22784,22785,22786,22787,22788,22789, +22790,22791,22792,22793,22794,22795,22796,22797,22798,22799,22800,22801, +22802,22803,22804,22805,22806,22807,22808,22809,22810,22811,22812,22813, +22814,22815,22816,22817,22818,22819,22820,22821,22822,22823,22824,22825, +22826,22827,22828,22829,22830,22831,22832,22833,22834,22835,22836,22837, +22838,22839,22840,22841,22842,22843,22844,22845,22846,22847,22848,22849, +22850,22851,22852,22853,22854,22855,22856,22857,22858,22859,22860,22861, +22862,22863,22864,22865,22866,22867,22868,22869,22870,22871,22872,22873, +22874,22875,22876,22877,22878,22879,22880,22881,22882,22883,22884,22885, +22886,22887,22888,22889,22890,22891,22892,22893,22894,22895,22896,22897, +22898,22899,22900,22901,22902,22903,22904,22905,22906,22907,22908,22909, +22910,22911,22912,22913,22914,22915,22916,22917,22918,22919,22920,22921, +22922,22923,22924,22925,22926,22927,22928,22929,22930,22931,22932,22933, +22934,22935,22936,22937,22938,22939,22940,22941,22942,22943,22944,22945, +22946,22947,22948,22949,22950,22951,22952,22953,22954,22955,22956,22957, +22958,22959,22960,22961,22962,22963,22964,22965,22966,22967,22968,22969, +22970,22971,22972,22973,22974,22975,22976,22977,22978,22979,22980,22981, +22982,22983,22984,22985,22986,22987,22988,22989,22990,22991,22992,22993, +22994,22995,22996,22997,22998,22999,23000,23001,23002,23003,23004,23005, +23006,23007,23008,23009,23010,23011,23012,23013,23014,23015,23016,23017, +23018,23019,23020,23021,23022,23023,23024,23025,23026,23027,23028,23029, +23030,23031,23032,23033,23034,23035,23036,23037,23038,23039,23040,23041, +23042,23043,23044,23045,23046,23047,23048,23049,23050,23051,23052,23053, +23054,23055,23056,23057,23058,23059,23060,23061,23062,23063,23064,23065, +23066,23067,23068,23069,23070,23071,23072,23073,23074,23075,23076,23077, +23078,23079,23080,23081,23082,23083,23084,23085,23086,23087,23088,23089, +23090,23091,23092,23093,23094,23095,23096,23097,23098,23099,23100,23101, +23102,23103,23104,23105,23106,23107,23108,23109,23110,23111,23112,23113, +23114,23115,23116,23117,23118,23119,23120,23121,23122,23123,23124,23125, +23126,23127,23128,23129,23130,23131,23132,23133,23134,23135,23136,23137, +23138,23139,23140,23141,23142,23143,23144,23145,23146,23147,23148,23149, +23150,23151,23152,23153,23154,23155,23156,23157,23158,23159,23160,23161, +23162,23163,23164,23165,23166,23167,23168,23169,23170,23171,23172,23173, +23174,23175,23176,23177,23178,23179,23180,23181,23182,23183,23184,23185, +23186,23187,23188,23189,23190,23191,23192,23193,23194,23195,23196,23197, +23198,23199,23200,23201,23202,23203,23204,23205,23206,23207,23208,23209, +23210,23211,23212,23213,23214,23215,23216,23217,23218,23219,23220,23221, +23222,23223,23224,23225,23226,23227,23228,23229,23230,23231,23232,23233, +23234,23235,23236,23237,23238,23239,23240,23241,23242,23243,23244,23245, +23246,23247,23248,23249,23250,23251,23252,23253,23254,23255,23256,23257, +23258,23259,23260,23261,23262,23263,23264,23265,23266,23267,23268,23269, +23270,23271,23272,23273,23274,23275,23276,23277,23278,23279,23280,23281, +23282,23283,23284,23285,23286,23287,23288,23289,23290,23291,23292,23293, +23294,23295,23296,23297,23298,23299,23300,23301,23302,23303,23304,23305, +23306,23307,23308,23309,23310,23311,23312,23313,23314,23315,23316,23317, +23318,23319,23320,23321,23322,23323,23324,23325,23326,23327,23328,23329, +23330,23331,23332,23333,23334,23335,23336,23337,23338,23339,23340,23341, +23342,23343,23344,23345,23346,23347,23348,23349,23350,23351,23352,23353, +23354,23355,23356,23357,23358,23359,23360,23361,23362,23363,23364,23365, +23366,23367,23368,23369,23370,23371,23372,23373,23374,23375,23376,23377, +23378,23379,23380,23381,23382,23383,23384,23385,23386,23387,23388,23389, +23390,23391,23392,23393,23394,23395,23396,23397,23398,23399,23400,23401, +23402,23403,23404,23405,23406,23407,23408,23409,23410,23411,23412,23413, +23414,23415,23416,23417,23418,23419,23420,23421,23422,23423,23424,23425, +23426,23427,23428,23429,23430,23431,23432,23433,23434,23435,23436,23437, +23438,23439,23440,23441,23442,23443,23444,23445,23446,23447,23448,23449, +23450,23451,23452,23453,23454,23455,23456,23457,23458,23459,23460,23461, +23462,23463,23464,23465,23466,23467,23468,23469,23470,23471,23472,23473, +23474,23475,23476,23477,23478,23479,23480,23481,23482,23483,23484,23485, +23486,23487,23488,23489,23490,23491,23492,23493,23494,23495,23496,23497, +23498,23499,23500,23501,23502,23503,23504,23505,23506,23507,23508,23509, +23510,23511,23512,23513,23514,23515,23516,23517,23518,23519,23520,23521, +23522,23523,23524,23525,23526,23527,23528,23529,23530,23531,23532,23533, +23534,23535,23536,23537,23538,23539,23540,23541,23542,23543,23544,23545, +23546,23547,23548,23549,23550,23551,23552,23553,23554,23555,23556,23557, +23558,23559,23560,23561,23562,23563,23564,23565,23566,23567,23568,23569, +23570,23571,23572,23573,23574,23575,23576,23577,23578,23579,23580,23581, +23582,23583,23584,23585,23586,23587,23588,23589,23590,23591,23592,23593, +23594,23595,23596,23597,23598,23599,23600,23601,23602,23603,23604,23605, +23606,23607,23608,23609,23610,23611,23612,23613,23614,23615,23616,23617, +23618,23619,23620,23621,23622,23623,23624,23625,23626,23627,23628,23629, +23630,23631,23632,23633,23634,23635,23636,23637,23638,23639,23640,23641, +23642,23643,23644,23645,23646,23647,23648,23649,23650,23651,23652,23653, +23654,23655,23656,23657,23658,23659,23660,23661,23662,23663,23664,23665, +23666,23667,23668,23669,23670,23671,23672,23673,23674,23675,23676,23677, +23678,23679,23680,23681,23682,23683,23684,23685,23686,23687,23688,23689, +23690,23691,23692,23693,23694,23695,23696,23697,23698,23699,23700,23701, +23702,23703,23704,23705,23706,23707,23708,23709,23710,23711,23712,23713, +23714,23715,23716,23717,23718,23719,23720,23721,23722,23723,23724,23725, +23726,23727,23728,23729,23730,23731,23732,23733,23734,23735,23736,23737, +23738,23739,23740,23741,23742,23743,23744,23745,23746,23747,23748,23749, +23750,23751,23752,23753,23754,23755,23756,23757,23758,23759,23760,23761, +23762,23763,23764,23765,23766,23767,23768,23769,23770,23771,23772,23773, +23774,23775,23776,23777,23778,23779,23780,23781,23782,23783,23784,23785, +23786,23787,23788,23789,23790,23791,23792,23793,23794,23795,23796,23797, +23798,23799,23800,23801,23802,23803,23804,23805,23806,23807,23808,23809, +23810,23811,23812,23813,23814,23815,23816,23817,23818,23819,23820,23821, +23822,23823,23824,23825,23826,23827,23828,23829,23830,23831,23832,23833, +23834,23835,23836,23837,23838,23839,23840,23841,23842,23843,23844,23845, +23846,23847,23848,23849,23850,23851,23852,23853,23854,23855,23856,23857, +23858,23859,23860,23861,23862,23863,23864,23865,23866,23867,23868,23869, +23870,23871,23872,23873,23874,23875,23876,23877,23878,23879,23880,23881, +23882,23883,23884,23885,23886,23887,23888,23889,23890,23891,23892,23893, +23894,23895,23896,23897,23898,23899,23900,23901,23902,23903,23904,23905, +23906,23907,23908,23909,23910,23911,23912,23913,23914,23915,23916,23917, +23918,23919,23920,23921,23922,23923,23924,23925,23926,23927,23928,23929, +23930,23931,23932,23933,23934,23935,23936,23937,23938,23939,23940,23941, +23942,23943,23944,23945,23946,23947,23948,23949,23950,23951,23952,23953, +23954,23955,23956,23957,23958,23959,23960,23961,23962,23963,23964,23965, +23966,23967,23968,23969,23970,23971,23972,23973,23974,23975,23976,23977, +23978,23979,23980,23981,23982,23983,23984,23985,23986,23987,23988,23989, +23990,23991,23992,23993,23994,23995,23996,23997,23998,23999,24000,24001, +24002,24003,24004,24005,24006,24007,24008,24009,24010,24011,24012,24013, +24014,24015,24016,24017,24018,24019,24020,24021,24022,24023,24024,24025, +24026,24027,24028,24029,24030,24031,24032,24033,24034,24035,24036,24037, +24038,24039,24040,24041,24042,24043,24044,24045,24046,24047,24048,24049, +24050,24051,24052,24053,24054,24055,24056,24057,24058,24059,24060,24061, +24062,24063,24064,24065,24066,24067,24068,24069,24070,24071,24072,24073, +24074,24075,24076,24077,24078,24079,24080,24081,24082,24083,24084,24085, +24086,24087,24088,24089,24090,24091,24092,24093,24094,24095,24096,24097, +24098,24099,24100,24101,24102,24103,24104,24105,24106,24107,24108,24109, +24110,24111,24112,24113,24114,24115,24116,24117,24118,24119,24120,24121, +24122,24123,24124,24125,24126,24127,24128,24129,24130,24131,24132,24133, +24134,24135,24136,24137,24138,24139,24140,24141,24142,24143,24144,24145, +24146,24147,24148,24149,24150,24151,24152,24153,24154,24155,24156,24157, +24158,24159,24160,24161,24162,24163,24164,24165,24166,24167,24168,24169, +24170,24171,24172,24173,24174,24175,24176,24177,24178,24179,24180,24181, +24182,24183,24184,24185,24186,24187,24188,24189,24190,24191,24192,24193, +24194,24195,24196,24197,24198,24199,24200,24201,24202,24203,24204,24205, +24206,24207,24208,24209,24210,24211,24212,24213,24214,24215,24216,24217, +24218,24219,24220,24221,24222,24223,24224,24225,24226,24227,24228,24229, +24230,24231,24232,24233,24234,24235,24236,24237,24238,24239,24240,24241, +24242,24243,24244,24245,24246,24247,24248,24249,24250,24251,24252,24253, +24254,24255,24256,24257,24258,24259,24260,24261,24262,24263,24264,24265, +24266,24267,24268,24269,24270,24271,24272,24273,24274,24275,24276,24277, +24278,24279,24280,24281,24282,24283,24284,24285,24286,24287,24288,24289, +24290,24291,24292,24293,24294,24295,24296,24297,24298,24299,24300,24301, +24302,24303,24304,24305,24306,24307,24308,24309,24310,24311,24312,24313, +24314,24315,24316,24317,24318,24319,24320,24321,24322,24323,24324,24325, +24326,24327,24328,24329,24330,24331,24332,24333,24334,24335,24336,24337, +24338,24339,24340,24341,24342,24343,24344,24345,24346,24347,24348,24349, +24350,24351,24352,24353,24354,24355,24356,24357,24358,24359,24360,24361, +24362,24363,24364,24365,24366,24367,24368,24369,24370,24371,24372,24373, +24374,24375,24376,24377,24378,24379,24380,24381,24382,24383,24384,24385, +24386,24387,24388,24389,24390,24391,24392,24393,24394,24395,24396,24397, +24398,24399,24400,24401,24402,24403,24404,24405,24406,24407,24408,24409, +24410,24411,24412,24413,24414,24415,24416,24417,24418,24419,24420,24421, +24422,24423,24424,24425,24426,24427,24428,24429,24430,24431,24432,24433, +24434,24435,24436,24437,24438,24439,24440,24441,24442,24443,24444,24445, +24446,24447,24448,24449,24450,24451,24452,24453,24454,24455,24456,24457, +24458,24459,24460,24461,24462,24463,24464,24465,24466,24467,24468,24469, +24470,24471,24472,24473,24474,24475,24476,24477,24478,24479,24480,24481, +24482,24483,24484,24485,24486,24487,24488,24489,24490,24491,24492,24493, +24494,24495,24496,24497,24498,24499,24500,24501,24502,24503,24504,24505, +24506,24507,24508,24509,24510,24511,24512,24513,24514,24515,24516,24517, +24518,24519,24520,24521,24522,24523,24524,24525,24526,24527,24528,24529, +24530,24531,24532,24533,24534,24535,24536,24537,24538,24539,24540,24541, +24542,24543,24544,24545,24546,24547,24548,24549,24550,24551,24552,24553, +24554,24555,24556,24557,24558,24559,24560,24561,24562,24563,24564,24565, +24566,24567,24568,24569,24570,24571,24572,24573,24574,24575,24576,24577, +24578,24579,24580,24581,24582,24583,24584,24585,24586,24587,24588,24589, +24590,24591,24592,24593,24594,24595,24596,24597,24598,24599,24600,24601, +24602,24603,24604,24605,24606,24607,24608,24609,24610,24611,24612,24613, +24614,24615,24616,24617,24618,24619,24620,24621,24622,24623,24624,24625, +24626,24627,24628,24629,24630,24631,24632,24633,24634,24635,24636,24637, +24638,24639,24640,24641,24642,24643,24644,24645,24646,24647,24648,24649, +24650,24651,24652,24653,24654,24655,24656,24657,24658,24659,24660,24661, +24662,24663,24664,24665,24666,24667,24668,24669,24670,24671,24672,24673, +24674,24675,24676,24677,24678,24679,24680,24681,24682,24683,24684,24685, +24686,24687,24688,24689,24690,24691,24692,24693,24694,24695,24696,24697, +24698,24699,24700,24701,24702,24703,24704,24705,24706,24707,24708,24709, +24710,24711,24712,24713,24714,24715,24716,24717,24718,24719,24720,24721, +24722,24723,24724,24725,24726,24727,24728,24729,24730,24731,24732,24733, +24734,24735,24736,24737,24738,24739,24740,24741,24742,24743,24744,24745, +24746,24747,24748,24749,24750,24751,24752,24753,24754,24755,24756,24757, +24758,24759,24760,24761,24762,24763,24764,24765,24766,24767,24768,24769, +24770,24771,24772,24773,24774,24775,24776,24777,24778,24779,24780,24781, +24782,24783,24784,24785,24786,24787,24788,24789,24790,24791,24792,24793, +24794,24795,24796,24797,24798,24799,24800,24801,24802,24803,24804,24805, +24806,24807,24808,24809,24810,24811,24812,24813,24814,24815,24816,24817, +24818,24819,24820,24821,24822,24823,24824,24825,24826,24827,24828,24829, +24830,24831,24832,24833,24834,24835,24836,24837,24838,24839,24840,24841, +24842,24843,24844,24845,24846,24847,24848,24849,24850,24851,24852,24853, +24854,24855,24856,24857,24858,24859,24860,24861,24862,24863,24864,24865, +24866,24867,24868,24869,24870,24871,24872,24873,24874,24875,24876,24877, +24878,24879,24880,24881,24882,24883,24884,24885,24886,24887,24888,24889, +24890,24891,24892,24893,24894,24895,24896,24897,24898,24899,24900,24901, +24902,24903,24904,24905,24906,24907,24908,24909,24910,24911,24912,24913, +24914,24915,24916,24917,24918,24919,24920,24921,24922,24923,24924,24925, +24926,24927,24928,24929,24930,24931,24932,24933,24934,24935,24936,24937, +24938,24939,24940,24941,24942,24943,24944,24945,24946,24947,24948,24949, +24950,24951,24952,24953,24954,24955,24956,24957,24958,24959,24960,24961, +24962,24963,24964,24965,24966,24967,24968,24969,24970,24971,24972,24973, +24974,24975,24976,24977,24978,24979,24980,24981,24982,24983,24984,24985, +24986,24987,24988,24989,24990,24991,24992,24993,24994,24995,24996,24997, +24998,24999,25000,25001,25002,25003,25004,25005,25006,25007,25008,25009, +25010,25011,25012,25013,25014,25015,25016,25017,25018,25019,25020,25021, +25022,25023,25024,25025,25026,25027,25028,25029,25030,25031,25032,25033, +25034,25035,25036,25037,25038,25039,25040,25041,25042,25043,25044,25045, +25046,25047,25048,25049,25050,25051,25052,25053,25054,25055,25056,25057, +25058,25059,25060,25061,25062,25063,25064,25065,25066,25067,25068,25069, +25070,25071,25072,25073,25074,25075,25076,25077,25078,25079,25080,25081, +25082,25083,25084,25085,25086,25087,25088,25089,25090,25091,25092,25093, +25094,25095,25096,25097,25098,25099,25100,25101,25102,25103,25104,25105, +25106,25107,25108,25109,25110,25111,25112,25113,25114,25115,25116,25117, +25118,25119,25120,25121,25122,25123,25124,25125,25126,25127,25128,25129, +25130,25131,25132,25133,25134,25135,25136,25137,25138,25139,25140,25141, +25142,25143,25144,25145,25146,25147,25148,25149,25150,25151,25152,25153, +25154,25155,25156,25157,25158,25159,25160,25161,25162,25163,25164,25165, +25166,25167,25168,25169,25170,25171,25172,25173,25174,25175,25176,25177, +25178,25179,25180,25181,25182,25183,25184,25185,25186,25187,25188,25189, +25190,25191,25192,25193,25194,25195,25196,25197,25198,25199,25200,25201, +25202,25203,25204,25205,25206,25207,25208,25209,25210,25211,25212,25213, +25214,25215,25216,25217,25218,25219,25220,25221,25222,25223,25224,25225, +25226,25227,25228,25229,25230,25231,25232,25233,25234,25235,25236,25237, +25238,25239,25240,25241,25242,25243,25244,25245,25246,25247,25248,25249, +25250,25251,25252,25253,25254,25255,25256,25257,25258,25259,25260,25261, +25262,25263,25264,25265,25266,25267,25268,25269,25270,25271,25272,25273, +25274,25275,25276,25277,25278,25279,25280,25281,25282,25283,25284,25285, +25286,25287,25288,25289,25290,25291,25292,25293,25294,25295,25296,25297, +25298,25299,25300,25301,25302,25303,25304,25305,25306,25307,25308,25309, +25310,25311,25312,25313,25314,25315,25316,25317,25318,25319,25320,25321, +25322,25323,25324,25325,25326,25327,25328,25329,25330,25331,25332,25333, +25334,25335,25336,25337,25338,25339,25340,25341,25342,25343,25344,25345, +25346,25347,25348,25349,25350,25351,25352,25353,25354,25355,25356,25357, +25358,25359,25360,25361,25362,25363,25364,25365,25366,25367,25368,25369, +25370,25371,25372,25373,25374,25375,25376,25377,25378,25379,25380,25381, +25382,25383,25384,25385,25386,25387,25388,25389,25390,25391,25392,25393, +25394,25395,25396,25397,25398,25399,25400,25401,25402,25403,25404,25405, +25406,25407,25408,25409,25410,25411,25412,25413,25414,25415,25416,25417, +25418,25419,25420,25421,25422,25423,25424,25425,25426,25427,25428,25429, +25430,25431,25432,25433,25434,25435,25436,25437,25438,25439,25440,25441, +25442,25443,25444,25445,25446,25447,25448,25449,25450,25451,25452,25453, +25454,25455,25456,25457,25458,25459,25460,25461,25462,25463,25464,25465, +25466,25467,25468,25469,25470,25471,25472,25473,25474,25475,25476,25477, +25478,25479,25480,25481,25482,25483,25484,25485,25486,25487,25488,25489, +25490,25491,25492,25493,25494,25495,25496,25497,25498,25499,25500,25501, +25502,25503,25504,25505,25506,25507,25508,25509,25510,25511,25512,25513, +25514,25515,25516,25517,25518,25519,25520,25521,25522,25523,25524,25525, +25526,25527,25528,25529,25530,25531,25532,25533,25534,25535,25536,25537, +25538,25539,25540,25541,25542,25543,25544,25545,25546,25547,25548,25549, +25550,25551,25552,25553,25554,25555,25556,25557,25558,25559,25560,25561, +25562,25563,25564,25565,25566,25567,25568,25569,25570,25571,25572,25573, +25574,25575,25576,25577,25578,25579,25580,25581,25582,25583,25584,25585, +25586,25587,25588,25589,25590,25591,25592,25593,25594,25595,25596,25597, +25598,25599,25600,25601,25602,25603,25604,25605,25606,25607,25608,25609, +25610,25611,25612,25613,25614,25615,25616,25617,25618,25619,25620,25621, +25622,25623,25624,25625,25626,25627,25628,25629,25630,25631,25632,25633, +25634,25635,25636,25637,25638,25639,25640,25641,25642,25643,25644,25645, +25646,25647,25648,25649,25650,25651,25652,25653,25654,25655,25656,25657, +25658,25659,25660,25661,25662,25663,25664,25665,25666,25667,25668,25669, +25670,25671,25672,25673,25674,25675,25676,25677,25678,25679,25680,25681, +25682,25683,25684,25685,25686,25687,25688,25689,25690,25691,25692,25693, +25694,25695,25696,25697,25698,25699,25700,25701,25702,25703,25704,25705, +25706,25707,25708,25709,25710,25711,25712,25713,25714,25715,25716,25717, +25718,25719,25720,25721,25722,25723,25724,25725,25726,25727,25728,25729, +25730,25731,25732,25733,25734,25735,25736,25737,25738,25739,25740,25741, +25742,25743,25744,25745,25746,25747,25748,25749,25750,25751,25752,25753, +25754,25755,25756,25757,25758,25759,25760,25761,25762,25763,25764,25765, +25766,25767,25768,25769,25770,25771,25772,25773,25774,25775,25776,25777, +25778,25779,25780,25781,25782,25783,25784,25785,25786,25787,25788,25789, +25790,25791,25792,25793,25794,25795,25796,25797,25798,25799,25800,25801, +25802,25803,25804,25805,25806,25807,25808,25809,25810,25811,25812,25813, +25814,25815,25816,25817,25818,25819,25820,25821,25822,25823,25824,25825, +25826,25827,25828,25829,25830,25831,25832,25833,25834,25835,25836,25837, +25838,25839,25840,25841,25842,25843,25844,25845,25846,25847,25848,25849, +25850,25851,25852,25853,25854,25855,25856,25857,25858,25859,25860,25861, +25862,25863,25864,25865,25866,25867,25868,25869,25870,25871,25872,25873, +25874,25875,25876,25877,25878,25879,25880,25881,25882,25883,25884,25885, +25886,25887,25888,25889,25890,25891,25892,25893,25894,25895,25896,25897, +25898,25899,25900,25901,25902,25903,25904,25905,25906,25907,25908,25909, +25910,25911,25912,25913,25914,25915,25916,25917,25918,25919,25920,25921, +25922,25923,25924,25925,25926,25927,25928,25929,25930,25931,25932,25933, +25934,25935,25936,25937,25938,25939,25940,25941,25942,25943,25944,25945, +25946,25947,25948,25949,25950,25951,25952,25953,25954,25955,25956,25957, +25958,25959,25960,25961,25962,25963,25964,25965,25966,25967,25968,25969, +25970,25971,25972,25973,25974,25975,25976,25977,25978,25979,25980,25981, +25982,25983,25984,25985,25986,25987,25988,25989,25990,25991,25992,25993, +25994,25995,25996,25997,25998,25999,26000,26001,26002,26003,26004,26005, +26006,26007,26008,26009,26010,26011,26012,26013,26014,26015,26016,26017, +26018,26019,26020,26021,26022,26023,26024,26025,26026,26027,26028,26029, +26030,26031,26032,26033,26034,26035,26036,26037,26038,26039,26040,26041, +26042,26043,26044,26045,26046,26047,26048,26049,26050,26051,26052,26053, +26054,26055,26056,26057,26058,26059,26060,26061,26062,26063,26064,26065, +26066,26067,26068,26069,26070,26071,26072,26073,26074,26075,26076,26077, +26078,26079,26080,26081,26082,26083,26084,26085,26086,26087,26088,26089, +26090,26091,26092,26093,26094,26095,26096,26097,26098,26099,26100,26101, +26102,26103,26104,26105,26106,26107,26108,26109,26110,26111,26112,26113, +26114,26115,26116,26117,26118,26119,26120,26121,26122,26123,26124,26125, +26126,26127,26128,26129,26130,26131,26132,26133,26134,26135,26136,26137, +26138,26139,26140,26141,26142,26143,26144,26145,26146,26147,26148,26149, +26150,26151,26152,26153,26154,26155,26156,26157,26158,26159,26160,26161, +26162,26163,26164,26165,26166,26167,26168,26169,26170,26171,26172,26173, +26174,26175,26176,26177,26178,26179,26180,26181,26182,26183,26184,26185, +26186,26187,26188,26189,26190,26191,26192,26193,26194,26195,26196,26197, +26198,26199,26200,26201,26202,26203,26204,26205,26206,26207,26208,26209, +26210,26211,26212,26213,26214,26215,26216,26217,26218,26219,26220,26221, +26222,26223,26224,26225,26226,26227,26228,26229,26230,26231,26232,26233, +26234,26235,26236,26237,26238,26239,26240,26241,26242,26243,26244,26245, +26246,26247,26248,26249,26250,26251,26252,26253,26254,26255,26256,26257, +26258,26259,26260,26261,26262,26263,26264,26265,26266,26267,26268,26269, +26270,26271,26272,26273,26274,26275,26276,26277,26278,26279,26280,26281, +26282,26283,26284,26285,26286,26287,26288,26289,26290,26291,26292,26293, +26294,26295,26296,26297,26298,26299,26300,26301,26302,26303,26304,26305, +26306,26307,26308,26309,26310,26311,26312,26313,26314,26315,26316,26317, +26318,26319,26320,26321,26322,26323,26324,26325,26326,26327,26328,26329, +26330,26331,26332,26333,26334,26335,26336,26337,26338,26339,26340,26341, +26342,26343,26344,26345,26346,26347,26348,26349,26350,26351,26352,26353, +26354,26355,26356,26357,26358,26359,26360,26361,26362,26363,26364,26365, +26366,26367,26368,26369,26370,26371,26372,26373,26374,26375,26376,26377, +26378,26379,26380,26381,26382,26383,26384,26385,26386,26387,26388,26389, +26390,26391,26392,26393,26394,26395,26396,26397,26398,26399,26400,26401, +26402,26403,26404,26405,26406,26407,26408,26409,26410,26411,26412,26413, +26414,26415,26416,26417,26418,26419,26420,26421,26422,26423,26424,26425, +26426,26427,26428,26429,26430,26431,26432,26433,26434,26435,26436,26437, +26438,26439,26440,26441,26442,26443,26444,26445,26446,26447,26448,26449, +26450,26451,26452,26453,26454,26455,26456,26457,26458,26459,26460,26461, +26462,26463,26464,26465,26466,26467,26468,26469,26470,26471,26472,26473, +26474,26475,26476,26477,26478,26479,26480,26481,26482,26483,26484,26485, +26486,26487,26488,26489,26490,26491,26492,26493,26494,26495,26496,26497, +26498,26499,26500,26501,26502,26503,26504,26505,26506,26507,26508,26509, +26510,26511,26512,26513,26514,26515,26516,26517,26518,26519,26520,26521, +26522,26523,26524,26525,26526,26527,26528,26529,26530,26531,26532,26533, +26534,26535,26536,26537,26538,26539,26540,26541,26542,26543,26544,26545, +26546,26547,26548,26549,26550,26551,26552,26553,26554,26555,26556,26557, +26558,26559,26560,26561,26562,26563,26564,26565,26566,26567,26568,26569, +26570,26571,26572,26573,26574,26575,26576,26577,26578,26579,26580,26581, +26582,26583,26584,26585,26586,26587,26588,26589,26590,26591,26592,26593, +26594,26595,26596,26597,26598,26599,26600,26601,26602,26603,26604,26605, +26606,26607,26608,26609,26610,26611,26612,26613,26614,26615,26616,26617, +26618,26619,26620,26621,26622,26623,26624,26625,26626,26627,26628,26629, +26630,26631,26632,26633,26634,26635,26636,26637,26638,26639,26640,26641, +26642,26643,26644,26645,26646,26647,26648,26649,26650,26651,26652,26653, +26654,26655,26656,26657,26658,26659,26660,26661,26662,26663,26664,26665, +26666,26667,26668,26669,26670,26671,26672,26673,26674,26675,26676,26677, +26678,26679,26680,26681,26682,26683,26684,26685,26686,26687,26688,26689, +26690,26691,26692,26693,26694,26695,26696,26697,26698,26699,26700,26701, +26702,26703,26704,26705,26706,26707,26708,26709,26710,26711,26712,26713, +26714,26715,26716,26717,26718,26719,26720,26721,26722,26723,26724,26725, +26726,26727,26728,26729,26730,26731,26732,26733,26734,26735,26736,26737, +26738,26739,26740,26741,26742,26743,26744,26745,26746,26747,26748,26749, +26750,26751,26752,26753,26754,26755,26756,26757,26758,26759,26760,26761, +26762,26763,26764,26765,26766,26767,26768,26769,26770,26771,26772,26773, +26774,26775,26776,26777,26778,26779,26780,26781,26782,26783,26784,26785, +26786,26787,26788,26789,26790,26791,26792,26793,26794,26795,26796,26797, +26798,26799,26800,26801,26802,26803,26804,26805,26806,26807,26808,26809, +26810,26811,26812,26813,26814,26815,26816,26817,26818,26819,26820,26821, +26822,26823,26824,26825,26826,26827,26828,26829,26830,26831,26832,26833, +26834,26835,26836,26837,26838,26839,26840,26841,26842,26843,26844,26845, +26846,26847,26848,26849,26850,26851,26852,26853,26854,26855,26856,26857, +26858,26859,26860,26861,26862,26863,26864,26865,26866,26867,26868,26869, +26870,26871,26872,26873,26874,26875,26876,26877,26878,26879,26880,26881, +26882,26883,26884,26885,26886,26887,26888,26889,26890,26891,26892,26893, +26894,26895,26896,26897,26898,26899,26900,26901,26902,26903,26904,26905, +26906,26907,26908,26909,26910,26911,26912,26913,26914,26915,26916,26917, +26918,26919,26920,26921,26922,26923,26924,26925,26926,26927,26928,26929, +26930,26931,26932,26933,26934,26935,26936,26937,26938,26939,26940,26941, +26942,26943,26944,26945,26946,26947,26948,26949,26950,26951,26952,26953, +26954,26955,26956,26957,26958,26959,26960,26961,26962,26963,26964,26965, +26966,26967,26968,26969,26970,26971,26972,26973,26974,26975,26976,26977, +26978,26979,26980,26981,26982,26983,26984,26985,26986,26987,26988,26989, +26990,26991,26992,26993,26994,26995,26996,26997,26998,26999,27000,27001, +27002,27003,27004,27005,27006,27007,27008,27009,27010,27011,27012,27013, +27014,27015,27016,27017,27018,27019,27020,27021,27022,27023,27024,27025, +27026,27027,27028,27029,27030,27031,27032,27033,27034,27035,27036,27037, +27038,27039,27040,27041,27042,27043,27044,27045,27046,27047,27048,27049, +27050,27051,27052,27053,27054,27055,27056,27057,27058,27059,27060,27061, +27062,27063,27064,27065,27066,27067,27068,27069,27070,27071,27072,27073, +27074,27075,27076,27077,27078,27079,27080,27081,27082,27083,27084,27085, +27086,27087,27088,27089,27090,27091,27092,27093,27094,27095,27096,27097, +27098,27099,27100,27101,27102,27103,27104,27105,27106,27107,27108,27109, +27110,27111,27112,27113,27114,27115,27116,27117,27118,27119,27120,27121, +27122,27123,27124,27125,27126,27127,27128,27129,27130,27131,27132,27133, +27134,27135,27136,27137,27138,27139,27140,27141,27142,27143,27144,27145, +27146,27147,27148,27149,27150,27151,27152,27153,27154,27155,27156,27157, +27158,27159,27160,27161,27162,27163,27164,27165,27166,27167,27168,27169, +27170,27171,27172,27173,27174,27175,27176,27177,27178,27179,27180,27181, +27182,27183,27184,27185,27186,27187,27188,27189,27190,27191,27192,27193, +27194,27195,27196,27197,27198,27199,27200,27201,27202,27203,27204,27205, +27206,27207,27208,27209,27210,27211,27212,27213,27214,27215,27216,27217, +27218,27219,27220,27221,27222,27223,27224,27225,27226,27227,27228,27229, +27230,27231,27232,27233,27234,27235,27236,27237,27238,27239,27240,27241, +27242,27243,27244,27245,27246,27247,27248,27249,27250,27251,27252,27253, +27254,27255,27256,27257,27258,27259,27260,27261,27262,27263,27264,27265, +27266,27267,27268,27269,27270,27271,27272,27273,27274,27275,27276,27277, +27278,27279,27280,27281,27282,27283,27284,27285,27286,27287,27288,27289, +27290,27291,27292,27293,27294,27295,27296,27297,27298,27299,27300,27301, +27302,27303,27304,27305,27306,27307,27308,27309,27310,27311,27312,27313, +27314,27315,27316,27317,27318,27319,27320,27321,27322,27323,27324,27325, +27326,27327,27328,27329,27330,27331,27332,27333,27334,27335,27336,27337, +27338,27339,27340,27341,27342,27343,27344,27345,27346,27347,27348,27349, +27350,27351,27352,27353,27354,27355,27356,27357,27358,27359,27360,27361, +27362,27363,27364,27365,27366,27367,27368,27369,27370,27371,27372,27373, +27374,27375,27376,27377,27378,27379,27380,27381,27382,27383,27384,27385, +27386,27387,27388,27389,27390,27391,27392,27393,27394,27395,27396,27397, +27398,27399,27400,27401,27402,27403,27404,27405,27406,27407,27408,27409, +27410,27411,27412,27413,27414,27415,27416,27417,27418,27419,27420,27421, +27422,27423,27424,27425,27426,27427,27428,27429,27430,27431,27432,27433, +27434,27435,27436,27437,27438,27439,27440,27441,27442,27443,27444,27445, +27446,27447,27448,27449,27450,27451,27452,27453,27454,27455,27456,27457, +27458,27459,27460,27461,27462,27463,27464,27465,27466,27467,27468,27469, +27470,27471,27472,27473,27474,27475,27476,27477,27478,27479,27480,27481, +27482,27483,27484,27485,27486,27487,27488,27489,27490,27491,27492,27493, +27494,27495,27496,27497,27498,27499,27500,27501,27502,27503,27504,27505, +27506,27507,27508,27509,27510,27511,27512,27513,27514,27515,27516,27517, +27518,27519,27520,27521,27522,27523,27524,27525,27526,27527,27528,27529, +27530,27531,27532,27533,27534,27535,27536,27537,27538,27539,27540,27541, +27542,27543,27544,27545,27546,27547,27548,27549,27550,27551,27552,27553, +27554,27555,27556,27557,27558,27559,27560,27561,27562,27563,27564,27565, +27566,27567,27568,27569,27570,27571,27572,27573,27574,27575,27576,27577, +27578,27579,27580,27581,27582,27583,27584,27585,27586,27587,27588,27589, +27590,27591,27592,27593,27594,27595,27596,27597,27598,27599,27600,27601, +27602,27603,27604,27605,27606,27607,27608,27609,27610,27611,27612,27613, +27614,27615,27616,27617,27618,27619,27620,27621,27622,27623,27624,27625, +27626,27627,27628,27629,27630,27631,27632,27633,27634,27635,27636,27637, +27638,27639,27640,27641,27642,27643,27644,27645,27646,27647,27648,27649, +27650,27651,27652,27653,27654,27655,27656,27657,27658,27659,27660,27661, +27662,27663,27664,27665,27666,27667,27668,27669,27670,27671,27672,27673, +27674,27675,27676,27677,27678,27679,27680,27681,27682,27683,27684,27685, +27686,27687,27688,27689,27690,27691,27692,27693,27694,27695,27696,27697, +27698,27699,27700,27701,27702,27703,27704,27705,27706,27707,27708,27709, +27710,27711,27712,27713,27714,27715,27716,27717,27718,27719,27720,27721, +27722,27723,27724,27725,27726,27727,27728,27729,27730,27731,27732,27733, +27734,27735,27736,27737,27738,27739,27740,27741,27742,27743,27744,27745, +27746,27747,27748,27749,27750,27751,27752,27753,27754,27755,27756,27757, +27758,27759,27760,27761,27762,27763,27764,27765,27766,27767,27768,27769, +27770,27771,27772,27773,27774,27775,27776,27777,27778,27779,27780,27781, +27782,27783,27784,27785,27786,27787,27788,27789,27790,27791,27792,27793, +27794,27795,27796,27797,27798,27799,27800,27801,27802,27803,27804,27805, +27806,27807,27808,27809,27810,27811,27812,27813,27814,27815,27816,27817, +27818,27819,27820,27821,27822,27823,27824,27825,27826,27827,27828,27829, +27830,27831,27832,27833,27834,27835,27836,27837,27838,27839,27840,27841, +27842,27843,27844,27845,27846,27847,27848,27849,27850,27851,27852,27853, +27854,27855,27856,27857,27858,27859,27860,27861,27862,27863,27864,27865, +27866,27867,27868,27869,27870,27871,27872,27873,27874,27875,27876,27877, +27878,27879,27880,27881,27882,27883,27884,27885,27886,27887,27888,27889, +27890,27891,27892,27893,27894,27895,27896,27897,27898,27899,27900,27901, +27902,27903,27904,27905,27906,27907,27908,27909,27910,27911,27912,27913, +27914,27915,27916,27917,27918,27919,27920,27921,27922,27923,27924,27925, +27926,27927,27928,27929,27930,27931,27932,27933,27934,27935,27936,27937, +27938,27939,27940,27941,27942,27943,27944,27945,27946,27947,27948,27949, +27950,27951,27952,27953,27954,27955,27956,27957,27958,27959,27960,27961, +27962,27963,27964,27965,27966,27967,27968,27969,27970,27971,27972,27973, +27974,27975,27976,27977,27978,27979,27980,27981,27982,27983,27984,27985, +27986,27987,27988,27989,27990,27991,27992,27993,27994,27995,27996,27997, +27998,27999,28000,28001,28002,28003,28004,28005,28006,28007,28008,28009, +28010,28011,28012,28013,28014,28015,28016,28017,28018,28019,28020,28021, +28022,28023,28024,28025,28026,28027,28028,28029,28030,28031,28032,28033, +28034,28035,28036,28037,28038,28039,28040,28041,28042,28043,28044,28045, +28046,28047,28048,28049,28050,28051,28052,28053,28054,28055,28056,28057, +28058,28059,28060,28061,28062,28063,28064,28065,28066,28067,28068,28069, +28070,28071,28072,28073,28074,28075,28076,28077,28078,28079,28080,28081, +28082,28083,28084,28085,28086,28087,28088,28089,28090,28091,28092,28093, +28094,28095,28096,28097,28098,28099,28100,28101,28102,28103,28104,28105, +28106,28107,28108,28109,28110,28111,28112,28113,28114,28115,28116,28117, +28118,28119,28120,28121,28122,28123,28124,28125,28126,28127,28128,28129, +28130,28131,28132,28133,28134,28135,28136,28137,28138,28139,28140,28141, +28142,28143,28144,28145,28146,28147,28148,28149,28150,28151,28152,28153, +28154,28155,28156,28157,28158,28159,28160,28161,28162,28163,28164,28165, +28166,28167,28168,28169,28170,28171,28172,28173,28174,28175,28176,28177, +28178,28179,28180,28181,28182,28183,28184,28185,28186,28187,28188,28189, +28190,28191,28192,28193,28194,28195,28196,28197,28198,28199,28200,28201, +28202,28203,28204,28205,28206,28207,28208,28209,28210,28211,28212,28213, +28214,28215,28216,28217,28218,28219,28220,28221,28222,28223,28224,28225, +28226,28227,28228,28229,28230,28231,28232,28233,28234,28235,28236,28237, +28238,28239,28240,28241,28242,28243,28244,28245,28246,28247,28248,28249, +28250,28251,28252,28253,28254,28255,28256,28257,28258,28259,28260,28261, +28262,28263,28264,28265,28266,28267,28268,28269,28270,28271,28272,28273, +28274,28275,28276,28277,28278,28279,28280,28281,28282,28283,28284,28285, +28286,28287,28288,28289,28290,28291,28292,28293,28294,28295,28296,28297, +28298,28299,28300,28301,28302,28303,28304,28305,28306,28307,28308,28309, +28310,28311,28312,28313,28314,28315,28316,28317,28318,28319,28320,28321, +28322,28323,28324,28325,28326,28327,28328,28329,28330,28331,28332,28333, +28334,28335,28336,28337,28338,28339,28340,28341,28342,28343,28344,28345, +28346,28347,28348,28349,28350,28351,28352,28353,28354,28355,28356,28357, +28358,28359,28360,28361,28362,28363,28364,28365,28366,28367,28368,28369, +28370,28371,28372,28373,28374,28375,28376,28377,28378,28379,28380,28381, +28382,28383,28384,28385,28386,28387,28388,28389,28390,28391,28392,28393, +28394,28395,28396,28397,28398,28399,28400,28401,28402,28403,28404,28405, +28406,28407,28408,28409,28410,28411,28412,28413,28414,28415,28416,28417, +28418,28419,28420,28421,28422,28423,28424,28425,28426,28427,28428,28429, +28430,28431,28432,28433,28434,28435,28436,28437,28438,28439,28440,28441, +28442,28443,28444,28445,28446,28447,28448,28449,28450,28451,28452,28453, +28454,28455,28456,28457,28458,28459,28460,28461,28462,28463,28464,28465, +28466,28467,28468,28469,28470,28471,28472,28473,28474,28475,28476,28477, +28478,28479,28480,28481,28482,28483,28484,28485,28486,28487,28488,28489, +28490,28491,28492,28493,28494,28495,28496,28497,28498,28499,28500,28501, +28502,28503,28504,28505,28506,28507,28508,28509,28510,28511,28512,28513, +28514,28515,28516,28517,28518,28519,28520,28521,28522,28523,28524,28525, +28526,28527,28528,28529,28530,28531,28532,28533,28534,28535,28536,28537, +28538,28539,28540,28541,28542,28543,28544,28545,28546,28547,28548,28549, +28550,28551,28552,28553,28554,28555,28556,28557,28558,28559,28560,28561, +28562,28563,28564,28565,28566,28567,28568,28569,28570,28571,28572,28573, +28574,28575,28576,28577,28578,28579,28580,28581,28582,28583,28584,28585, +28586,28587,28588,28589,28590,28591,28592,28593,28594,28595,28596,28597, +28598,28599,28600,28601,28602,28603,28604,28605,28606,28607,28608,28609, +28610,28611,28612,28613,28614,28615,28616,28617,28618,28619,28620,28621, +28622,28623,28624,28625,28626,28627,28628,28629,28630,28631,28632,28633, +28634,28635,28636,28637,28638,28639,28640,28641,28642,28643,28644,28645, +28646,28647,28648,28649,28650,28651,28652,28653,28654,28655,28656,28657, +28658,28659,28660,28661,28662,28663,28664,28665,28666,28667,28668,28669, +28670,28671,28672,28673,28674,28675,28676,28677,28678,28679,28680,28681, +28682,28683,28684,28685,28686,28687,28688,28689,28690,28691,28692,28693, +28694,28695,28696,28697,28698,28699,28700,28701,28702,28703,28704,28705, +28706,28707,28708,28709,28710,28711,28712,28713,28714,28715,28716,28717, +28718,28719,28720,28721,28722,28723,28724,28725,28726,28727,28728,28729, +28730,28731,28732,28733,28734,28735,28736,28737,28738,28739,28740,28741, +28742,28743,28744,28745,28746,28747,28748,28749,28750,28751,28752,28753, +28754,28755,28756,28757,28758,28759,28760,28761,28762,28763,28764,28765, +28766,28767,28768,28769,28770,28771,28772,28773,28774,28775,28776,28777, +28778,28779,28780,28781,28782,28783,28784,28785,28786,28787,28788,28789, +28790,28791,28792,28793,28794,28795,28796,28797,28798,28799,28800,28801, +28802,28803,28804,28805,28806,28807,28808,28809,28810,28811,28812,28813, +28814,28815,28816,28817,28818,28819,28820,28821,28822,28823,28824,28825, +28826,28827,28828,28829,28830,28831,28832,28833,28834,28835,28836,28837, +28838,28839,28840,28841,28842,28843,28844,28845,28846,28847,28848,28849, +28850,28851,28852,28853,28854,28855,28856,28857,28858,28859,28860,28861, +28862,28863,28864,28865,28866,28867,28868,28869,28870,28871,28872,28873, +28874,28875,28876,28877,28878,28879,28880,28881,28882,28883,28884,28885, +28886,28887,28888,28889,28890,28891,28892,28893,28894,28895,28896,28897, +28898,28899,28900,28901,28902,28903,28904,28905,28906,28907,28908,28909, +28910,28911,28912,28913,28914,28915,28916,28917,28918,28919,28920,28921, +28922,28923,28924,28925,28926,28927,28928,28929,28930,28931,28932,28933, +28934,28935,28936,28937,28938,28939,28940,28941,28942,28943,28944,28945, +28946,28947,28948,28949,28950,28951,28952,28953,28954,28955,28956,28957, +28958,28959,28960,28961,28962,28963,28964,28965,28966,28967,28968,28969, +28970,28971,28972,28973,28974,28975,28976,28977,28978,28979,28980,28981, +28982,28983,28984,28985,28986,28987,28988,28989,28990,28991,28992,28993, +28994,28995,28996,28997,28998,28999,29000,29001,29002,29003,29004,29005, +29006,29007,29008,29009,29010,29011,29012,29013,29014,29015,29016,29017, +29018,29019,29020,29021,29022,29023,29024,29025,29026,29027,29028,29029, +29030,29031,29032,29033,29034,29035,29036,29037,29038,29039,29040,29041, +29042,29043,29044,29045,29046,29047,29048,29049,29050,29051,29052,29053, +29054,29055,29056,29057,29058,29059,29060,29061,29062,29063,29064,29065, +29066,29067,29068,29069,29070,29071,29072,29073,29074,29075,29076,29077, +29078,29079,29080,29081,29082,29083,29084,29085,29086,29087,29088,29089, +29090,29091,29092,29093,29094,29095,29096,29097,29098,29099,29100,29101, +29102,29103,29104,29105,29106,29107,29108,29109,29110,29111,29112,29113, +29114,29115,29116,29117,29118,29119,29120,29121,29122,29123,29124,29125, +29126,29127,29128,29129,29130,29131,29132,29133,29134,29135,29136,29137, +29138,29139,29140,29141,29142,29143,29144,29145,29146,29147,29148,29149, +29150,29151,29152,29153,29154,29155,29156,29157,29158,29159,29160,29161, +29162,29163,29164,29165,29166,29167,29168,29169,29170,29171,29172,29173, +29174,29175,29176,29177,29178,29179,29180,29181,29182,29183,29184,29185, +29186,29187,29188,29189,29190,29191,29192,29193,29194,29195,29196,29197, +29198,29199,29200,29201,29202,29203,29204,29205,29206,29207,29208,29209, +29210,29211,29212,29213,29214,29215,29216,29217,29218,29219,29220,29221, +29222,29223,29224,29225,29226,29227,29228,29229,29230,29231,29232,29233, +29234,29235,29236,29237,29238,29239,29240,29241,29242,29243,29244,29245, +29246,29247,29248,29249,29250,29251,29252,29253,29254,29255,29256,29257, +29258,29259,29260,29261,29262,29263,29264,29265,29266,29267,29268,29269, +29270,29271,29272,29273,29274,29275,29276,29277,29278,29279,29280,29281, +29282,29283,29284,29285,29286,29287,29288,29289,29290,29291,29292,29293, +29294,29295,29296,29297,29298,29299,29300,29301,29302,29303,29304,29305, +29306,29307,29308,29309,29310,29311,29312,29313,29314,29315,29316,29317, +29318,29319,29320,29321,29322,29323,29324,29325,29326,29327,29328,29329, +29330,29331,29332,29333,29334,29335,29336,29337,29338,29339,29340,29341, +29342,29343,29344,29345,29346,29347,29348,29349,29350,29351,29352,29353, +29354,29355,29356,29357,29358,29359,29360,29361,29362,29363,29364,29365, +29366,29367,29368,29369,29370,29371,29372,29373,29374,29375,29376,29377, +29378,29379,29380,29381,29382,29383,29384,29385,29386,29387,29388,29389, +29390,29391,29392,29393,29394,29395,29396,29397,29398,29399,29400,29401, +29402,29403,29404,29405,29406,29407,29408,29409,29410,29411,29412,29413, +29414,29415,29416,29417,29418,29419,29420,29421,29422,29423,29424,29425, +29426,29427,29428,29429,29430,29431,29432,29433,29434,29435,29436,29437, +29438,29439,29440,29441,29442,29443,29444,29445,29446,29447,29448,29449, +29450,29451,29452,29453,29454,29455,29456,29457,29458,29459,29460,29461, +29462,29463,29464,29465,29466,29467,29468,29469,29470,29471,29472,29473, +29474,29475,29476,29477,29478,29479,29480,29481,29482,29483,29484,29485, +29486,29487,29488,29489,29490,29491,29492,29493,29494,29495,29496,29497, +29498,29499,29500,29501,29502,29503,29504,29505,29506,29507,29508,29509, +29510,29511,29512,29513,29514,29515,29516,29517,29518,29519,29520,29521, +29522,29523,29524,29525,29526,29527,29528,29529,29530,29531,29532,29533, +29534,29535,29536,29537,29538,29539,29540,29541,29542,29543,29544,29545, +29546,29547,29548,29549,29550,29551,29552,29553,29554,29555,29556,29557, +29558,29559,29560,29561,29562,29563,29564,29565,29566,29567,29568,29569, +29570,29571,29572,29573,29574,29575,29576,29577,29578,29579,29580,29581, +29582,29583,29584,29585,29586,29587,29588,29589,29590,29591,29592,29593, +29594,29595,29596,29597,29598,29599,29600,29601,29602,29603,29604,29605, +29606,29607,29608,29609,29610,29611,29612,29613,29614,29615,29616,29617, +29618,29619,29620,29621,29622,29623,29624,29625,29626,29627,29628,29629, +29630,29631,29632,29633,29634,29635,29636,29637,29638,29639,29640,29641, +29642,29643,29644,29645,29646,29647,29648,29649,29650,29651,29652,29653, +29654,29655,29656,29657,29658,29659,29660,29661,29662,29663,29664,29665, +29666,29667,29668,29669,29670,29671,29672,29673,29674,29675,29676,29677, +29678,29679,29680,29681,29682,29683,29684,29685,29686,29687,29688,29689, +29690,29691,29692,29693,29694,29695,29696,29697,29698,29699,29700,29701, +29702,29703,29704,29705,29706,29707,29708,29709,29710,29711,29712,29713, +29714,29715,29716,29717,29718,29719,29720,29721,29722,29723,29724,29725, +29726,29727,29728,29729,29730,29731,29732,29733,29734,29735,29736,29737, +29738,29739,29740,29741,29742,29743,29744,29745,29746,29747,29748,29749, +29750,29751,29752,29753,29754,29755,29756,29757,29758,29759,29760,29761, +29762,29763,29764,29765,29766,29767,29768,29769,29770,29771,29772,29773, +29774,29775,29776,29777,29778,29779,29780,29781,29782,29783,29784,29785, +29786,29787,29788,29789,29790,29791,29792,29793,29794,29795,29796,29797, +29798,29799,29800,29801,29802,29803,29804,29805,29806,29807,29808,29809, +29810,29811,29812,29813,29814,29815,29816,29817,29818,29819,29820,29821, +29822,29823,29824,29825,29826,29827,29828,29829,29830,29831,29832,29833, +29834,29835,29836,29837,29838,29839,29840,29841,29842,29843,29844,29845, +29846,29847,29848,29849,29850,29851,29852,29853,29854,29855,29856,29857, +29858,29859,29860,29861,29862,29863,29864,29865,29866,29867,29868,29869, +29870,29871,29872,29873,29874,29875,29876,29877,29878,29879,29880,29881, +29882,29883,29884,29885,29886,29887,29888,29889,29890,29891,29892,29893, +29894,29895,29896,29897,29898,29899,29900,29901,29902,29903,29904,29905, +29906,29907,29908,29909,29910,29911,29912,29913,29914,29915,29916,29917, +29918,29919,29920,29921,29922,29923,29924,29925,29926,29927,29928,29929, +29930,29931,29932,29933,29934,29935,29936,29937,29938,29939,29940,29941, +29942,29943,29944,29945,29946,29947,29948,29949,29950,29951,29952,29953, +29954,29955,29956,29957,29958,29959,29960,29961,29962,29963,29964,29965, +29966,29967,29968,29969,29970,29971,29972,29973,29974,29975,29976,29977, +29978,29979,29980,29981,29982,29983,29984,29985,29986,29987,29988,29989, +29990,29991,29992,29993,29994,29995,29996,29997,29998,29999,30000,30001, +30002,30003,30004,30005,30006,30007,30008,30009,30010,30011,30012,30013, +30014,30015,30016,30017,30018,30019,30020,30021,30022,30023,30024,30025, +30026,30027,30028,30029,30030,30031,30032,30033,30034,30035,30036,30037, +30038,30039,30040,30041,30042,30043,30044,30045,30046,30047,30048,30049, +30050,30051,30052,30053,30054,30055,30056,30057,30058,30059,30060,30061, +30062,30063,30064,30065,30066,30067,30068,30069,30070,30071,30072,30073, +30074,30075,30076,30077,30078,30079,30080,30081,30082,30083,30084,30085, +30086,30087,30088,30089,30090,30091,30092,30093,30094,30095,30096,30097, +30098,30099,30100,30101,30102,30103,30104,30105,30106,30107,30108,30109, +30110,30111,30112,30113,30114,30115,30116,30117,30118,30119,30120,30121, +30122,30123,30124,30125,30126,30127,30128,30129,30130,30131,30132,30133, +30134,30135,30136,30137,30138,30139,30140,30141,30142,30143,30144,30145, +30146,30147,30148,30149,30150,30151,30152,30153,30154,30155,30156,30157, +30158,30159,30160,30161,30162,30163,30164,30165,30166,30167,30168,30169, +30170,30171,30172,30173,30174,30175,30176,30177,30178,30179,30180,30181, +30182,30183,30184,30185,30186,30187,30188,30189,30190,30191,30192,30193, +30194,30195,30196,30197,30198,30199,30200,30201,30202,30203,30204,30205, +30206,30207,30208,30209,30210,30211,30212,30213,30214,30215,30216,30217, +30218,30219,30220,30221,30222,30223,30224,30225,30226,30227,30228,30229, +30230,30231,30232,30233,30234,30235,30236,30237,30238,30239,30240,30241, +30242,30243,30244,30245,30246,30247,30248,30249,30250,30251,30252,30253, +30254,30255,30256,30257,30258,30259,30260,30261,30262,30263,30264,30265, +30266,30267,30268,30269,30270,30271,30272,30273,30274,30275,30276,30277, +30278,30279,30280,30281,30282,30283,30284,30285,30286,30287,30288,30289, +30290,30291,30292,30293,30294,30295,30296,30297,30298,30299,30300,30301, +30302,30303,30304,30305,30306,30307,30308,30309,30310,30311,30312,30313, +30314,30315,30316,30317,30318,30319,30320,30321,30322,30323,30324,30325, +30326,30327,30328,30329,30330,30331,30332,30333,30334,30335,30336,30337, +30338,30339,30340,30341,30342,30343,30344,30345,30346,30347,30348,30349, +30350,30351,30352,30353,30354,30355,30356,30357,30358,30359,30360,30361, +30362,30363,30364,30365,30366,30367,30368,30369,30370,30371,30372,30373, +30374,30375,30376,30377,30378,30379,30380,30381,30382,30383,30384,30385, +30386,30387,30388,30389,30390,30391,30392,30393,30394,30395,30396,30397, +30398,30399,30400,30401,30402,30403,30404,30405,30406,30407,30408,30409, +30410,30411,30412,30413,30414,30415,30416,30417,30418,30419,30420,30421, +30422,30423,30424,30425,30426,30427,30428,30429,30430,30431,30432,30433, +30434,30435,30436,30437,30438,30439,30440,30441,30442,30443,30444,30445, +30446,30447,30448,30449,30450,30451,30452,30453,30454,30455,30456,30457, +30458,30459,30460,30461,30462,30463,30464,30465,30466,30467,30468,30469, +30470,30471,30472,30473,30474,30475,30476,30477,30478,30479,30480,30481, +30482,30483,30484,30485,30486,30487,30488,30489,30490,30491,30492,30493, +30494,30495,30496,30497,30498,30499,30500,30501,30502,30503,30504,30505, +30506,30507,30508,30509,30510,30511,30512,30513,30514,30515,30516,30517, +30518,30519,30520,30521,30522,30523,30524,30525,30526,30527,30528,30529, +30530,30531,30532,30533,30534,30535,30536,30537,30538,30539,30540,30541, +30542,30543,30544,30545,30546,30547,30548,30549,30550,30551,30552,30553, +30554,30555,30556,30557,30558,30559,30560,30561,30562,30563,30564,30565, +30566,30567,30568,30569,30570,30571,30572,30573,30574,30575,30576,30577, +30578,30579,30580,30581,30582,30583,30584,30585,30586,30587,30588,30589, +30590,30591,30592,30593,30594,30595,30596,30597,30598,30599,30600,30601, +30602,30603,30604,30605,30606,30607,30608,30609,30610,30611,30612,30613, +30614,30615,30616,30617,30618,30619,30620,30621,30622,30623,30624,30625, +30626,30627,30628,30629,30630,30631,30632,30633,30634,30635,30636,30637, +30638,30639,30640,30641,30642,30643,30644,30645,30646,30647,30648,30649, +30650,30651,30652,30653,30654,30655,30656,30657,30658,30659,30660,30661, +30662,30663,30664,30665,30666,30667,30668,30669,30670,30671,30672,30673, +30674,30675,30676,30677,30678,30679,30680,30681,30682,30683,30684,30685, +30686,30687,30688,30689,30690,30691,30692,30693,30694,30695,30696,30697, +30698,30699,30700,30701,30702,30703,30704,30705,30706,30707,30708,30709, +30710,30711,30712,30713,30714,30715,30716,30717,30718,30719,30720,30721, +30722,30723,30724,30725,30726,30727,30728,30729,30730,30731,30732,30733, +30734,30735,30736,30737,30738,30739,30740,30741,30742,30743,30744,30745, +30746,30747,30748,30749,30750,30751,30752,30753,30754,30755,30756,30757, +30758,30759,30760,30761,30762,30763,30764,30765,30766,30767,30768,30769, +30770,30771,30772,30773,30774,30775,30776,30777,30778,30779,30780,30781, +30782,30783,30784,30785,30786,30787,30788,30789,30790,30791,30792,30793, +30794,30795,30796,30797,30798,30799,30800,30801,30802,30803,30804,30805, +30806,30807,30808,30809,30810,30811,30812,30813,30814,30815,30816,30817, +30818,30819,30820,30821,30822,30823,30824,30825,30826,30827,30828,30829, +30830,30831,30832,30833,30834,30835,30836,30837,30838,30839,30840,30841, +30842,30843,30844,30845,30846,30847,30848,30849,30850,30851,30852,30853, +30854,30855,30856,30857,30858,30859,30860,30861,30862,30863,30864,30865, +30866,30867,30868,30869,30870,30871,30872,30873,30874,30875,30876,30877, +30878,30879,30880,30881,30882,30883,30884,30885,30886,30887,30888,30889, +30890,30891,30892,30893,30894,30895,30896,30897,30898,30899,30900,30901, +30902,30903,30904,30905,30906,30907,30908,30909,30910,30911,30912,30913, +30914,30915,30916,30917,30918,30919,30920,30921,30922,30923,30924,30925, +30926,30927,30928,30929,30930,30931,30932,30933,30934,30935,30936,30937, +30938,30939,30940,30941,30942,30943,30944,30945,30946,30947,30948,30949, +30950,30951,30952,30953,30954,30955,30956,30957,30958,30959,30960,30961, +30962,30963,30964,30965,30966,30967,30968,30969,30970,30971,30972,30973, +30974,30975,30976,30977,30978,30979,30980,30981,30982,30983,30984,30985, +30986,30987,30988,30989,30990,30991,30992,30993,30994,30995,30996,30997, +30998,30999,31000,31001,31002,31003,31004,31005,31006,31007,31008,31009, +31010,31011,31012,31013,31014,31015,31016,31017,31018,31019,31020,31021, +31022,31023,31024,31025,31026,31027,31028,31029,31030,31031,31032,31033, +31034,31035,31036,31037,31038,31039,31040,31041,31042,31043,31044,31045, +31046,31047,31048,31049,31050,31051,31052,31053,31054,31055,31056,31057, +31058,31059,31060,31061,31062,31063,31064,31065,31066,31067,31068,31069, +31070,31071,31072,31073,31074,31075,31076,31077,31078,31079,31080,31081, +31082,31083,31084,31085,31086,31087,31088,31089,31090,31091,31092,31093, +31094,31095,31096,31097,31098,31099,31100,31101,31102,31103,31104,31105, +31106,31107,31108,31109,31110,31111,31112,31113,31114,31115,31116,31117, +31118,31119,31120,31121,31122,31123,31124,31125,31126,31127,31128,31129, +31130,31131,31132,31133,31134,31135,31136,31137,31138,31139,31140,31141, +31142,31143,31144,31145,31146,31147,31148,31149,31150,31151,31152,31153, +31154,31155,31156,31157,31158,31159,31160,31161,31162,31163,31164,31165, +31166,31167,31168,31169,31170,31171,31172,31173,31174,31175,31176,31177, +31178,31179,31180,31181,31182,31183,31184,31185,31186,31187,31188,31189, +31190,31191,31192,31193,31194,31195,31196,31197,31198,31199,31200,31201, +31202,31203,31204,31205,31206,31207,31208,31209,31210,31211,31212,31213, +31214,31215,31216,31217,31218,31219,31220,31221,31222,31223,31224,31225, +31226,31227,31228,31229,31230,31231,31232,31233,31234,31235,31236,31237, +31238,31239,31240,31241,31242,31243,31244,31245,31246,31247,31248,31249, +31250,31251,31252,31253,31254,31255,31256,31257,31258,31259,31260,31261, +31262,31263,31264,31265,31266,31267,31268,31269,31270,31271,31272,31273, +31274,31275,31276,31277,31278,31279,31280,31281,31282,31283,31284,31285, +31286,31287,31288,31289,31290,31291,31292,31293,31294,31295,31296,31297, +31298,31299,31300,31301,31302,31303,31304,31305,31306,31307,31308,31309, +31310,31311,31312,31313,31314,31315,31316,31317,31318,31319,31320,31321, +31322,31323,31324,31325,31326,31327,31328,31329,31330,31331,31332,31333, +31334,31335,31336,31337,31338,31339,31340,31341,31342,31343,31344,31345, +31346,31347,31348,31349,31350,31351,31352,31353,31354,31355,31356,31357, +31358,31359,31360,31361,31362,31363,31364,31365,31366,31367,31368,31369, +31370,31371,31372,31373,31374,31375,31376,31377,31378,31379,31380,31381, +31382,31383,31384,31385,31386,31387,31388,31389,31390,31391,31392,31393, +31394,31395,31396,31397,31398,31399,31400,31401,31402,31403,31404,31405, +31406,31407,31408,31409,31410,31411,31412,31413,31414,31415,31416,31417, +31418,31419,31420,31421,31422,31423,31424,31425,31426,31427,31428,31429, +31430,31431,31432,31433,31434,31435,31436,31437,31438,31439,31440,31441, +31442,31443,31444,31445,31446,31447,31448,31449,31450,31451,31452,31453, +31454,31455,31456,31457,31458,31459,31460,31461,31462,31463,31464,31465, +31466,31467,31468,31469,31470,31471,31472,31473,31474,31475,31476,31477, +31478,31479,31480,31481,31482,31483,31484,31485,31486,31487,31488,31489, +31490,31491,31492,31493,31494,31495,31496,31497,31498,31499,31500,31501, +31502,31503,31504,31505,31506,31507,31508,31509,31510,31511,31512,31513, +31514,31515,31516,31517,31518,31519,31520,31521,31522,31523,31524,31525, +31526,31527,31528,31529,31530,31531,31532,31533,31534,31535,31536,31537, +31538,31539,31540,31541,31542,31543,31544,31545,31546,31547,31548,31549, +31550,31551,31552,31553,31554,31555,31556,31557,31558,31559,31560,31561, +31562,31563,31564,31565,31566,31567,31568,31569,31570,31571,31572,31573, +31574,31575,31576,31577,31578,31579,31580,31581,31582,31583,31584,31585, +31586,31587,31588,31589,31590,31591,31592,31593,31594,31595,31596,31597, +31598,31599,31600,31601,31602,31603,31604,31605,31606,31607,31608,31609, +31610,31611,31612,31613,31614,31615,31616,31617,31618,31619,31620,31621, +31622,31623,31624,31625,31626,31627,31628,31629,31630,31631,31632,31633, +31634,31635,31636,31637,31638,31639,31640,31641,31642,31643,31644,31645, +31646,31647,31648,31649,31650,31651,31652,31653,31654,31655,31656,31657, +31658,31659,31660,31661,31662,31663,31664,31665,31666,31667,31668,31669, +31670,31671,31672,31673,31674,31675,31676,31677,31678,31679,31680,31681, +31682,31683,31684,31685,31686,31687,31688,31689,31690,31691,31692,31693, +31694,31695,31696,31697,31698,31699,31700,31701,31702,31703,31704,31705, +31706,31707,31708,31709,31710,31711,31712,31713,31714,31715,31716,31717, +31718,31719,31720,31721,31722,31723,31724,31725,31726,31727,31728,31729, +31730,31731,31732,31733,31734,31735,31736,31737,31738,31739,31740,31741, +31742,31743,31744,31745,31746,31747,31748,31749,31750,31751,31752,31753, +31754,31755,31756,31757,31758,31759,31760,31761,31762,31763,31764,31765, +31766,31767,31768,31769,31770,31771,31772,31773,31774,31775,31776,31777, +31778,31779,31780,31781,31782,31783,31784,31785,31786,31787,31788,31789, +31790,31791,31792,31793,31794,31795,31796,31797,31798,31799,31800,31801, +31802,31803,31804,31805,31806,31807,31808,31809,31810,31811,31812,31813, +31814,31815,31816,31817,31818,31819,31820,31821,31822,31823,31824,31825, +31826,31827,31828,31829,31830,31831,31832,31833,31834,31835,31836,31837, +31838,31839,31840,31841,31842,31843,31844,31845,31846,31847,31848,31849, +31850,31851,31852,31853,31854,31855,31856,31857,31858,31859,31860,31861, +31862,31863,31864,31865,31866,31867,31868,31869,31870,31871,31872,31873, +31874,31875,31876,31877,31878,31879,31880,31881,31882,31883,31884,31885, +31886,31887,31888,31889,31890,31891,31892,31893,31894,31895,31896,31897, +31898,31899,31900,31901,31902,31903,31904,31905,31906,31907,31908,31909, +31910,31911,31912,31913,31914,31915,31916,31917,31918,31919,31920,31921, +31922,31923,31924,31925,31926,31927,31928,31929,31930,31931,31932,31933, +31934,31935,31936,31937,31938,31939,31940,31941,31942,31943,31944,31945, +31946,31947,31948,31949,31950,31951,31952,31953,31954,31955,31956,31957, +31958,31959,31960,31961,31962,31963,31964,31965,31966,31967,31968,31969, +31970,31971,31972,31973,31974,31975,31976,31977,31978,31979,31980,31981, +31982,31983,31984,31985,31986,31987,31988,31989,31990,31991,31992,31993, +31994,31995,31996,31997,31998,31999,32000,32001,32002,32003,32004,32005, +32006,32007,32008,32009,32010,32011,32012,32013,32014,32015,32016,32017, +32018,32019,32020,32021,32022,32023,32024,32025,32026,32027,32028,32029, +32030,32031,32032,32033,32034,32035,32036,32037,32038,32039,32040,32041, +32042,32043,32044,32045,32046,32047,32048,32049,32050,32051,32052,32053, +32054,32055,32056,32057,32058,32059,32060,32061,32062,32063,32064,32065, +32066,32067,32068,32069,32070,32071,32072,32073,32074,32075,32076,32077, +32078,32079,32080,32081,32082,32083,32084,32085,32086,32087,32088,32089, +32090,32091,32092,32093,32094,32095,32096,32097,32098,32099,32100,32101, +32102,32103,32104,32105,32106,32107,32108,32109,32110,32111,32112,32113, +32114,32115,32116,32117,32118,32119,32120,32121,32122,32123,32124,32125, +32126,32127,32128,32129,32130,32131,32132,32133,32134,32135,32136,32137, +32138,32139,32140,32141,32142,32143,32144,32145,32146,32147,32148,32149, +32150,32151,32152,32153,32154,32155,32156,32157,32158,32159,32160,32161, +32162,32163,32164,32165,32166,32167,32168,32169,32170,32171,32172,32173, +32174,32175,32176,32177,32178,32179,32180,32181,32182,32183,32184,32185, +32186,32187,32188,32189,32190,32191,32192,32193,32194,32195,32196,32197, +32198,32199,32200,32201,32202,32203,32204,32205,32206,32207,32208,32209, +32210,32211,32212,32213,32214,32215,32216,32217,32218,32219,32220,32221, +32222,32223,32224,32225,32226,32227,32228,32229,32230,32231,32232,32233, +32234,32235,32236,32237,32238,32239,32240,32241,32242,32243,32244,32245, +32246,32247,32248,32249,32250,32251,32252,32253,32254,32255,32256,32257, +32258,32259,32260,32261,32262,32263,32264,32265,32266,32267,32268,32269, +32270,32271,32272,32273,32274,32275,32276,32277,32278,32279,32280,32281, +32282,32283,32284,32285,32286,32287,32288,32289,32290,32291,32292,32293, +32294,32295,32296,32297,32298,32299,32300,32301,32302,32303,32304,32305, +32306,32307,32308,32309,32310,32311,32312,32313,32314,32315,32316,32317, +32318,32319,32320,32321,32322,32323,32324,32325,32326,32327,32328,32329, +32330,32331,32332,32333,32334,32335,32336,32337,32338,32339,32340,32341, +32342,32343,32344,32345,32346,32347,32348,32349,32350,32351,32352,32353, +32354,32355,32356,32357,32358,32359,32360,32361,32362,32363,32364,32365, +32366,32367,32368,32369,32370,32371,32372,32373,32374,32375,32376,32377, +32378,32379,32380,32381,32382,32383,32384,32385,32386,32387,32388,32389, +32390,32391,32392,32393,32394,32395,32396,32397,32398,32399,32400,32401, +32402,32403,32404,32405,32406,32407,32408,32409,32410,32411,32412,32413, +32414,32415,32416,32417,32418,32419,32420,32421,32422,32423,32424,32425, +32426,32427,32428,32429,32430,32431,32432,32433,32434,32435,32436,32437, +32438,32439,32440,32441,32442,32443,32444,32445,32446,32447,32448,32449, +32450,32451,32452,32453,32454,32455,32456,32457,32458,32459,32460,32461, +32462,32463,32464,32465,32466,32467,32468,32469,32470,32471,32472,32473, +32474,32475,32476,32477,32478,32479,32480,32481,32482,32483,32484,32485, +32486,32487,32488,32489,32490,32491,32492,32493,32494,32495,32496,32497, +32498,32499,32500,32501,32502,32503,32504,32505,32506,32507,32508,32509, +32510,32511,32512,32513,32514,32515,32516,32517,32518,32519,32520,32521, +32522,32523,32524,32525,32526,32527,32528,32529,32530,32531,32532,32533, +32534,32535,32536,32537,32538,32539,32540,32541,32542,32543,32544,32545, +32546,32547,32548,32549,32550,32551,32552,32553,32554,32555,32556,32557, +32558,32559,32560,32561,32562,32563,32564,32565,32566,32567,32568,32569, +32570,32571,32572,32573,32574,32575,32576,32577,32578,32579,32580,32581, +32582,32583,32584,32585,32586,32587,32588,32589,32590,32591,32592,32593, +32594,32595,32596,32597,32598,32599,32600,32601,32602,32603,32604,32605, +32606,32607,32608,32609,32610,32611,32612,32613,32614,32615,32616,32617, +32618,32619,32620,32621,32622,32623,32624,32625,32626,32627,32628,32629, +32630,32631,32632,32633,32634,32635,32636,32637,32638,32639,32640,32641, +32642,32643,32644,32645,32646,32647,32648,32649,32650,32651,32652,32653, +32654,32655,32656,32657,32658,32659,32660,32661,32662,32663,32664,32665, +32666,32667,32668,32669,32670,32671,32672,32673,32674,32675,32676,32677, +32678,32679,32680,32681,32682,32683,32684,32685,32686,32687,32688,32689, +32690,32691,32692,32693,32694,32695,32696,32697,32698,32699,32700,32701, +32702,32703,32704,32705,32706,32707,32708,32709,32710,32711,32712,32713, +32714,32715,32716,32717,32718,32719,32720,32721,32722,32723,32724,32725, +32726,32727,32728,32729,32730,32731,32732,32733,32734,32735,32736,32737, +32738,32739,32740,32741,32742,32743,32744,32745,32746,32747,32748,32749, +32750,32751,32752,32753,32754,32755,32756,32757,32758,32759,32760,32761, +32762,32763,32764,32765,32766,32767,32768,32769,32770,32771,32772,32773, +32774,32775,32776,32777,32778,32779,32780,32781,32782,32783,32784,32785, +32786,32787,32788,32789,32790,32791,32792,32793,32794,32795,32796,32797, +32798,32799,32800,32801,32802,32803,32804,32805,32806,32807,32808,32809, +32810,32811,32812,32813,32814,32815,32816,32817,32818,32819,32820,32821, +32822,32823,32824,32825,32826,32827,32828,32829,32830,32831,32832,32833, +32834,32835,32836,32837,32838,32839,32840,32841,32842,32843,32844,32845, +32846,32847,32848,32849,32850,32851,32852,32853,32854,32855,32856,32857, +32858,32859,32860,32861,32862,32863,32864,32865,32866,32867,32868,32869, +32870,32871,32872,32873,32874,32875,32876,32877,32878,32879,32880,32881, +32882,32883,32884,32885,32886,32887,32888,32889,32890,32891,32892,32893, +32894,32895,32896,32897,32898,32899,32900,32901,32902,32903,32904,32905, +32906,32907,32908,32909,32910,32911,32912,32913,32914,32915,32916,32917, +32918,32919,32920,32921,32922,32923,32924,32925,32926,32927,32928,32929, +32930,32931,32932,32933,32934,32935,32936,32937,32938,32939,32940,32941, +32942,32943,32944,32945,32946,32947,32948,32949,32950,32951,32952,32953, +32954,32955,32956,32957,32958,32959,32960,32961,32962,32963,32964,32965, +32966,32967,32968,32969,32970,32971,32972,32973,32974,32975,32976,32977, +32978,32979,32980,32981,32982,32983,32984,32985,32986,32987,32988,32989, +32990,32991,32992,32993,32994,32995,32996,32997,32998,32999,33000,33001, +33002,33003,33004,33005,33006,33007,33008,33009,33010,33011,33012,33013, +33014,33015,33016,33017,33018,33019,33020,33021,33022,33023,33024,33025, +33026,33027,33028,33029,33030,33031,33032,33033,33034,33035,33036,33037, +33038,33039,33040,33041,33042,33043,33044,33045,33046,33047,33048,33049, +33050,33051,33052,33053,33054,33055,33056,33057,33058,33059,33060,33061, +33062,33063,33064,33065,33066,33067,33068,33069,33070,33071,33072,33073, +33074,33075,33076,33077,33078,33079,33080,33081,33082,33083,33084,33085, +33086,33087,33088,33089,33090,33091,33092,33093,33094,33095,33096,33097, +33098,33099,33100,33101,33102,33103,33104,33105,33106,33107,33108,33109, +33110,33111,33112,33113,33114,33115,33116,33117,33118,33119,33120,33121, +33122,33123,33124,33125,33126,33127,33128,33129,33130,33131,33132,33133, +33134,33135,33136,33137,33138,33139,33140,33141,33142,33143,33144,33145, +33146,33147,33148,33149,33150,33151,33152,33153,33154,33155,33156,33157, +33158,33159,33160,33161,33162,33163,33164,33165,33166,33167,33168,33169, +33170,33171,33172,33173,33174,33175,33176,33177,33178,33179,33180,33181, +33182,33183,33184,33185,33186,33187,33188,33189,33190,33191,33192,33193, +33194,33195,33196,33197,33198,33199,33200,33201,33202,33203,33204,33205, +33206,33207,33208,33209,33210,33211,33212,33213,33214,33215,33216,33217, +33218,33219,33220,33221,33222,33223,33224,33225,33226,33227,33228,33229, +33230,33231,33232,33233,33234,33235,33236,33237,33238,33239,33240,33241, +33242,33243,33244,33245,33246,33247,33248,33249,33250,33251,33252,33253, +33254,33255,33256,33257,33258,33259,33260,33261,33262,33263,33264,33265, +33266,33267,33268,33269,33270,33271,33272,33273,33274,33275,33276,33277, +33278,33279,33280,33281,33282,33283,33284,33285,33286,33287,33288,33289, +33290,33291,33292,33293,33294,33295,33296,33297,33298,33299,33300,33301, +33302,33303,33304,33305,33306,33307,33308,33309,33310,33311,33312,33313, +33314,33315,33316,33317,33318,33319,33320,33321,33322,33323,33324,33325, +33326,33327,33328,33329,33330,33331,33332,33333,33334,33335,33336,33337, +33338,33339,33340,33341,33342,33343,33344,33345,33346,33347,33348,33349, +33350,33351,33352,33353,33354,33355,33356,33357,33358,33359,33360,33361, +33362,33363,33364,33365,33366,33367,33368,33369,33370,33371,33372,33373, +33374,33375,33376,33377,33378,33379,33380,33381,33382,33383,33384,33385, +33386,33387,33388,33389,33390,33391,33392,33393,33394,33395,33396,33397, +33398,33399,33400,33401,33402,33403,33404,33405,33406,33407,33408,33409, +33410,33411,33412,33413,33414,33415,33416,33417,33418,33419,33420,33421, +33422,33423,33424,33425,33426,33427,33428,33429,33430,33431,33432,33433, +33434,33435,33436,33437,33438,33439,33440,33441,33442,33443,33444,33445, +33446,33447,33448,33449,33450,33451,33452,33453,33454,33455,33456,33457, +33458,33459,33460,33461,33462,33463,33464,33465,33466,33467,33468,33469, +33470,33471,33472,33473,33474,33475,33476,33477,33478,33479,33480,33481, +33482,33483,33484,33485,33486,33487,33488,33489,33490,33491,33492,33493, +33494,33495,33496,33497,33498,33499,33500,33501,33502,33503,33504,33505, +33506,33507,33508,33509,33510,33511,33512,33513,33514,33515,33516,33517, +33518,33519,33520,33521,33522,33523,33524,33525,33526,33527,33528,33529, +33530,33531,33532,33533,33534,33535,33536,33537,33538,33539,33540,33541, +33542,33543,33544,33545,33546,33547,33548,33549,33550,33551,33552,33553, +33554,33555,33556,33557,33558,33559,33560,33561,33562,33563,33564,33565, +33566,33567,33568,33569,33570,33571,33572,33573,33574,33575,33576,33577, +33578,33579,33580,33581,33582,33583,33584,33585,33586,33587,33588,33589, +33590,33591,33592,33593,33594,33595,33596,33597,33598,33599,33600,33601, +33602,33603,33604,33605,33606,33607,33608,33609,33610,33611,33612,33613, +33614,33615,33616,33617,33618,33619,33620,33621,33622,33623,33624,33625, +33626,33627,33628,33629,33630,33631,33632,33633,33634,33635,33636,33637, +33638,33639,33640,33641,33642,33643,33644,33645,33646,33647,33648,33649, +33650,33651,33652,33653,33654,33655,33656,33657,33658,33659,33660,33661, +33662,33663,33664,33665,33666,33667,33668,33669,33670,33671,33672,33673, +33674,33675,33676,33677,33678,33679,33680,33681,33682,33683,33684,33685, +33686,33687,33688,33689,33690,33691,33692,33693,33694,33695,33696,33697, +33698,33699,33700,33701,33702,33703,33704,33705,33706,33707,33708,33709, +33710,33711,33712,33713,33714,33715,33716,33717,33718,33719,33720,33721, +33722,33723,33724,33725,33726,33727,33728,33729,33730,33731,33732,33733, +33734,33735,33736,33737,33738,33739,33740,33741,33742,33743,33744,33745, +33746,33747,33748,33749,33750,33751,33752,33753,33754,33755,33756,33757, +33758,33759,33760,33761,33762,33763,33764,33765,33766,33767,33768,33769, +33770,33771,33772,33773,33774,33775,33776,33777,33778,33779,33780,33781, +33782,33783,33784,33785,33786,33787,33788,33789,33790,33791,33792,33793, +33794,33795,33796,33797,33798,33799,33800,33801,33802,33803,33804,33805, +33806,33807,33808,33809,33810,33811,33812,33813,33814,33815,33816,33817, +33818,33819,33820,33821,33822,33823,33824,33825,33826,33827,33828,33829, +33830,33831,33832,33833,33834,33835,33836,33837,33838,33839,33840,33841, +33842,33843,33844,33845,33846,33847,33848,33849,33850,33851,33852,33853, +33854,33855,33856,33857,33858,33859,33860,33861,33862,33863,33864,33865, +33866,33867,33868,33869,33870,33871,33872,33873,33874,33875,33876,33877, +33878,33879,33880,33881,33882,33883,33884,33885,33886,33887,33888,33889, +33890,33891,33892,33893,33894,33895,33896,33897,33898,33899,33900,33901, +33902,33903,33904,33905,33906,33907,33908,33909,33910,33911,33912,33913, +33914,33915,33916,33917,33918,33919,33920,33921,33922,33923,33924,33925, +33926,33927,33928,33929,33930,33931,33932,33933,33934,33935,33936,33937, +33938,33939,33940,33941,33942,33943,33944,33945,33946,33947,33948,33949, +33950,33951,33952,33953,33954,33955,33956,33957,33958,33959,33960,33961, +33962,33963,33964,33965,33966,33967,33968,33969,33970,33971,33972,33973, +33974,33975,33976,33977,33978,33979,33980,33981,33982,33983,33984,33985, +33986,33987,33988,33989,33990,33991,33992,33993,33994,33995,33996,33997, +33998,33999,34000,34001,34002,34003,34004,34005,34006,34007,34008,34009, +34010,34011,34012,34013,34014,34015,34016,34017,34018,34019,34020,34021, +34022,34023,34024,34025,34026,34027,34028,34029,34030,34031,34032,34033, +34034,34035,34036,34037,34038,34039,34040,34041,34042,34043,34044,34045, +34046,34047,34048,34049,34050,34051,34052,34053,34054,34055,34056,34057, +34058,34059,34060,34061,34062,34063,34064,34065,34066,34067,34068,34069, +34070,34071,34072,34073,34074,34075,34076,34077,34078,34079,34080,34081, +34082,34083,34084,34085,34086,34087,34088,34089,34090,34091,34092,34093, +34094,34095,34096,34097,34098,34099,34100,34101,34102,34103,34104,34105, +34106,34107,34108,34109,34110,34111,34112,34113,34114,34115,34116,34117, +34118,34119,34120,34121,34122,34123,34124,34125,34126,34127,34128,34129, +34130,34131,34132,34133,34134,34135,34136,34137,34138,34139,34140,34141, +34142,34143,34144,34145,34146,34147,34148,34149,34150,34151,34152,34153, +34154,34155,34156,34157,34158,34159,34160,34161,34162,34163,34164,34165, +34166,34167,34168,34169,34170,34171,34172,34173,34174,34175,34176,34177, +34178,34179,34180,34181,34182,34183,34184,34185,34186,34187,34188,34189, +34190,34191,34192,34193,34194,34195,34196,34197,34198,34199,34200,34201, +34202,34203,34204,34205,34206,34207,34208,34209,34210,34211,34212,34213, +34214,34215,34216,34217,34218,34219,34220,34221,34222,34223,34224,34225, +34226,34227,34228,34229,34230,34231,34232,34233,34234,34235,34236,34237, +34238,34239,34240,34241,34242,34243,34244,34245,34246,34247,34248,34249, +34250,34251,34252,34253,34254,34255,34256,34257,34258,34259,34260,34261, +34262,34263,34264,34265,34266,34267,34268,34269,34270,34271,34272,34273, +34274,34275,34276,34277,34278,34279,34280,34281,34282,34283,34284,34285, +34286,34287,34288,34289,34290,34291,34292,34293,34294,34295,34296,34297, +34298,34299,34300,34301,34302,34303,34304,34305,34306,34307,34308,34309, +34310,34311,34312,34313,34314,34315,34316,34317,34318,34319,34320,34321, +34322,34323,34324,34325,34326,34327,34328,34329,34330,34331,34332,34333, +34334,34335,34336,34337,34338,34339,34340,34341,34342,34343,34344,34345, +34346,34347,34348,34349,34350,34351,34352,34353,34354,34355,34356,34357, +34358,34359,34360,34361,34362,34363,34364,34365,34366,34367,34368,34369, +34370,34371,34372,34373,34374,34375,34376,34377,34378,34379,34380,34381, +34382,34383,34384,34385,34386,34387,34388,34389,34390,34391,34392,34393, +34394,34395,34396,34397,34398,34399,34400,34401,34402,34403,34404,34405, +34406,34407,34408,34409,34410,34411,34412,34413,34414,34415,34416,34417, +34418,34419,34420,34421,34422,34423,34424,34425,34426,34427,34428,34429, +34430,34431,34432,34433,34434,34435,34436,34437,34438,34439,34440,34441, +34442,34443,34444,34445,34446,34447,34448,34449,34450,34451,34452,34453, +34454,34455,34456,34457,34458,34459,34460,34461,34462,34463,34464,34465, +34466,34467,34468,34469,34470,34471,34472,34473,34474,34475,34476,34477, +34478,34479,34480,34481,34482,34483,34484,34485,34486,34487,34488,34489, +34490,34491,34492,34493,34494,34495,34496,34497,34498,34499,34500,34501, +34502,34503,34504,34505,34506,34507,34508,34509,34510,34511,34512,34513, +34514,34515,34516,34517,34518,34519,34520,34521,34522,34523,34524,34525, +34526,34527,34528,34529,34530,34531,34532,34533,34534,34535,34536,34537, +34538,34539,34540,34541,34542,34543,34544,34545,34546,34547,34548,34549, +34550,34551,34552,34553,34554,34555,34556,34557,34558,34559,34560,34561, +34562,34563,34564,34565,34566,34567,34568,34569,34570,34571,34572,34573, +34574,34575,34576,34577,34578,34579,34580,34581,34582,34583,34584,34585, +34586,34587,34588,34589,34590,34591,34592,34593,34594,34595,34596,34597, +34598,34599,34600,34601,34602,34603,34604,34605,34606,34607,34608,34609, +34610,34611,34612,34613,34614,34615,34616,34617,34618,34619,34620,34621, +34622,34623,34624,34625,34626,34627,34628,34629,34630,34631,34632,34633, +34634,34635,34636,34637,34638,34639,34640,34641,34642,34643,34644,34645, +34646,34647,34648,34649,34650,34651,34652,34653,34654,34655,34656,34657, +34658,34659,34660,34661,34662,34663,34664,34665,34666,34667,34668,34669, +34670,34671,34672,34673,34674,34675,34676,34677,34678,34679,34680,34681, +34682,34683,34684,34685,34686,34687,34688,34689,34690,34691,34692,34693, +34694,34695,34696,34697,34698,34699,34700,34701,34702,34703,34704,34705, +34706,34707,34708,34709,34710,34711,34712,34713,34714,34715,34716,34717, +34718,34719,34720,34721,34722,34723,34724,34725,34726,34727,34728,34729, +34730,34731,34732,34733,34734,34735,34736,34737,34738,34739,34740,34741, +34742,34743,34744,34745,34746,34747,34748,34749,34750,34751,34752,34753, +34754,34755,34756,34757,34758,34759,34760,34761,34762,34763,34764,34765, +34766,34767,34768,34769,34770,34771,34772,34773,34774,34775,34776,34777, +34778,34779,34780,34781,34782,34783,34784,34785,34786,34787,34788,34789, +34790,34791,34792,34793,34794,34795,34796,34797,34798,34799,34800,34801, +34802,34803,34804,34805,34806,34807,34808,34809,34810,34811,34812,34813, +34814,34815,34816,34817,34818,34819,34820,34821,34822,34823,34824,34825, +34826,34827,34828,34829,34830,34831,34832,34833,34834,34835,34836,34837, +34838,34839,34840,34841,34842,34843,34844,34845,34846,34847,34848,34849, +34850,34851,34852,34853,34854,34855,34856,34857,34858,34859,34860,34861, +34862,34863,34864,34865,34866,34867,34868,34869,34870,34871,34872,34873, +34874,34875,34876,34877,34878,34879,34880,34881,34882,34883,34884,34885, +34886,34887,34888,34889,34890,34891,34892,34893,34894,34895,34896,34897, +34898,34899,34900,34901,34902,34903,34904,34905,34906,34907,34908,34909, +34910,34911,34912,34913,34914,34915,34916,34917,34918,34919,34920,34921, +34922,34923,34924,34925,34926,34927,34928,34929,34930,34931,34932,34933, +34934,34935,34936,34937,34938,34939,34940,34941,34942,34943,34944,34945, +34946,34947,34948,34949,34950,34951,34952,34953,34954,34955,34956,34957, +34958,34959,34960,34961,34962,34963,34964,34965,34966,34967,34968,34969, +34970,34971,34972,34973,34974,34975,34976,34977,34978,34979,34980,34981, +34982,34983,34984,34985,34986,34987,34988,34989,34990,34991,34992,34993, +34994,34995,34996,34997,34998,34999,35000,35001,35002,35003,35004,35005, +35006,35007,35008,35009,35010,35011,35012,35013,35014,35015,35016,35017, +35018,35019,35020,35021,35022,35023,35024,35025,35026,35027,35028,35029, +35030,35031,35032,35033,35034,35035,35036,35037,35038,35039,35040,35041, +35042,35043,35044,35045,35046,35047,35048,35049,35050,35051,35052,35053, +35054,35055,35056,35057,35058,35059,35060,35061,35062,35063,35064,35065, +35066,35067,35068,35069,35070,35071,35072,35073,35074,35075,35076,35077, +35078,35079,35080,35081,35082,35083,35084,35085,35086,35087,35088,35089, +35090,35091,35092,35093,35094,35095,35096,35097,35098,35099,35100,35101, +35102,35103,35104,35105,35106,35107,35108,35109,35110,35111,35112,35113, +35114,35115,35116,35117,35118,35119,35120,35121,35122,35123,35124,35125, +35126,35127,35128,35129,35130,35131,35132,35133,35134,35135,35136,35137, +35138,35139,35140,35141,35142,35143,35144,35145,35146,35147,35148,35149, +35150,35151,35152,35153,35154,35155,35156,35157,35158,35159,35160,35161, +35162,35163,35164,35165,35166,35167,35168,35169,35170,35171,35172,35173, +35174,35175,35176,35177,35178,35179,35180,35181,35182,35183,35184,35185, +35186,35187,35188,35189,35190,35191,35192,35193,35194,35195,35196,35197, +35198,35199,35200,35201,35202,35203,35204,35205,35206,35207,35208,35209, +35210,35211,35212,35213,35214,35215,35216,35217,35218,35219,35220,35221, +35222,35223,35224,35225,35226,35227,35228,35229,35230,35231,35232,35233, +35234,35235,35236,35237,35238,35239,35240,35241,35242,35243,35244,35245, +35246,35247,35248,35249,35250,35251,35252,35253,35254,35255,35256,35257, +35258,35259,35260,35261,35262,35263,35264,35265,35266,35267,35268,35269, +35270,35271,35272,35273,35274,35275,35276,35277,35278,35279,35280,35281, +35282,35283,35284,35285,35286,35287,35288,35289,35290,35291,35292,35293, +35294,35295,35296,35297,35298,35299,35300,35301,35302,35303,35304,35305, +35306,35307,35308,35309,35310,35311,35312,35313,35314,35315,35316,35317, +35318,35319,35320,35321,35322,35323,35324,35325,35326,35327,35328,35329, +35330,35331,35332,35333,35334,35335,35336,35337,35338,35339,35340,35341, +35342,35343,35344,35345,35346,35347,35348,35349,35350,35351,35352,35353, +35354,35355,35356,35357,35358,35359,35360,35361,35362,35363,35364,35365, +35366,35367,35368,35369,35370,35371,35372,35373,35374,35375,35376,35377, +35378,35379,35380,35381,35382,35383,35384,35385,35386,35387,35388,35389, +35390,35391,35392,35393,35394,35395,35396,35397,35398,35399,35400,35401, +35402,35403,35404,35405,35406,35407,35408,35409,35410,35411,35412,35413, +35414,35415,35416,35417,35418,35419,35420,35421,35422,35423,35424,35425, +35426,35427,35428,35429,35430,35431,35432,35433,35434,35435,35436,35437, +35438,35439,35440,35441,35442,35443,35444,35445,35446,35447,35448,35449, +35450,35451,35452,35453,35454,35455,35456,35457,35458,35459,35460,35461, +35462,35463,35464,35465,35466,35467,35468,35469,35470,35471,35472,35473, +35474,35475,35476,35477,35478,35479,35480,35481,35482,35483,35484,35485, +35486,35487,35488,35489,35490,35491,35492,35493,35494,35495,35496,35497, +35498,35499,35500,35501,35502,35503,35504,35505,35506,35507,35508,35509, +35510,35511,35512,35513,35514,35515,35516,35517,35518,35519,35520,35521, +35522,35523,35524,35525,35526,35527,35528,35529,35530,35531,35532,35533, +35534,35535,35536,35537,35538,35539,35540,35541,35542,35543,35544,35545, +35546,35547,35548,35549,35550,35551,35552,35553,35554,35555,35556,35557, +35558,35559,35560,35561,35562,35563,35564,35565,35566,35567,35568,35569, +35570,35571,35572,35573,35574,35575,35576,35577,35578,35579,35580,35581, +35582,35583,35584,35585,35586,35587,35588,35589,35590,35591,35592,35593, +35594,35595,35596,35597,35598,35599,35600,35601,35602,35603,35604,35605, +35606,35607,35608,35609,35610,35611,35612,35613,35614,35615,35616,35617, +35618,35619,35620,35621,35622,35623,35624,35625,35626,35627,35628,35629, +35630,35631,35632,35633,35634,35635,35636,35637,35638,35639,35640,35641, +35642,35643,35644,35645,35646,35647,35648,35649,35650,35651,35652,35653, +35654,35655,35656,35657,35658,35659,35660,35661,35662,35663,35664,35665, +35666,35667,35668,35669,35670,35671,35672,35673,35674,35675,35676,35677, +35678,35679,35680,35681,35682,35683,35684,35685,35686,35687,35688,35689, +35690,35691,35692,35693,35694,35695,35696,35697,35698,35699,35700,35701, +35702,35703,35704,35705,35706,35707,35708,35709,35710,35711,35712,35713, +35714,35715,35716,35717,35718,35719,35720,35721,35722,35723,35724,35725, +35726,35727,35728,35729,35730,35731,35732,35733,35734,35735,35736,35737, +35738,35739,35740,35741,35742,35743,35744,35745,35746,35747,35748,35749, +35750,35751,35752,35753,35754,35755,35756,35757,35758,35759,35760,35761, +35762,35763,35764,35765,35766,35767,35768,35769,35770,35771,35772,35773, +35774,35775,35776,35777,35778,35779,35780,35781,35782,35783,35784,35785, +35786,35787,35788,35789,35790,35791,35792,35793,35794,35795,35796,35797, +35798,35799,35800,35801,35802,35803,35804,35805,35806,35807,35808,35809, +35810,35811,35812,35813,35814,35815,35816,35817,35818,35819,35820,35821, +35822,35823,35824,35825,35826,35827,35828,35829,35830,35831,35832,35833, +35834,35835,35836,35837,35838,35839,35840,35841,35842,35843,35844,35845, +35846,35847,35848,35849,35850,35851,35852,35853,35854,35855,35856,35857, +35858,35859,35860,35861,35862,35863,35864,35865,35866,35867,35868,35869, +35870,35871,35872,35873,35874,35875,35876,35877,35878,35879,35880,35881, +35882,35883,35884,35885,35886,35887,35888,35889,35890,35891,35892,35893, +35894,35895,35896,35897,35898,35899,35900,35901,35902,35903,35904,35905, +35906,35907,35908,35909,35910,35911,35912,35913,35914,35915,35916,35917, +35918,35919,35920,35921,35922,35923,35924,35925,35926,35927,35928,35929, +35930,35931,35932,35933,35934,35935,35936,35937,35938,35939,35940,35941, +35942,35943,35944,35945,35946,35947,35948,35949,35950,35951,35952,35953, +35954,35955,35956,35957,35958,35959,35960,35961,35962,35963,35964,35965, +35966,35967,35968,35969,35970,35971,35972,35973,35974,35975,35976,35977, +35978,35979,35980,35981,35982,35983,35984,35985,35986,35987,35988,35989, +35990,35991,35992,35993,35994,35995,35996,35997,35998,35999,36000,36001, +36002,36003,36004,36005,36006,36007,36008,36009,36010,36011,36012,36013, +36014,36015,36016,36017,36018,36019,36020,36021,36022,36023,36024,36025, +36026,36027,36028,36029,36030,36031,36032,36033,36034,36035,36036,36037, +36038,36039,36040,36041,36042,36043,36044,36045,36046,36047,36048,36049, +36050,36051,36052,36053,36054,36055,36056,36057,36058,36059,36060,36061, +36062,36063,36064,36065,36066,36067,36068,36069,36070,36071,36072,36073, +36074,36075,36076,36077,36078,36079,36080,36081,36082,36083,36084,36085, +36086,36087,36088,36089,36090,36091,36092,36093,36094,36095,36096,36097, +36098,36099,36100,36101,36102,36103,36104,36105,36106,36107,36108,36109, +36110,36111,36112,36113,36114,36115,36116,36117,36118,36119,36120,36121, +36122,36123,36124,36125,36126,36127,36128,36129,36130,36131,36132,36133, +36134,36135,36136,36137,36138,36139,36140,36141,36142,36143,36144,36145, +36146,36147,36148,36149,36150,36151,36152,36153,36154,36155,36156,36157, +36158,36159,36160,36161,36162,36163,36164,36165,36166,36167,36168,36169, +36170,36171,36172,36173,36174,36175,36176,36177,36178,36179,36180,36181, +36182,36183,36184,36185,36186,36187,36188,36189,36190,36191,36192,36193, +36194,36195,36196,36197,36198,36199,36200,36201,36202,36203,36204,36205, +36206,36207,36208,36209,36210,36211,36212,36213,36214,36215,36216,36217, +36218,36219,36220,36221,36222,36223,36224,36225,36226,36227,36228,36229, +36230,36231,36232,36233,36234,36235,36236,36237,36238,36239,36240,36241, +36242,36243,36244,36245,36246,36247,36248,36249,36250,36251,36252,36253, +36254,36255,36256,36257,36258,36259,36260,36261,36262,36263,36264,36265, +36266,36267,36268,36269,36270,36271,36272,36273,36274,36275,36276,36277, +36278,36279,36280,36281,36282,36283,36284,36285,36286,36287,36288,36289, +36290,36291,36292,36293,36294,36295,36296,36297,36298,36299,36300,36301, +36302,36303,36304,36305,36306,36307,36308,36309,36310,36311,36312,36313, +36314,36315,36316,36317,36318,36319,36320,36321,36322,36323,36324,36325, +36326,36327,36328,36329,36330,36331,36332,36333,36334,36335,36336,36337, +36338,36339,36340,36341,36342,36343,36344,36345,36346,36347,36348,36349, +36350,36351,36352,36353,36354,36355,36356,36357,36358,36359,36360,36361, +36362,36363,36364,36365,36366,36367,36368,36369,36370,36371,36372,36373, +36374,36375,36376,36377,36378,36379,36380,36381,36382,36383,36384,36385, +36386,36387,36388,36389,36390,36391,36392,36393,36394,36395,36396,36397, +36398,36399,36400,36401,36402,36403,36404,36405,36406,36407,36408,36409, +36410,36411,36412,36413,36414,36415,36416,36417,36418,36419,36420,36421, +36422,36423,36424,36425,36426,36427,36428,36429,36430,36431,36432,36433, +36434,36435,36436,36437,36438,36439,36440,36441,36442,36443,36444,36445, +36446,36447,36448,36449,36450,36451,36452,36453,36454,36455,36456,36457, +36458,36459,36460,36461,36462,36463,36464,36465,36466,36467,36468,36469, +36470,36471,36472,36473,36474,36475,36476,36477,36478,36479,36480,36481, +36482,36483,36484,36485,36486,36487,36488,36489,36490,36491,36492,36493, +36494,36495,36496,36497,36498,36499,36500,36501,36502,36503,36504,36505, +36506,36507,36508,36509,36510,36511,36512,36513,36514,36515,36516,36517, +36518,36519,36520,36521,36522,36523,36524,36525,36526,36527,36528,36529, +36530,36531,36532,36533,36534,36535,36536,36537,36538,36539,36540,36541, +36542,36543,36544,36545,36546,36547,36548,36549,36550,36551,36552,36553, +36554,36555,36556,36557,36558,36559,36560,36561,36562,36563,36564,36565, +36566,36567,36568,36569,36570,36571,36572,36573,36574,36575,36576,36577, +36578,36579,36580,36581,36582,36583,36584,36585,36586,36587,36588,36589, +36590,36591,36592,36593,36594,36595,36596,36597,36598,36599,36600,36601, +36602,36603,36604,36605,36606,36607,36608,36609,36610,36611,36612,36613, +36614,36615,36616,36617,36618,36619,36620,36621,36622,36623,36624,36625, +36626,36627,36628,36629,36630,36631,36632,36633,36634,36635,36636,36637, +36638,36639,36640,36641,36642,36643,36644,36645,36646,36647,36648,36649, +36650,36651,36652,36653,36654,36655,36656,36657,36658,36659,36660,36661, +36662,36663,36664,36665,36666,36667,36668,36669,36670,36671,36672,36673, +36674,36675,36676,36677,36678,36679,36680,36681,36682,36683,36684,36685, +36686,36687,36688,36689,36690,36691,36692,36693,36694,36695,36696,36697, +36698,36699,36700,36701,36702,36703,36704,36705,36706,36707,36708,36709, +36710,36711,36712,36713,36714,36715,36716,36717,36718,36719,36720,36721, +36722,36723,36724,36725,36726,36727,36728,36729,36730,36731,36732,36733, +36734,36735,36736,36737,36738,36739,36740,36741,36742,36743,36744,36745, +36746,36747,36748,36749,36750,36751,36752,36753,36754,36755,36756,36757, +36758,36759,36760,36761,36762,36763,36764,36765,36766,36767,36768,36769, +36770,36771,36772,36773,36774,36775,36776,36777,36778,36779,36780,36781, +36782,36783,36784,36785,36786,36787,36788,36789,36790,36791,36792,36793, +36794,36795,36796,36797,36798,36799,36800,36801,36802,36803,36804,36805, +36806,36807,36808,36809,36810,36811,36812,36813,36814,36815,36816,36817, +36818,36819,36820,36821,36822,36823,36824,36825,36826,36827,36828,36829, +36830,36831,36832,36833,36834,36835,36836,36837,36838,36839,36840,36841, +36842,36843,36844,36845,36846,36847,36848,36849,36850,36851,36852,36853, +36854,36855,36856,36857,36858,36859,36860,36861,36862,36863,36864,36865, +36866,36867,36868,36869,36870,36871,36872,36873,36874,36875,36876,36877, +36878,36879,36880,36881,36882,36883,36884,36885,36886,36887,36888,36889, +36890,36891,36892,36893,36894,36895,36896,36897,36898,36899,36900,36901, +36902,36903,36904,36905,36906,36907,36908,36909,36910,36911,36912,36913, +36914,36915,36916,36917,36918,36919,36920,36921,36922,36923,36924,36925, +36926,36927,36928,36929,36930,36931,36932,36933,36934,36935,36936,36937, +36938,36939,36940,36941,36942,36943,36944,36945,36946,36947,36948,36949, +36950,36951,36952,36953,36954,36955,36956,36957,36958,36959,36960,36961, +36962,36963,36964,36965,36966,36967,36968,36969,36970,36971,36972,36973, +36974,36975,36976,36977,36978,36979,36980,36981,36982,36983,36984,36985, +36986,36987,36988,36989,36990,36991,36992,36993,36994,36995,36996,36997, +36998,36999,37000,37001,37002,37003,37004,37005,37006,37007,37008,37009, +37010,37011,37012,37013,37014,37015,37016,37017,37018,37019,37020,37021, +37022,37023,37024,37025,37026,37027,37028,37029,37030,37031,37032,37033, +37034,37035,37036,37037,37038,37039,37040,37041,37042,37043,37044,37045, +37046,37047,37048,37049,37050,37051,37052,37053,37054,37055,37056,37057, +37058,37059,37060,37061,37062,37063,37064,37065,37066,37067,37068,37069, +37070,37071,37072,37073,37074,37075,37076,37077,37078,37079,37080,37081, +37082,37083,37084,37085,37086,37087,37088,37089,37090,37091,37092,37093, +37094,37095,37096,37097,37098,37099,37100,37101,37102,37103,37104,37105, +37106,37107,37108,37109,37110,37111,37112,37113,37114,37115,37116,37117, +37118,37119,37120,37121,37122,37123,37124,37125,37126,37127,37128,37129, +37130,37131,37132,37133,37134,37135,37136,37137,37138,37139,37140,37141, +37142,37143,37144,37145,37146,37147,37148,37149,37150,37151,37152,37153, +37154,37155,37156,37157,37158,37159,37160,37161,37162,37163,37164,37165, +37166,37167,37168,37169,37170,37171,37172,37173,37174,37175,37176,37177, +37178,37179,37180,37181,37182,37183,37184,37185,37186,37187,37188,37189, +37190,37191,37192,37193,37194,37195,37196,37197,37198,37199,37200,37201, +37202,37203,37204,37205,37206,37207,37208,37209,37210,37211,37212,37213, +37214,37215,37216,37217,37218,37219,37220,37221,37222,37223,37224,37225, +37226,37227,37228,37229,37230,37231,37232,37233,37234,37235,37236,37237, +37238,37239,37240,37241,37242,37243,37244,37245,37246,37247,37248,37249, +37250,37251,37252,37253,37254,37255,37256,37257,37258,37259,37260,37261, +37262,37263,37264,37265,37266,37267,37268,37269,37270,37271,37272,37273, +37274,37275,37276,37277,37278,37279,37280,37281,37282,37283,37284,37285, +37286,37287,37288,37289,37290,37291,37292,37293,37294,37295,37296,37297, +37298,37299,37300,37301,37302,37303,37304,37305,37306,37307,37308,37309, +37310,37311,37312,37313,37314,37315,37316,37317,37318,37319,37320,37321, +37322,37323,37324,37325,37326,37327,37328,37329,37330,37331,37332,37333, +37334,37335,37336,37337,37338,37339,37340,37341,37342,37343,37344,37345, +37346,37347,37348,37349,37350,37351,37352,37353,37354,37355,37356,37357, +37358,37359,37360,37361,37362,37363,37364,37365,37366,37367,37368,37369, +37370,37371,37372,37373,37374,37375,37376,37377,37378,37379,37380,37381, +37382,37383,37384,37385,37386,37387,37388,37389,37390,37391,37392,37393, +37394,37395,37396,37397,37398,37399,37400,37401,37402,37403,37404,37405, +37406,37407,37408,37409,37410,37411,37412,37413,37414,37415,37416,37417, +37418,37419,37420,37421,37422,37423,37424,37425,37426,37427,37428,37429, +37430,37431,37432,37433,37434,37435,37436,37437,37438,37439,37440,37441, +37442,37443,37444,37445,37446,37447,37448,37449,37450,37451,37452,37453, +37454,37455,37456,37457,37458,37459,37460,37461,37462,37463,37464,37465, +37466,37467,37468,37469,37470,37471,37472,37473,37474,37475,37476,37477, +37478,37479,37480,37481,37482,37483,37484,37485,37486,37487,37488,37489, +37490,37491,37492,37493,37494,37495,37496,37497,37498,37499,37500,37501, +37502,37503,37504,37505,37506,37507,37508,37509,37510,37511,37512,37513, +37514,37515,37516,37517,37518,37519,37520,37521,37522,37523,37524,37525, +37526,37527,37528,37529,37530,37531,37532,37533,37534,37535,37536,37537, +37538,37539,37540,37541,37542,37543,37544,37545,37546,37547,37548,37549, +37550,37551,37552,37553,37554,37555,37556,37557,37558,37559,37560,37561, +37562,37563,37564,37565,37566,37567,37568,37569,37570,37571,37572,37573, +37574,37575,37576,37577,37578,37579,37580,37581,37582,37583,37584,37585, +37586,37587,37588,37589,37590,37591,37592,37593,37594,37595,37596,37597, +37598,37599,37600,37601,37602,37603,37604,37605,37606,37607,37608,37609, +37610,37611,37612,37613,37614,37615,37616,37617,37618,37619,37620,37621, +37622,37623,37624,37625,37626,37627,37628,37629,37630,37631,37632,37633, +37634,37635,37636,37637,37638,37639,37640,37641,37642,37643,37644,37645, +37646,37647,37648,37649,37650,37651,37652,37653,37654,37655,37656,37657, +37658,37659,37660,37661,37662,37663,37664,37665,37666,37667,37668,37669, +37670,37671,37672,37673,37674,37675,37676,37677,37678,37679,37680,37681, +37682,37683,37684,37685,37686,37687,37688,37689,37690,37691,37692,37693, +37694,37695,37696,37697,37698,37699,37700,37701,37702,37703,37704,37705, +37706,37707,37708,37709,37710,37711,37712,37713,37714,37715,37716,37717, +37718,37719,37720,37721,37722,37723,37724,37725,37726,37727,37728,37729, +37730,37731,37732,37733,37734,37735,37736,37737,37738,37739,37740,37741, +37742,37743,37744,37745,37746,37747,37748,37749,37750,37751,37752,37753, +37754,37755,37756,37757,37758,37759,37760,37761,37762,37763,37764,37765, +37766,37767,37768,37769,37770,37771,37772,37773,37774,37775,37776,37777, +37778,37779,37780,37781,37782,37783,37784,37785,37786,37787,37788,37789, +37790,37791,37792,37793,37794,37795,37796,37797,37798,37799,37800,37801, +37802,37803,37804,37805,37806,37807,37808,37809,37810,37811,37812,37813, +37814,37815,37816,37817,37818,37819,37820,37821,37822,37823,37824,37825, +37826,37827,37828,37829,37830,37831,37832,37833,37834,37835,37836,37837, +37838,37839,37840,37841,37842,37843,37844,37845,37846,37847,37848,37849, +37850,37851,37852,37853,37854,37855,37856,37857,37858,37859,37860,37861, +37862,37863,37864,37865,37866,37867,37868,37869,37870,37871,37872,37873, +37874,37875,37876,37877,37878,37879,37880,37881,37882,37883,37884,37885, +37886,37887,37888,37889,37890,37891,37892,37893,37894,37895,37896,37897, +37898,37899,37900,37901,37902,37903,37904,37905,37906,37907,37908,37909, +37910,37911,37912,37913,37914,37915,37916,37917,37918,37919,37920,37921, +37922,37923,37924,37925,37926,37927,37928,37929,37930,37931,37932,37933, +37934,37935,37936,37937,37938,37939,37940,37941,37942,37943,37944,37945, +37946,37947,37948,37949,37950,37951,37952,37953,37954,37955,37956,37957, +37958,37959,37960,37961,37962,37963,37964,37965,37966,37967,37968,37969, +37970,37971,37972,37973,37974,37975,37976,37977,37978,37979,37980,37981, +37982,37983,37984,37985,37986,37987,37988,37989,37990,37991,37992,37993, +37994,37995,37996,37997,37998,37999,38000,38001,38002,38003,38004,38005, +38006,38007,38008,38009,38010,38011,38012,38013,38014,38015,38016,38017, +38018,38019,38020,38021,38022,38023,38024,38025,38026,38027,38028,38029, +38030,38031,38032,38033,38034,38035,38036,38037,38038,38039,38040,38041, +38042,38043,38044,38045,38046,38047,38048,38049,38050,38051,38052,38053, +38054,38055,38056,38057,38058,38059,38060,38061,38062,38063,38064,38065, +38066,38067,38068,38069,38070,38071,38072,38073,38074,38075,38076,38077, +38078,38079,38080,38081,38082,38083,38084,38085,38086,38087,38088,38089, +38090,38091,38092,38093,38094,38095,38096,38097,38098,38099,38100,38101, +38102,38103,38104,38105,38106,38107,38108,38109,38110,38111,38112,38113, +38114,38115,38116,38117,38118,38119,38120,38121,38122,38123,38124,38125, +38126,38127,38128,38129,38130,38131,38132,38133,38134,38135,38136,38137, +38138,38139,38140,38141,38142,38143,38144,38145,38146,38147,38148,38149, +38150,38151,38152,38153,38154,38155,38156,38157,38158,38159,38160,38161, +38162,38163,38164,38165,38166,38167,38168,38169,38170,38171,38172,38173, +38174,38175,38176,38177,38178,38179,38180,38181,38182,38183,38184,38185, +38186,38187,38188,38189,38190,38191,38192,38193,38194,38195,38196,38197, +38198,38199,38200,38201,38202,38203,38204,38205,38206,38207,38208,38209, +38210,38211,38212,38213,38214,38215,38216,38217,38218,38219,38220,38221, +38222,38223,38224,38225,38226,38227,38228,38229,38230,38231,38232,38233, +38234,38235,38236,38237,38238,38239,38240,38241,38242,38243,38244,38245, +38246,38247,38248,38249,38250,38251,38252,38253,38254,38255,38256,38257, +38258,38259,38260,38261,38262,38263,38264,38265,38266,38267,38268,38269, +38270,38271,38272,38273,38274,38275,38276,38277,38278,38279,38280,38281, +38282,38283,38284,38285,38286,38287,38288,38289,38290,38291,38292,38293, +38294,38295,38296,38297,38298,38299,38300,38301,38302,38303,38304,38305, +38306,38307,38308,38309,38310,38311,38312,38313,38314,38315,38316,38317, +38318,38319,38320,38321,38322,38323,38324,38325,38326,38327,38328,38329, +38330,38331,38332,38333,38334,38335,38336,38337,38338,38339,38340,38341, +38342,38343,38344,38345,38346,38347,38348,38349,38350,38351,38352,38353, +38354,38355,38356,38357,38358,38359,38360,38361,38362,38363,38364,38365, +38366,38367,38368,38369,38370,38371,38372,38373,38374,38375,38376,38377, +38378,38379,38380,38381,38382,38383,38384,38385,38386,38387,38388,38389, +38390,38391,38392,38393,38394,38395,38396,38397,38398,38399,38400,38401, +38402,38403,38404,38405,38406,38407,38408,38409,38410,38411,38412,38413, +38414,38415,38416,38417,38418,38419,38420,38421,38422,38423,38424,38425, +38426,38427,38428,38429,38430,38431,38432,38433,38434,38435,38436,38437, +38438,38439,38440,38441,38442,38443,38444,38445,38446,38447,38448,38449, +38450,38451,38452,38453,38454,38455,38456,38457,38458,38459,38460,38461, +38462,38463,38464,38465,38466,38467,38468,38469,38470,38471,38472,38473, +38474,38475,38476,38477,38478,38479,38480,38481,38482,38483,38484,38485, +38486,38487,38488,38489,38490,38491,38492,38493,38494,38495,38496,38497, +38498,38499,38500,38501,38502,38503,38504,38505,38506,38507,38508,38509, +38510,38511,38512,38513,38514,38515,38516,38517,38518,38519,38520,38521, +38522,38523,38524,38525,38526,38527,38528,38529,38530,38531,38532,38533, +38534,38535,38536,38537,38538,38539,38540,38541,38542,38543,38544,38545, +38546,38547,38548,38549,38550,38551,38552,38553,38554,38555,38556,38557, +38558,38559,38560,38561,38562,38563,38564,38565,38566,38567,38568,38569, +38570,38571,38572,38573,38574,38575,38576,38577,38578,38579,38580,38581, +38582,38583,38584,38585,38586,38587,38588,38589,38590,38591,38592,38593, +38594,38595,38596,38597,38598,38599,38600,38601,38602,38603,38604,38605, +38606,38607,38608,38609,38610,38611,38612,38613,38614,38615,38616,38617, +38618,38619,38620,38621,38622,38623,38624,38625,38626,38627,38628,38629, +38630,38631,38632,38633,38634,38635,38636,38637,38638,38639,38640,38641, +38642,38643,38644,38645,38646,38647,38648,38649,38650,38651,38652,38653, +38654,38655,38656,38657,38658,38659,38660,38661,38662,38663,38664,38665, +38666,38667,38668,38669,38670,38671,38672,38673,38674,38675,38676,38677, +38678,38679,38680,38681,38682,38683,38684,38685,38686,38687,38688,38689, +38690,38691,38692,38693,38694,38695,38696,38697,38698,38699,38700,38701, +38702,38703,38704,38705,38706,38707,38708,38709,38710,38711,38712,38713, +38714,38715,38716,38717,38718,38719,38720,38721,38722,38723,38724,38725, +38726,38727,38728,38729,38730,38731,38732,38733,38734,38735,38736,38737, +38738,38739,38740,38741,38742,38743,38744,38745,38746,38747,38748,38749, +38750,38751,38752,38753,38754,38755,38756,38757,38758,38759,38760,38761, +38762,38763,38764,38765,38766,38767,38768,38769,38770,38771,38772,38773, +38774,38775,38776,38777,38778,38779,38780,38781,38782,38783,38784,38785, +38786,38787,38788,38789,38790,38791,38792,38793,38794,38795,38796,38797, +38798,38799,38800,38801,38802,38803,38804,38805,38806,38807,38808,38809, +38810,38811,38812,38813,38814,38815,38816,38817,38818,38819,38820,38821, +38822,38823,38824,38825,38826,38827,38828,38829,38830,38831,38832,38833, +38834,38835,38836,38837,38838,38839,38840,38841,38842,38843,38844,38845, +38846,38847,38848,38849,38850,38851,38852,38853,38854,38855,38856,38857, +38858,38859,38860,38861,38862,38863,38864,38865,38866,38867,38868,38869, +38870,38871,38872,38873,38874,38875,38876,38877,38878,38879,38880,38881, +38882,38883,38884,38885,38886,38887,38888,38889,38890,38891,38892,38893, +38894,38895,38896,38897,38898,38899,38900,38901,38902,38903,38904,38905, +38906,38907,38908,38909,38910,38911,38912,38913,38914,38915,38916,38917, +38918,38919,38920,38921,38922,38923,38924,38925,38926,38927,38928,38929, +38930,38931,38932,38933,38934,38935,38936,38937,38938,38939,38940,38941, +38942,38943,38944,38945,38946,38947,38948,38949,38950,38951,38952,38953, +38954,38955,38956,38957,38958,38959,38960,38961,38962,38963,38964,38965, +38966,38967,38968,38969,38970,38971,38972,38973,38974,38975,38976,38977, +38978,38979,38980,38981,38982,38983,38984,38985,38986,38987,38988,38989, +38990,38991,38992,38993,38994,38995,38996,38997,38998,38999,39000,39001, +39002,39003,39004,39005,39006,39007,39008,39009,39010,39011,39012,39013, +39014,39015,39016,39017,39018,39019,39020,39021,39022,39023,39024,39025, +39026,39027,39028,39029,39030,39031,39032,39033,39034,39035,39036,39037, +39038,39039,39040,39041,39042,39043,39044,39045,39046,39047,39048,39049, +39050,39051,39052,39053,39054,39055,39056,39057,39058,39059,39060,39061, +39062,39063,39064,39065,39066,39067,39068,39069,39070,39071,39072,39073, +39074,39075,39076,39077,39078,39079,39080,39081,39082,39083,39084,39085, +39086,39087,39088,39089,39090,39091,39092,39093,39094,39095,39096,39097, +39098,39099,39100,39101,39102,39103,39104,39105,39106,39107,39108,39109, +39110,39111,39112,39113,39114,39115,39116,39117,39118,39119,39120,39121, +39122,39123,39124,39125,39126,39127,39128,39129,39130,39131,39132,39133, +39134,39135,39136,39137,39138,39139,39140,39141,39142,39143,39144,39145, +39146,39147,39148,39149,39150,39151,39152,39153,39154,39155,39156,39157, +39158,39159,39160,39161,39162,39163,39164,39165,39166,39167,39168,39169, +39170,39171,39172,39173,39174,39175,39176,39177,39178,39179,39180,39181, +39182,39183,39184,39185,39186,39187,39188,39189,39190,39191,39192,39193, +39194,39195,39196,39197,39198,39199,39200,39201,39202,39203,39204,39205, +39206,39207,39208,39209,39210,39211,39212,39213,39214,39215,39216,39217, +39218,39219,39220,39221,39222,39223,39224,39225,39226,39227,39228,39229, +39230,39231,39232,39233,39234,39235,39236,39237,39238,39239,39240,39241, +39242,39243,39244,39245,39246,39247,39248,39249,39250,39251,39252,39253, +39254,39255,39256,39257,39258,39259,39260,39261,39262,39263,39264,39265, +39266,39267,39268,39269,39270,39271,39272,39273,39274,39275,39276,39277, +39278,39279,39280,39281,39282,39283,39284,39285,39286,39287,39288,39289, +39290,39291,39292,39293,39294,39295,39296,39297,39298,39299,39300,39301, +39302,39303,39304,39305,39306,39307,39308,39309,39310,39311,39312,39313, +39314,39315,39316,39317,39318,39319,39320,39321,39322,39323,39324,39325, +39326,39327,39328,39329,39330,39331,39332,39333,39334,39335,39336,39337, +39338,39339,39340,39341,39342,39343,39344,39345,39346,39347,39348,39349, +39350,39351,39352,39353,39354,39355,39356,39357,39358,39359,39360,39361, +39362,39363,39364,39365,39366,39367,39368,39369,39370,39371,39372,39373, +39374,39375,39376,39377,39378,39379,39380,39381,39382,39383,39384,39385, +39386,39387,39388,39389,39390,39391,39392,39393,39394,39395,39396,39397, +39398,39399,39400,39401,39402,39403,39404,39405,39406,39407,39408,39409, +39410,39411,39412,39413,39414,39415,39416,39417,39418,39419,39420,39421, +39422,39423,39424,39425,39426,39427,39428,39429,39430,39431,39432,39433, +39434,39435,39436,39437,39438,39439,39440,39441,39442,39443,39444,39445, +39446,39447,39448,39449,39450,39451,39452,39453,39454,39455,39456,39457, +39458,39459,39460,39461,39462,39463,39464,39465,39466,39467,39468,39469, +39470,39471,39472,39473,39474,39475,39476,39477,39478,39479,39480,39481, +39482,39483,39484,39485,39486,39487,39488,39489,39490,39491,39492,39493, +39494,39495,39496,39497,39498,39499,39500,39501,39502,39503,39504,39505, +39506,39507,39508,39509,39510,39511,39512,39513,39514,39515,39516,39517, +39518,39519,39520,39521,39522,39523,39524,39525,39526,39527,39528,39529, +39530,39531,39532,39533,39534,39535,39536,39537,39538,39539,39540,39541, +39542,39543,39544,39545,39546,39547,39548,39549,39550,39551,39552,39553, +39554,39555,39556,39557,39558,39559,39560,39561,39562,39563,39564,39565, +39566,39567,39568,39569,39570,39571,39572,39573,39574,39575,39576,39577, +39578,39579,39580,39581,39582,39583,39584,39585,39586,39587,39588,39589, +39590,39591,39592,39593,39594,39595,39596,39597,39598,39599,39600,39601, +39602,39603,39604,39605,39606,39607,39608,39609,39610,39611,39612,39613, +39614,39615,39616,39617,39618,39619,39620,39621,39622,39623,39624,39625, +39626,39627,39628,39629,39630,39631,39632,39633,39634,39635,39636,39637, +39638,39639,39640,39641,39642,39643,39644,39645,39646,39647,39648,39649, +39650,39651,39652,39653,39654,39655,39656,39657,39658,39659,39660,39661, +39662,39663,39664,39665,39666,39667,39668,39669,39670,39671,39672,39673, +39674,39675,39676,39677,39678,39679,39680,39681,39682,39683,39684,39685, +39686,39687,39688,39689,39690,39691,39692,39693,39694,39695,39696,39697, +39698,39699,39700,39701,39702,39703,39704,39705,39706,39707,39708,39709, +39710,39711,39712,39713,39714,39715,39716,39717,39718,39719,39720,39721, +39722,39723,39724,39725,39726,39727,39728,39729,39730,39731,39732,39733, +39734,39735,39736,39737,39738,39739,39740,39741,39742,39743,39744,39745, +39746,39747,39748,39749,39750,39751,39752,39753,39754,39755,39756,39757, +39758,39759,39760,39761,39762,39763,39764,39765,39766,39767,39768,39769, +39770,39771,39772,39773,39774,39775,39776,39777,39778,39779,39780,39781, +39782,39783,39784,39785,39786,39787,39788,39789,39790,39791,39792,39793, +39794,39795,39796,39797,39798,39799,39800,39801,39802,39803,39804,39805, +39806,39807,39808,39809,39810,39811,39812,39813,39814,39815,39816,39817, +39818,39819,39820,39821,39822,39823,39824,39825,39826,39827,39828,39829, +39830,39831,39832,39833,39834,39835,39836,39837,39838,39839,39840,39841, +39842,39843,39844,39845,39846,39847,39848,39849,39850,39851,39852,39853, +39854,39855,39856,39857,39858,39859,39860,39861,39862,39863,39864,39865, +39866,39867,39868,39869,39870,39871,39872,39873,39874,39875,39876,39877, +39878,39879,39880,39881,39882,39883,39884,39885,39886,39887,39888,39889, +39890,39891,39892,39893,39894,39895,39896,39897,39898,39899,39900,39901, +39902,39903,39904,39905,39906,39907,39908,39909,39910,39911,39912,39913, +39914,39915,39916,39917,39918,39919,39920,39921,39922,39923,39924,39925, +39926,39927,39928,39929,39930,39931,39932,39933,39934,39935,39936,39937, +39938,39939,39940,39941,39942,39943,39944,39945,39946,39947,39948,39949, +39950,39951,39952,39953,39954,39955,39956,39957,39958,39959,39960,39961, +39962,39963,39964,39965,39966,39967,39968,39969,39970,39971,39972,39973, +39974,39975,39976,39977,39978,39979,39980,39981,39982,39983,39984,39985, +39986,39987,39988,39989,39990,39991,39992,39993,39994,39995,39996,39997, +39998,39999,40000,40001,40002,40003,40004,40005,40006,40007,40008,40009, +40010,40011,40012,40013,40014,40015,40016,40017,40018,40019,40020,40021, +40022,40023,40024,40025,40026,40027,40028,40029,40030,40031,40032,40033, +40034,40035,40036,40037,40038,40039,40040,40041,40042,40043,40044,40045, +40046,40047,40048,40049,40050,40051,40052,40053,40054,40055,40056,40057, +40058,40059,40060,40061,40062,40063,40064,40065,40066,40067,40068,40069, +40070,40071,40072,40073,40074,40075,40076,40077,40078,40079,40080,40081, +40082,40083,40084,40085,40086,40087,40088,40089,40090,40091,40092,40093, +40094,40095,40096,40097,40098,40099,40100,40101,40102,40103,40104,40105, +40106,40107,40108,40109,40110,40111,40112,40113,40114,40115,40116,40117, +40118,40119,40120,40121,40122,40123,40124,40125,40126,40127,40128,40129, +40130,40131,40132,40133,40134,40135,40136,40137,40138,40139,40140,40141, +40142,40143,40144,40145,40146,40147,40148,40149,40150,40151,40152,40153, +40154,40155,40156,40157,40158,40159,40160,40161,40162,40163,40164,40165, +40166,40167,40168,40169,40170,40171,40172,40173,40174,40175,40176,40177, +40178,40179,40180,40181,40182,40183,40184,40185,40186,40187,40188,40189, +40190,40191,40192,40193,40194,40195,40196,40197,40198,40199,40200,40201, +40202,40203,40204,40205,40206,40207,40208,40209,40210,40211,40212,40213, +40214,40215,40216,40217,40218,40219,40220,40221,40222,40223,40224,40225, +40226,40227,40228,40229,40230,40231,40232,40233,40234,40235,40236,40237, +40238,40239,40240,40241,40242,40243,40244,40245,40246,40247,40248,40249, +40250,40251,40252,40253,40254,40255,40256,40257,40258,40259,40260,40261, +40262,40263,40264,40265,40266,40267,40268,40269,40270,40271,40272,40273, +40274,40275,40276,40277,40278,40279,40280,40281,40282,40283,40284,40285, +40286,40287,40288,40289,40290,40291,40292,40293,40294,40295,40296,40297, +40298,40299,40300,40301,40302,40303,40304,40305,40306,40307,40308,40309, +40310,40311,40312,40313,40314,40315,40316,40317,40318,40319,40320,40321, +40322,40323,40324,40325,40326,40327,40328,40329,40330,40331,40332,40333, +40334,40335,40336,40337,40338,40339,40340,40341,40342,40343,40344,40345, +40346,40347,40348,40349,40350,40351,40352,40353,40354,40355,40356,40357, +40358,40359,40360,40361,40362,40363,40364,40365,40366,40367,40368,40369, +40370,40371,40372,40373,40374,40375,40376,40377,40378,40379,40380,40381, +40382,40383,40384,40385,40386,40387,40388,40389,40390,40391,40392,40393, +40394,40395,40396,40397,40398,40399,40400,40401,40402,40403,40404,40405, +40406,40407,40408,40409,40410,40411,40412,40413,40414,40415,40416,40417, +40418,40419,40420,40421,40422,40423,40424,40425,40426,40427,40428,40429, +40430,40431,40432,40433,40434,40435,40436,40437,40438,40439,40440,40441, +40442,40443,40444,40445,40446,40447,40448,40449,40450,40451,40452,40453, +40454,40455,40456,40457,40458,40459,40460,40461,40462,40463,40464,40465, +40466,40467,40468,40469,40470,40471,40472,40473,40474,40475,40476,40477, +40478,40479,40480,40481,40482,40483,40484,40485,40486,40487,40488,40489, +40490,40491,40492,40493,40494,40495,40496,40497,40498,40499,40500,40501, +40502,40503,40504,40505,40506,40507,40508,40509,40510,40511,40512,40513, +40514,40515,40516,40517,40518,40519,40520,40521,40522,40523,40524,40525, +40526,40527,40528,40529,40530,40531,40532,40533,40534,40535,40536,40537, +40538,40539,40540,40541,40542,40543,40544,40545,40546,40547,40548,40549, +40550,40551,40552,40553,40554,40555,40556,40557,40558,40559,40560,40561, +40562,40563,40564,40565,40566,40567,40568,40569,40570,40571,40572,40573, +40574,40575,40576,40577,40578,40579,40580,40581,40582,40583,40584,40585, +40586,40587,40588,40589,40590,40591,40592,40593,40594,40595,40596,40597, +40598,40599,40600,40601,40602,40603,40604,40605,40606,40607,40608,40609, +40610,40611,40612,40613,40614,40615,40616,40617,40618,40619,40620,40621, +40622,40623,40624,40625,40626,40627,40628,40629,40630,40631,40632,40633, +40634,40635,40636,40637,40638,40639,40640,40641,40642,40643,40644,40645, +40646,40647,40648,40649,40650,40651,40652,40653,40654,40655,40656,40657, +40658,40659,40660,40661,40662,40663,40664,40665,40666,40667,40668,40669, +40670,40671,40672,40673,40674,40675,40676,40677,40678,40679,40680,40681, +40682,40683,40684,40685,40686,40687,40688,40689,40690,40691,40692,40693, +40694,40695,40696,40697,40698,40699,40700,40701,40702,40703,40704,40705, +40706,40707,40708,40709,40710,40711,40712,40713,40714,40715,40716,40717, +40718,40719,40720,40721,40722,40723,40724,40725,40726,40727,40728,40729, +40730,40731,40732,40733,40734,40735,40736,40737,40738,40739,40740,40741, +40742,40743,40744,40745,40746,40747,40748,40749,40750,40751,40752,40753, +40754,40755,40756,40757,40758,40759,40760,40761,40762,40763,40764,40765, +40766,40767,40768,40769,40770,40771,40772,40773,40774,40775,40776,40777, +40778,40779,40780,40781,40782,40783,40784,40785,40786,40787,40788,40789, +40790,40791,40792,40793,40794,40795,40796,40797,40798,40799,40800,40801, +40802,40803,40804,40805,40806,40807,40808,40809,40810,40811,40812,40813, +40814,40815,40816,40817,40818,40819,40820,40821,40822,40823,40824,40825, +40826,40827,40828,40829,40830,40831,40832,40833,40834,40835,40836,40837, +40838,40839,40840,40841,40842,40843,40844,40845,40846,40847,40848,40849, +40850,40851,40852,40853,40854,40855,40856,40857,40858,40859,40860,40861, +40862,40863,40864,40865,40866,40867,40868,40869,40870,40871,40872,40873, +40874,40875,40876,40877,40878,40879,40880,40881,40882,40883,40884,40885, +40886,40887,40888,40889,40890,40891,40892,40893,40894,40895,40896,40897, +40898,40899,40900,40901,40902,40903,40904,40905,40906,40907,40908,40909, +40910,40911,40912,40913,40914,40915,40916,40917,40918,40919,40920,40921, +40922,40923,40924,40925,40926,40927,40928,40929,40930,40931,40932,40933, +40934,40935,40936,40937,40938,40939,40940,40941,40942,40943,40944,40945, +40946,40947,40948,40949,40950,40951,40952,40953,40954,40955,40956,40957, +40958,40959,40960,40961,40962,40963,40964,40965,40966,40967,40968,40969, +40970,40971,40972,40973,40974,40975,40976,40977,40978,40979,40980,40981, +40982,40983,40984,40985,40986,40987,40988,40989,40990,40991,40992,40993, +40994,40995,40996,40997,40998,40999,41000,41001,41002,41003,41004,41005, +41006,41007,41008,41009,41010,41011,41012,41013,41014,41015,41016,41017, +41018,41019,41020,41021,41022,41023,41024,41025,41026,41027,41028,41029, +41030,41031,41032,41033,41034,41035,41036,41037,41038,41039,41040,41041, +41042,41043,41044,41045,41046,41047,41048,41049,41050,41051,41052,41053, +41054,41055,41056,41057,41058,41059,41060,41061,41062,41063,41064,41065, +41066,41067,41068,41069,41070,41071,41072,41073,41074,41075,41076,41077, +41078,41079,41080,41081,41082,41083,41084,41085,41086,41087,41088,41089, +41090,41091,41092,41093,41094,41095,41096,41097,41098,41099,41100,41101, +41102,41103,41104,41105,41106,41107,41108,41109,41110,41111,41112,41113, +41114,41115,41116,41117,41118,41119,41120,41121,41122,41123,41124,41125, +41126,41127,41128,41129,41130,41131,41132,41133,41134,41135,41136,41137, +41138,41139,41140,41141,41142,41143,41144,41145,41146,41147,41148,41149, +41150,41151,41152,41153,41154,41155,41156,41157,41158,41159,41160,41161, +41162,41163,41164,41165,41166,41167,41168,41169,41170,41171,41172,41173, +41174,41175,41176,41177,41178,41179,41180,41181,41182,41183,41184,41185, +41186,41187,41188,41189,41190,41191,41192,41193,41194,41195,41196,41197, +41198,41199,41200,41201,41202,41203,41204,41205,41206,41207,41208,41209, +41210,41211,41212,41213,41214,41215,41216,41217,41218,41219,41220,41221, +41222,41223,41224,41225,41226,41227,41228,41229,41230,41231,41232,41233, +41234,41235,41236,41237,41238,41239,41240,41241,41242,41243,41244,41245, +41246,41247,41248,41249,41250,41251,41252,41253,41254,41255,41256,41257, +41258,41259,41260,41261,41262,41263,41264,41265,41266,41267,41268,41269, +41270,41271,41272,41273,41274,41275,41276,41277,41278,41279,41280,41281, +41282,41283,41284,41285,41286,41287,41288,41289,41290,41291,41292,41293, +41294,41295,41296,41297,41298,41299,41300,41301,41302,41303,41304,41305, +41306,41307,41308,41309,41310,41311,41312,41313,41314,41315,41316,41317, +41318,41319,41320,41321,41322,41323,41324,41325,41326,41327,41328,41329, +41330,41331,41332,41333,41334,41335,41336,41337,41338,41339,41340,41341, +41342,41343,41344,41345,41346,41347,41348,41349,41350,41351,41352,41353, +41354,41355,41356,41357,41358,41359,41360,41361,41362,41363,41364,41365, +41366,41367,41368,41369,41370,41371,41372,41373,41374,41375,41376,41377, +41378,41379,41380,41381,41382,41383,41384,41385,41386,41387,41388,41389, +41390,41391,41392,41393,41394,41395,41396,41397,41398,41399,41400,41401, +41402,41403,41404,41405,41406,41407,41408,41409,41410,41411,41412,41413, +41414,41415,41416,41417,41418,41419,41420,41421,41422,41423,41424,41425, +41426,41427,41428,41429,41430,41431,41432,41433,41434,41435,41436,41437, +41438,41439,41440,41441,41442,41443,41444,41445,41446,41447,41448,41449, +41450,41451,41452,41453,41454,41455,41456,41457,41458,41459,41460,41461, +41462,41463,41464,41465,41466,41467,41468,41469,41470,41471,41472,41473, +41474,41475,41476,41477,41478,41479,41480,41481,41482,41483,41484,41485, +41486,41487,41488,41489,41490,41491,41492,41493,41494,41495,41496,41497, +41498,41499,41500,41501,41502,41503,41504,41505,41506,41507,41508,41509, +41510,41511,41512,41513,41514,41515,41516,41517,41518,41519,41520,41521, +41522,41523,41524,41525,41526,41527,41528,41529,41530,41531,41532,41533, +41534,41535,41536,41537,41538,41539,41540,41541,41542,41543,41544,41545, +41546,41547,41548,41549,41550,41551,41552,41553,41554,41555,41556,41557, +41558,41559,41560,41561,41562,41563,41564,41565,41566,41567,41568,41569, +41570,41571,41572,41573,41574,41575,41576,41577,41578,41579,41580,41581, +41582,41583,41584,41585,41586,41587,41588,41589,41590,41591,41592,41593, +41594,41595,41596,41597,41598,41599,41600,41601,41602,41603,41604,41605, +41606,41607,41608,41609,41610,41611,41612,41613,41614,41615,41616,41617, +41618,41619,41620,41621,41622,41623,41624,41625,41626,41627,41628,41629, +41630,41631,41632,41633,41634,41635,41636,41637,41638,41639,41640,41641, +41642,41643,41644,41645,41646,41647,41648,41649,41650,41651,41652,41653, +41654,41655,41656,41657,41658,41659,41660,41661,41662,41663,41664,41665, +41666,41667,41668,41669,41670,41671,41672,41673,41674,41675,41676,41677, +41678,41679,41680,41681,41682,41683,41684,41685,41686,41687,41688,41689, +41690,41691,41692,41693,41694,41695,41696,41697,41698,41699,41700,41701, +41702,41703,41704,41705,41706,41707,41708,41709,41710,41711,41712,41713, +41714,41715,41716,41717,41718,41719,41720,41721,41722,41723,41724,41725, +41726,41727,41728,41729,41730,41731,41732,41733,41734,41735,41736,41737, +41738,41739,41740,41741,41742,41743,41744,41745,41746,41747,41748,41749, +41750,41751,41752,41753,41754,41755,41756,41757,41758,41759,41760,41761, +41762,41763,41764,41765,41766,41767,41768,41769,41770,41771,41772,41773, +41774,41775,41776,41777,41778,41779,41780,41781,41782,41783,41784,41785, +41786,41787,41788,41789,41790,41791,41792,41793,41794,41795,41796,41797, +41798,41799,41800,41801,41802,41803,41804,41805,41806,41807,41808,41809, +41810,41811,41812,41813,41814,41815,41816,41817,41818,41819,41820,41821, +41822,41823,41824,41825,41826,41827,41828,41829,41830,41831,41832,41833, +41834,41835,41836,41837,41838,41839,41840,41841,41842,41843,41844,41845, +41846,41847,41848,41849,41850,41851,41852,41853,41854,41855,41856,41857, +41858,41859,41860,41861,41862,41863,41864,41865,41866,41867,41868,41869, +41870,41871,41872,41873,41874,41875,41876,41877,41878,41879,41880,41881, +41882,41883,41884,41885,41886,41887,41888,41889,41890,41891,41892,41893, +41894,41895,41896,41897,41898,41899,41900,41901,41902,41903,41904,41905, +41906,41907,41908,41909,41910,41911,41912,41913,41914,41915,41916,41917, +41918,41919,41920,41921,41922,41923,41924,41925,41926,41927,41928,41929, +41930,41931,41932,41933,41934,41935,41936,41937,41938,41939,41940,41941, +41942,41943,41944,41945,41946,41947,41948,41949,41950,41951,41952,41953, +41954,41955,41956,41957,41958,41959,41960,41961,41962,41963,41964,41965, +41966,41967,41968,41969,41970,41971,41972,41973,41974,41975,41976,41977, +41978,41979,41980,41981,41982,41983,41984,41985,41986,41987,41988,41989, +41990,41991,41992,41993,41994,41995,41996,41997,41998,41999,42000,42001, +42002,42003,42004,42005,42006,42007,42008,42009,42010,42011,42012,42013, +42014,42015,42016,42017,42018,42019,42020,42021,42022,42023,42024,42025, +42026,42027,42028,42029,42030,42031,42032,42033,42034,42035,42036,42037, +42038,42039,42040,42041,42042,42043,42044,42045,42046,42047,42048,42049, +42050,42051,42052,42053,42054,42055,42056,42057,42058,42059,42060,42061, +42062,42063,42064,42065,42066,42067,42068,42069,42070,42071,42072,42073, +42074,42075,42076,42077,42078,42079,42080,42081,42082,42083,42084,42085, +42086,42087,42088,42089,42090,42091,42092,42093,42094,42095,42096,42097, +42098,42099,42100,42101,42102,42103,42104,42105,42106,42107,42108,42109, +42110,42111,42112,42113,42114,42115,42116,42117,42118,42119,42120,42121, +42122,42123,42124,42125,42126,42127,42128,42129,42130,42131,42132,42133, +42134,42135,42136,42137,42138,42139,42140,42141,42142,42143,42144,42145, +42146,42147,42148,42149,42150,42151,42152,42153,42154,42155,42156,42157, +42158,42159,42160,42161,42162,42163,42164,42165,42166,42167,42168,42169, +42170,42171,42172,42173,42174,42175,42176,42177,42178,42179,42180,42181, +42182,42183,42184,42185,42186,42187,42188,42189,42190,42191,42192,42193, +42194,42195,42196,42197,42198,42199,42200,42201,42202,42203,42204,42205, +42206,42207,42208,42209,42210,42211,42212,42213,42214,42215,42216,42217, +42218,42219,42220,42221,42222,42223,42224,42225,42226,42227,42228,42229, +42230,42231,42232,42233,42234,42235,42236,42237,42238,42239,42240,42241, +42242,42243,42244,42245,42246,42247,42248,42249,42250,42251,42252,42253, +42254,42255,42256,42257,42258,42259,42260,42261,42262,42263,42264,42265, +42266,42267,42268,42269,42270,42271,42272,42273,42274,42275,42276,42277, +42278,42279,42280,42281,42282,42283,42284,42285,42286,42287,42288,42289, +42290,42291,42292,42293,42294,42295,42296,42297,42298,42299,42300,42301, +42302,42303,42304,42305,42306,42307,42308,42309,42310,42311,42312,42313, +42314,42315,42316,42317,42318,42319,42320,42321,42322,42323,42324,42325, +42326,42327,42328,42329,42330,42331,42332,42333,42334,42335,42336,42337, +42338,42339,42340,42341,42342,42343,42344,42345,42346,42347,42348,42349, +42350,42351,42352,42353,42354,42355,42356,42357,42358,42359,42360,42361, +42362,42363,42364,42365,42366,42367,42368,42369,42370,42371,42372,42373, +42374,42375,42376,42377,42378,42379,42380,42381,42382,42383,42384,42385, +42386,42387,42388,42389,42390,42391,42392,42393,42394,42395,42396,42397, +42398,42399,42400,42401,42402,42403,42404,42405,42406,42407,42408,42409, +42410,42411,42412,42413,42414,42415,42416,42417,42418,42419,42420,42421, +42422,42423,42424,42425,42426,42427,42428,42429,42430,42431,42432,42433, +42434,42435,42436,42437,42438,42439,42440,42441,42442,42443,42444,42445, +42446,42447,42448,42449,42450,42451,42452,42453,42454,42455,42456,42457, +42458,42459,42460,42461,42462,42463,42464,42465,42466,42467,42468,42469, +42470,42471,42472,42473,42474,42475,42476,42477,42478,42479,42480,42481, +42482,42483,42484,42485,42486,42487,42488,42489,42490,42491,42492,42493, +42494,42495,42496,42497,42498,42499,42500,42501,42502,42503,42504,42505, +42506,42507,42508,42509,42510,42511,42512,42513,42514,42515,42516,42517, +42518,42519,42520,42521,42522,42523,42524,42525,42526,42527,42528,42529, +42530,42531,42532,42533,42534,42535,42536,42537,42538,42539,42540,42541, +42542,42543,42544,42545,42546,42547,42548,42549,42550,42551,42552,42553, +42554,42555,42556,42557,42558,42559,42560,42560,42562,42562,42564,42564, +42566,42566,42568,42568,42570,42570,42572,42572,42574,42574,42576,42576, +42578,42578,42580,42580,42582,42582,42584,42584,42586,42586,42588,42588, +42590,42590,42592,42592,42594,42594,42596,42596,42598,42598,42600,42600, +42602,42602,42604,42604,42606,42607,42608,42609,42610,42611,42612,42613, +42614,42615,42616,42617,42618,42619,42620,42621,42622,42623,42624,42624, +42626,42626,42628,42628,42630,42630,42632,42632,42634,42634,42636,42636, +42638,42638,42640,42640,42642,42642,42644,42644,42646,42646,42648,42649, +42650,42651,42652,42653,42654,42655,42656,42657,42658,42659,42660,42661, +42662,42663,42664,42665,42666,42667,42668,42669,42670,42671,42672,42673, +42674,42675,42676,42677,42678,42679,42680,42681,42682,42683,42684,42685, +42686,42687,42688,42689,42690,42691,42692,42693,42694,42695,42696,42697, +42698,42699,42700,42701,42702,42703,42704,42705,42706,42707,42708,42709, +42710,42711,42712,42713,42714,42715,42716,42717,42718,42719,42720,42721, +42722,42723,42724,42725,42726,42727,42728,42729,42730,42731,42732,42733, +42734,42735,42736,42737,42738,42739,42740,42741,42742,42743,42744,42745, +42746,42747,42748,42749,42750,42751,42752,42753,42754,42755,42756,42757, +42758,42759,42760,42761,42762,42763,42764,42765,42766,42767,42768,42769, +42770,42771,42772,42773,42774,42775,42776,42777,42778,42779,42780,42781, +42782,42783,42784,42785,42786,42786,42788,42788,42790,42790,42792,42792, +42794,42794,42796,42796,42798,42798,42800,42801,42802,42802,42804,42804, +42806,42806,42808,42808,42810,42810,42812,42812,42814,42814,42816,42816, +42818,42818,42820,42820,42822,42822,42824,42824,42826,42826,42828,42828, +42830,42830,42832,42832,42834,42834,42836,42836,42838,42838,42840,42840, +42842,42842,42844,42844,42846,42846,42848,42848,42850,42850,42852,42852, +42854,42854,42856,42856,42858,42858,42860,42860,42862,42862,42864,42865, +42866,42867,42868,42869,42870,42871,42872,42873,42873,42875,42875,42877, +42878,42878,42880,42880,42882,42882,42884,42884,42886,42886,42888,42889, +42890,42891,42891,42893,42894,42895,42896,42896,42898,42899,42900,42901, +42902,42903,42904,42905,42906,42907,42908,42909,42910,42911,42912,42912, +42914,42914,42916,42916,42918,42918,42920,42920,42922,42923,42924,42925, +42926,42927,42928,42929,42930,42931,42932,42933,42934,42935,42936,42937, +42938,42939,42940,42941,42942,42943,42944,42945,42946,42947,42948,42949, +42950,42951,42952,42953,42954,42955,42956,42957,42958,42959,42960,42961, +42962,42963,42964,42965,42966,42967,42968,42969,42970,42971,42972,42973, +42974,42975,42976,42977,42978,42979,42980,42981,42982,42983,42984,42985, +42986,42987,42988,42989,42990,42991,42992,42993,42994,42995,42996,42997, +42998,42999,43000,43001,43002,43003,43004,43005,43006,43007,43008,43009, +43010,43011,43012,43013,43014,43015,43016,43017,43018,43019,43020,43021, +43022,43023,43024,43025,43026,43027,43028,43029,43030,43031,43032,43033, +43034,43035,43036,43037,43038,43039,43040,43041,43042,43043,43044,43045, +43046,43047,43048,43049,43050,43051,43052,43053,43054,43055,43056,43057, +43058,43059,43060,43061,43062,43063,43064,43065,43066,43067,43068,43069, +43070,43071,43072,43073,43074,43075,43076,43077,43078,43079,43080,43081, +43082,43083,43084,43085,43086,43087,43088,43089,43090,43091,43092,43093, +43094,43095,43096,43097,43098,43099,43100,43101,43102,43103,43104,43105, +43106,43107,43108,43109,43110,43111,43112,43113,43114,43115,43116,43117, +43118,43119,43120,43121,43122,43123,43124,43125,43126,43127,43128,43129, +43130,43131,43132,43133,43134,43135,43136,43137,43138,43139,43140,43141, +43142,43143,43144,43145,43146,43147,43148,43149,43150,43151,43152,43153, +43154,43155,43156,43157,43158,43159,43160,43161,43162,43163,43164,43165, +43166,43167,43168,43169,43170,43171,43172,43173,43174,43175,43176,43177, +43178,43179,43180,43181,43182,43183,43184,43185,43186,43187,43188,43189, +43190,43191,43192,43193,43194,43195,43196,43197,43198,43199,43200,43201, +43202,43203,43204,43205,43206,43207,43208,43209,43210,43211,43212,43213, +43214,43215,43216,43217,43218,43219,43220,43221,43222,43223,43224,43225, +43226,43227,43228,43229,43230,43231,43232,43233,43234,43235,43236,43237, +43238,43239,43240,43241,43242,43243,43244,43245,43246,43247,43248,43249, +43250,43251,43252,43253,43254,43255,43256,43257,43258,43259,43260,43261, +43262,43263,43264,43265,43266,43267,43268,43269,43270,43271,43272,43273, +43274,43275,43276,43277,43278,43279,43280,43281,43282,43283,43284,43285, +43286,43287,43288,43289,43290,43291,43292,43293,43294,43295,43296,43297, +43298,43299,43300,43301,43302,43303,43304,43305,43306,43307,43308,43309, +43310,43311,43312,43313,43314,43315,43316,43317,43318,43319,43320,43321, +43322,43323,43324,43325,43326,43327,43328,43329,43330,43331,43332,43333, +43334,43335,43336,43337,43338,43339,43340,43341,43342,43343,43344,43345, +43346,43347,43348,43349,43350,43351,43352,43353,43354,43355,43356,43357, +43358,43359,43360,43361,43362,43363,43364,43365,43366,43367,43368,43369, +43370,43371,43372,43373,43374,43375,43376,43377,43378,43379,43380,43381, +43382,43383,43384,43385,43386,43387,43388,43389,43390,43391,43392,43393, +43394,43395,43396,43397,43398,43399,43400,43401,43402,43403,43404,43405, +43406,43407,43408,43409,43410,43411,43412,43413,43414,43415,43416,43417, +43418,43419,43420,43421,43422,43423,43424,43425,43426,43427,43428,43429, +43430,43431,43432,43433,43434,43435,43436,43437,43438,43439,43440,43441, +43442,43443,43444,43445,43446,43447,43448,43449,43450,43451,43452,43453, +43454,43455,43456,43457,43458,43459,43460,43461,43462,43463,43464,43465, +43466,43467,43468,43469,43470,43471,43472,43473,43474,43475,43476,43477, +43478,43479,43480,43481,43482,43483,43484,43485,43486,43487,43488,43489, +43490,43491,43492,43493,43494,43495,43496,43497,43498,43499,43500,43501, +43502,43503,43504,43505,43506,43507,43508,43509,43510,43511,43512,43513, +43514,43515,43516,43517,43518,43519,43520,43521,43522,43523,43524,43525, +43526,43527,43528,43529,43530,43531,43532,43533,43534,43535,43536,43537, +43538,43539,43540,43541,43542,43543,43544,43545,43546,43547,43548,43549, +43550,43551,43552,43553,43554,43555,43556,43557,43558,43559,43560,43561, +43562,43563,43564,43565,43566,43567,43568,43569,43570,43571,43572,43573, +43574,43575,43576,43577,43578,43579,43580,43581,43582,43583,43584,43585, +43586,43587,43588,43589,43590,43591,43592,43593,43594,43595,43596,43597, +43598,43599,43600,43601,43602,43603,43604,43605,43606,43607,43608,43609, +43610,43611,43612,43613,43614,43615,43616,43617,43618,43619,43620,43621, +43622,43623,43624,43625,43626,43627,43628,43629,43630,43631,43632,43633, +43634,43635,43636,43637,43638,43639,43640,43641,43642,43643,43644,43645, +43646,43647,43648,43649,43650,43651,43652,43653,43654,43655,43656,43657, +43658,43659,43660,43661,43662,43663,43664,43665,43666,43667,43668,43669, +43670,43671,43672,43673,43674,43675,43676,43677,43678,43679,43680,43681, +43682,43683,43684,43685,43686,43687,43688,43689,43690,43691,43692,43693, +43694,43695,43696,43697,43698,43699,43700,43701,43702,43703,43704,43705, +43706,43707,43708,43709,43710,43711,43712,43713,43714,43715,43716,43717, +43718,43719,43720,43721,43722,43723,43724,43725,43726,43727,43728,43729, +43730,43731,43732,43733,43734,43735,43736,43737,43738,43739,43740,43741, +43742,43743,43744,43745,43746,43747,43748,43749,43750,43751,43752,43753, +43754,43755,43756,43757,43758,43759,43760,43761,43762,43763,43764,43765, +43766,43767,43768,43769,43770,43771,43772,43773,43774,43775,43776,43777, +43778,43779,43780,43781,43782,43783,43784,43785,43786,43787,43788,43789, +43790,43791,43792,43793,43794,43795,43796,43797,43798,43799,43800,43801, +43802,43803,43804,43805,43806,43807,43808,43809,43810,43811,43812,43813, +43814,43815,43816,43817,43818,43819,43820,43821,43822,43823,43824,43825, +43826,43827,43828,43829,43830,43831,43832,43833,43834,43835,43836,43837, +43838,43839,43840,43841,43842,43843,43844,43845,43846,43847,43848,43849, +43850,43851,43852,43853,43854,43855,43856,43857,43858,43859,43860,43861, +43862,43863,43864,43865,43866,43867,43868,43869,43870,43871,43872,43873, +43874,43875,43876,43877,43878,43879,43880,43881,43882,43883,43884,43885, +43886,43887,43888,43889,43890,43891,43892,43893,43894,43895,43896,43897, +43898,43899,43900,43901,43902,43903,43904,43905,43906,43907,43908,43909, +43910,43911,43912,43913,43914,43915,43916,43917,43918,43919,43920,43921, +43922,43923,43924,43925,43926,43927,43928,43929,43930,43931,43932,43933, +43934,43935,43936,43937,43938,43939,43940,43941,43942,43943,43944,43945, +43946,43947,43948,43949,43950,43951,43952,43953,43954,43955,43956,43957, +43958,43959,43960,43961,43962,43963,43964,43965,43966,43967,43968,43969, +43970,43971,43972,43973,43974,43975,43976,43977,43978,43979,43980,43981, +43982,43983,43984,43985,43986,43987,43988,43989,43990,43991,43992,43993, +43994,43995,43996,43997,43998,43999,44000,44001,44002,44003,44004,44005, +44006,44007,44008,44009,44010,44011,44012,44013,44014,44015,44016,44017, +44018,44019,44020,44021,44022,44023,44024,44025,44026,44027,44028,44029, +44030,44031,44032,44033,44034,44035,44036,44037,44038,44039,44040,44041, +44042,44043,44044,44045,44046,44047,44048,44049,44050,44051,44052,44053, +44054,44055,44056,44057,44058,44059,44060,44061,44062,44063,44064,44065, +44066,44067,44068,44069,44070,44071,44072,44073,44074,44075,44076,44077, +44078,44079,44080,44081,44082,44083,44084,44085,44086,44087,44088,44089, +44090,44091,44092,44093,44094,44095,44096,44097,44098,44099,44100,44101, +44102,44103,44104,44105,44106,44107,44108,44109,44110,44111,44112,44113, +44114,44115,44116,44117,44118,44119,44120,44121,44122,44123,44124,44125, +44126,44127,44128,44129,44130,44131,44132,44133,44134,44135,44136,44137, +44138,44139,44140,44141,44142,44143,44144,44145,44146,44147,44148,44149, +44150,44151,44152,44153,44154,44155,44156,44157,44158,44159,44160,44161, +44162,44163,44164,44165,44166,44167,44168,44169,44170,44171,44172,44173, +44174,44175,44176,44177,44178,44179,44180,44181,44182,44183,44184,44185, +44186,44187,44188,44189,44190,44191,44192,44193,44194,44195,44196,44197, +44198,44199,44200,44201,44202,44203,44204,44205,44206,44207,44208,44209, +44210,44211,44212,44213,44214,44215,44216,44217,44218,44219,44220,44221, +44222,44223,44224,44225,44226,44227,44228,44229,44230,44231,44232,44233, +44234,44235,44236,44237,44238,44239,44240,44241,44242,44243,44244,44245, +44246,44247,44248,44249,44250,44251,44252,44253,44254,44255,44256,44257, +44258,44259,44260,44261,44262,44263,44264,44265,44266,44267,44268,44269, +44270,44271,44272,44273,44274,44275,44276,44277,44278,44279,44280,44281, +44282,44283,44284,44285,44286,44287,44288,44289,44290,44291,44292,44293, +44294,44295,44296,44297,44298,44299,44300,44301,44302,44303,44304,44305, +44306,44307,44308,44309,44310,44311,44312,44313,44314,44315,44316,44317, +44318,44319,44320,44321,44322,44323,44324,44325,44326,44327,44328,44329, +44330,44331,44332,44333,44334,44335,44336,44337,44338,44339,44340,44341, +44342,44343,44344,44345,44346,44347,44348,44349,44350,44351,44352,44353, +44354,44355,44356,44357,44358,44359,44360,44361,44362,44363,44364,44365, +44366,44367,44368,44369,44370,44371,44372,44373,44374,44375,44376,44377, +44378,44379,44380,44381,44382,44383,44384,44385,44386,44387,44388,44389, +44390,44391,44392,44393,44394,44395,44396,44397,44398,44399,44400,44401, +44402,44403,44404,44405,44406,44407,44408,44409,44410,44411,44412,44413, +44414,44415,44416,44417,44418,44419,44420,44421,44422,44423,44424,44425, +44426,44427,44428,44429,44430,44431,44432,44433,44434,44435,44436,44437, +44438,44439,44440,44441,44442,44443,44444,44445,44446,44447,44448,44449, +44450,44451,44452,44453,44454,44455,44456,44457,44458,44459,44460,44461, +44462,44463,44464,44465,44466,44467,44468,44469,44470,44471,44472,44473, +44474,44475,44476,44477,44478,44479,44480,44481,44482,44483,44484,44485, +44486,44487,44488,44489,44490,44491,44492,44493,44494,44495,44496,44497, +44498,44499,44500,44501,44502,44503,44504,44505,44506,44507,44508,44509, +44510,44511,44512,44513,44514,44515,44516,44517,44518,44519,44520,44521, +44522,44523,44524,44525,44526,44527,44528,44529,44530,44531,44532,44533, +44534,44535,44536,44537,44538,44539,44540,44541,44542,44543,44544,44545, +44546,44547,44548,44549,44550,44551,44552,44553,44554,44555,44556,44557, +44558,44559,44560,44561,44562,44563,44564,44565,44566,44567,44568,44569, +44570,44571,44572,44573,44574,44575,44576,44577,44578,44579,44580,44581, +44582,44583,44584,44585,44586,44587,44588,44589,44590,44591,44592,44593, +44594,44595,44596,44597,44598,44599,44600,44601,44602,44603,44604,44605, +44606,44607,44608,44609,44610,44611,44612,44613,44614,44615,44616,44617, +44618,44619,44620,44621,44622,44623,44624,44625,44626,44627,44628,44629, +44630,44631,44632,44633,44634,44635,44636,44637,44638,44639,44640,44641, +44642,44643,44644,44645,44646,44647,44648,44649,44650,44651,44652,44653, +44654,44655,44656,44657,44658,44659,44660,44661,44662,44663,44664,44665, +44666,44667,44668,44669,44670,44671,44672,44673,44674,44675,44676,44677, +44678,44679,44680,44681,44682,44683,44684,44685,44686,44687,44688,44689, +44690,44691,44692,44693,44694,44695,44696,44697,44698,44699,44700,44701, +44702,44703,44704,44705,44706,44707,44708,44709,44710,44711,44712,44713, +44714,44715,44716,44717,44718,44719,44720,44721,44722,44723,44724,44725, +44726,44727,44728,44729,44730,44731,44732,44733,44734,44735,44736,44737, +44738,44739,44740,44741,44742,44743,44744,44745,44746,44747,44748,44749, +44750,44751,44752,44753,44754,44755,44756,44757,44758,44759,44760,44761, +44762,44763,44764,44765,44766,44767,44768,44769,44770,44771,44772,44773, +44774,44775,44776,44777,44778,44779,44780,44781,44782,44783,44784,44785, +44786,44787,44788,44789,44790,44791,44792,44793,44794,44795,44796,44797, +44798,44799,44800,44801,44802,44803,44804,44805,44806,44807,44808,44809, +44810,44811,44812,44813,44814,44815,44816,44817,44818,44819,44820,44821, +44822,44823,44824,44825,44826,44827,44828,44829,44830,44831,44832,44833, +44834,44835,44836,44837,44838,44839,44840,44841,44842,44843,44844,44845, +44846,44847,44848,44849,44850,44851,44852,44853,44854,44855,44856,44857, +44858,44859,44860,44861,44862,44863,44864,44865,44866,44867,44868,44869, +44870,44871,44872,44873,44874,44875,44876,44877,44878,44879,44880,44881, +44882,44883,44884,44885,44886,44887,44888,44889,44890,44891,44892,44893, +44894,44895,44896,44897,44898,44899,44900,44901,44902,44903,44904,44905, +44906,44907,44908,44909,44910,44911,44912,44913,44914,44915,44916,44917, +44918,44919,44920,44921,44922,44923,44924,44925,44926,44927,44928,44929, +44930,44931,44932,44933,44934,44935,44936,44937,44938,44939,44940,44941, +44942,44943,44944,44945,44946,44947,44948,44949,44950,44951,44952,44953, +44954,44955,44956,44957,44958,44959,44960,44961,44962,44963,44964,44965, +44966,44967,44968,44969,44970,44971,44972,44973,44974,44975,44976,44977, +44978,44979,44980,44981,44982,44983,44984,44985,44986,44987,44988,44989, +44990,44991,44992,44993,44994,44995,44996,44997,44998,44999,45000,45001, +45002,45003,45004,45005,45006,45007,45008,45009,45010,45011,45012,45013, +45014,45015,45016,45017,45018,45019,45020,45021,45022,45023,45024,45025, +45026,45027,45028,45029,45030,45031,45032,45033,45034,45035,45036,45037, +45038,45039,45040,45041,45042,45043,45044,45045,45046,45047,45048,45049, +45050,45051,45052,45053,45054,45055,45056,45057,45058,45059,45060,45061, +45062,45063,45064,45065,45066,45067,45068,45069,45070,45071,45072,45073, +45074,45075,45076,45077,45078,45079,45080,45081,45082,45083,45084,45085, +45086,45087,45088,45089,45090,45091,45092,45093,45094,45095,45096,45097, +45098,45099,45100,45101,45102,45103,45104,45105,45106,45107,45108,45109, +45110,45111,45112,45113,45114,45115,45116,45117,45118,45119,45120,45121, +45122,45123,45124,45125,45126,45127,45128,45129,45130,45131,45132,45133, +45134,45135,45136,45137,45138,45139,45140,45141,45142,45143,45144,45145, +45146,45147,45148,45149,45150,45151,45152,45153,45154,45155,45156,45157, +45158,45159,45160,45161,45162,45163,45164,45165,45166,45167,45168,45169, +45170,45171,45172,45173,45174,45175,45176,45177,45178,45179,45180,45181, +45182,45183,45184,45185,45186,45187,45188,45189,45190,45191,45192,45193, +45194,45195,45196,45197,45198,45199,45200,45201,45202,45203,45204,45205, +45206,45207,45208,45209,45210,45211,45212,45213,45214,45215,45216,45217, +45218,45219,45220,45221,45222,45223,45224,45225,45226,45227,45228,45229, +45230,45231,45232,45233,45234,45235,45236,45237,45238,45239,45240,45241, +45242,45243,45244,45245,45246,45247,45248,45249,45250,45251,45252,45253, +45254,45255,45256,45257,45258,45259,45260,45261,45262,45263,45264,45265, +45266,45267,45268,45269,45270,45271,45272,45273,45274,45275,45276,45277, +45278,45279,45280,45281,45282,45283,45284,45285,45286,45287,45288,45289, +45290,45291,45292,45293,45294,45295,45296,45297,45298,45299,45300,45301, +45302,45303,45304,45305,45306,45307,45308,45309,45310,45311,45312,45313, +45314,45315,45316,45317,45318,45319,45320,45321,45322,45323,45324,45325, +45326,45327,45328,45329,45330,45331,45332,45333,45334,45335,45336,45337, +45338,45339,45340,45341,45342,45343,45344,45345,45346,45347,45348,45349, +45350,45351,45352,45353,45354,45355,45356,45357,45358,45359,45360,45361, +45362,45363,45364,45365,45366,45367,45368,45369,45370,45371,45372,45373, +45374,45375,45376,45377,45378,45379,45380,45381,45382,45383,45384,45385, +45386,45387,45388,45389,45390,45391,45392,45393,45394,45395,45396,45397, +45398,45399,45400,45401,45402,45403,45404,45405,45406,45407,45408,45409, +45410,45411,45412,45413,45414,45415,45416,45417,45418,45419,45420,45421, +45422,45423,45424,45425,45426,45427,45428,45429,45430,45431,45432,45433, +45434,45435,45436,45437,45438,45439,45440,45441,45442,45443,45444,45445, +45446,45447,45448,45449,45450,45451,45452,45453,45454,45455,45456,45457, +45458,45459,45460,45461,45462,45463,45464,45465,45466,45467,45468,45469, +45470,45471,45472,45473,45474,45475,45476,45477,45478,45479,45480,45481, +45482,45483,45484,45485,45486,45487,45488,45489,45490,45491,45492,45493, +45494,45495,45496,45497,45498,45499,45500,45501,45502,45503,45504,45505, +45506,45507,45508,45509,45510,45511,45512,45513,45514,45515,45516,45517, +45518,45519,45520,45521,45522,45523,45524,45525,45526,45527,45528,45529, +45530,45531,45532,45533,45534,45535,45536,45537,45538,45539,45540,45541, +45542,45543,45544,45545,45546,45547,45548,45549,45550,45551,45552,45553, +45554,45555,45556,45557,45558,45559,45560,45561,45562,45563,45564,45565, +45566,45567,45568,45569,45570,45571,45572,45573,45574,45575,45576,45577, +45578,45579,45580,45581,45582,45583,45584,45585,45586,45587,45588,45589, +45590,45591,45592,45593,45594,45595,45596,45597,45598,45599,45600,45601, +45602,45603,45604,45605,45606,45607,45608,45609,45610,45611,45612,45613, +45614,45615,45616,45617,45618,45619,45620,45621,45622,45623,45624,45625, +45626,45627,45628,45629,45630,45631,45632,45633,45634,45635,45636,45637, +45638,45639,45640,45641,45642,45643,45644,45645,45646,45647,45648,45649, +45650,45651,45652,45653,45654,45655,45656,45657,45658,45659,45660,45661, +45662,45663,45664,45665,45666,45667,45668,45669,45670,45671,45672,45673, +45674,45675,45676,45677,45678,45679,45680,45681,45682,45683,45684,45685, +45686,45687,45688,45689,45690,45691,45692,45693,45694,45695,45696,45697, +45698,45699,45700,45701,45702,45703,45704,45705,45706,45707,45708,45709, +45710,45711,45712,45713,45714,45715,45716,45717,45718,45719,45720,45721, +45722,45723,45724,45725,45726,45727,45728,45729,45730,45731,45732,45733, +45734,45735,45736,45737,45738,45739,45740,45741,45742,45743,45744,45745, +45746,45747,45748,45749,45750,45751,45752,45753,45754,45755,45756,45757, +45758,45759,45760,45761,45762,45763,45764,45765,45766,45767,45768,45769, +45770,45771,45772,45773,45774,45775,45776,45777,45778,45779,45780,45781, +45782,45783,45784,45785,45786,45787,45788,45789,45790,45791,45792,45793, +45794,45795,45796,45797,45798,45799,45800,45801,45802,45803,45804,45805, +45806,45807,45808,45809,45810,45811,45812,45813,45814,45815,45816,45817, +45818,45819,45820,45821,45822,45823,45824,45825,45826,45827,45828,45829, +45830,45831,45832,45833,45834,45835,45836,45837,45838,45839,45840,45841, +45842,45843,45844,45845,45846,45847,45848,45849,45850,45851,45852,45853, +45854,45855,45856,45857,45858,45859,45860,45861,45862,45863,45864,45865, +45866,45867,45868,45869,45870,45871,45872,45873,45874,45875,45876,45877, +45878,45879,45880,45881,45882,45883,45884,45885,45886,45887,45888,45889, +45890,45891,45892,45893,45894,45895,45896,45897,45898,45899,45900,45901, +45902,45903,45904,45905,45906,45907,45908,45909,45910,45911,45912,45913, +45914,45915,45916,45917,45918,45919,45920,45921,45922,45923,45924,45925, +45926,45927,45928,45929,45930,45931,45932,45933,45934,45935,45936,45937, +45938,45939,45940,45941,45942,45943,45944,45945,45946,45947,45948,45949, +45950,45951,45952,45953,45954,45955,45956,45957,45958,45959,45960,45961, +45962,45963,45964,45965,45966,45967,45968,45969,45970,45971,45972,45973, +45974,45975,45976,45977,45978,45979,45980,45981,45982,45983,45984,45985, +45986,45987,45988,45989,45990,45991,45992,45993,45994,45995,45996,45997, +45998,45999,46000,46001,46002,46003,46004,46005,46006,46007,46008,46009, +46010,46011,46012,46013,46014,46015,46016,46017,46018,46019,46020,46021, +46022,46023,46024,46025,46026,46027,46028,46029,46030,46031,46032,46033, +46034,46035,46036,46037,46038,46039,46040,46041,46042,46043,46044,46045, +46046,46047,46048,46049,46050,46051,46052,46053,46054,46055,46056,46057, +46058,46059,46060,46061,46062,46063,46064,46065,46066,46067,46068,46069, +46070,46071,46072,46073,46074,46075,46076,46077,46078,46079,46080,46081, +46082,46083,46084,46085,46086,46087,46088,46089,46090,46091,46092,46093, +46094,46095,46096,46097,46098,46099,46100,46101,46102,46103,46104,46105, +46106,46107,46108,46109,46110,46111,46112,46113,46114,46115,46116,46117, +46118,46119,46120,46121,46122,46123,46124,46125,46126,46127,46128,46129, +46130,46131,46132,46133,46134,46135,46136,46137,46138,46139,46140,46141, +46142,46143,46144,46145,46146,46147,46148,46149,46150,46151,46152,46153, +46154,46155,46156,46157,46158,46159,46160,46161,46162,46163,46164,46165, +46166,46167,46168,46169,46170,46171,46172,46173,46174,46175,46176,46177, +46178,46179,46180,46181,46182,46183,46184,46185,46186,46187,46188,46189, +46190,46191,46192,46193,46194,46195,46196,46197,46198,46199,46200,46201, +46202,46203,46204,46205,46206,46207,46208,46209,46210,46211,46212,46213, +46214,46215,46216,46217,46218,46219,46220,46221,46222,46223,46224,46225, +46226,46227,46228,46229,46230,46231,46232,46233,46234,46235,46236,46237, +46238,46239,46240,46241,46242,46243,46244,46245,46246,46247,46248,46249, +46250,46251,46252,46253,46254,46255,46256,46257,46258,46259,46260,46261, +46262,46263,46264,46265,46266,46267,46268,46269,46270,46271,46272,46273, +46274,46275,46276,46277,46278,46279,46280,46281,46282,46283,46284,46285, +46286,46287,46288,46289,46290,46291,46292,46293,46294,46295,46296,46297, +46298,46299,46300,46301,46302,46303,46304,46305,46306,46307,46308,46309, +46310,46311,46312,46313,46314,46315,46316,46317,46318,46319,46320,46321, +46322,46323,46324,46325,46326,46327,46328,46329,46330,46331,46332,46333, +46334,46335,46336,46337,46338,46339,46340,46341,46342,46343,46344,46345, +46346,46347,46348,46349,46350,46351,46352,46353,46354,46355,46356,46357, +46358,46359,46360,46361,46362,46363,46364,46365,46366,46367,46368,46369, +46370,46371,46372,46373,46374,46375,46376,46377,46378,46379,46380,46381, +46382,46383,46384,46385,46386,46387,46388,46389,46390,46391,46392,46393, +46394,46395,46396,46397,46398,46399,46400,46401,46402,46403,46404,46405, +46406,46407,46408,46409,46410,46411,46412,46413,46414,46415,46416,46417, +46418,46419,46420,46421,46422,46423,46424,46425,46426,46427,46428,46429, +46430,46431,46432,46433,46434,46435,46436,46437,46438,46439,46440,46441, +46442,46443,46444,46445,46446,46447,46448,46449,46450,46451,46452,46453, +46454,46455,46456,46457,46458,46459,46460,46461,46462,46463,46464,46465, +46466,46467,46468,46469,46470,46471,46472,46473,46474,46475,46476,46477, +46478,46479,46480,46481,46482,46483,46484,46485,46486,46487,46488,46489, +46490,46491,46492,46493,46494,46495,46496,46497,46498,46499,46500,46501, +46502,46503,46504,46505,46506,46507,46508,46509,46510,46511,46512,46513, +46514,46515,46516,46517,46518,46519,46520,46521,46522,46523,46524,46525, +46526,46527,46528,46529,46530,46531,46532,46533,46534,46535,46536,46537, +46538,46539,46540,46541,46542,46543,46544,46545,46546,46547,46548,46549, +46550,46551,46552,46553,46554,46555,46556,46557,46558,46559,46560,46561, +46562,46563,46564,46565,46566,46567,46568,46569,46570,46571,46572,46573, +46574,46575,46576,46577,46578,46579,46580,46581,46582,46583,46584,46585, +46586,46587,46588,46589,46590,46591,46592,46593,46594,46595,46596,46597, +46598,46599,46600,46601,46602,46603,46604,46605,46606,46607,46608,46609, +46610,46611,46612,46613,46614,46615,46616,46617,46618,46619,46620,46621, +46622,46623,46624,46625,46626,46627,46628,46629,46630,46631,46632,46633, +46634,46635,46636,46637,46638,46639,46640,46641,46642,46643,46644,46645, +46646,46647,46648,46649,46650,46651,46652,46653,46654,46655,46656,46657, +46658,46659,46660,46661,46662,46663,46664,46665,46666,46667,46668,46669, +46670,46671,46672,46673,46674,46675,46676,46677,46678,46679,46680,46681, +46682,46683,46684,46685,46686,46687,46688,46689,46690,46691,46692,46693, +46694,46695,46696,46697,46698,46699,46700,46701,46702,46703,46704,46705, +46706,46707,46708,46709,46710,46711,46712,46713,46714,46715,46716,46717, +46718,46719,46720,46721,46722,46723,46724,46725,46726,46727,46728,46729, +46730,46731,46732,46733,46734,46735,46736,46737,46738,46739,46740,46741, +46742,46743,46744,46745,46746,46747,46748,46749,46750,46751,46752,46753, +46754,46755,46756,46757,46758,46759,46760,46761,46762,46763,46764,46765, +46766,46767,46768,46769,46770,46771,46772,46773,46774,46775,46776,46777, +46778,46779,46780,46781,46782,46783,46784,46785,46786,46787,46788,46789, +46790,46791,46792,46793,46794,46795,46796,46797,46798,46799,46800,46801, +46802,46803,46804,46805,46806,46807,46808,46809,46810,46811,46812,46813, +46814,46815,46816,46817,46818,46819,46820,46821,46822,46823,46824,46825, +46826,46827,46828,46829,46830,46831,46832,46833,46834,46835,46836,46837, +46838,46839,46840,46841,46842,46843,46844,46845,46846,46847,46848,46849, +46850,46851,46852,46853,46854,46855,46856,46857,46858,46859,46860,46861, +46862,46863,46864,46865,46866,46867,46868,46869,46870,46871,46872,46873, +46874,46875,46876,46877,46878,46879,46880,46881,46882,46883,46884,46885, +46886,46887,46888,46889,46890,46891,46892,46893,46894,46895,46896,46897, +46898,46899,46900,46901,46902,46903,46904,46905,46906,46907,46908,46909, +46910,46911,46912,46913,46914,46915,46916,46917,46918,46919,46920,46921, +46922,46923,46924,46925,46926,46927,46928,46929,46930,46931,46932,46933, +46934,46935,46936,46937,46938,46939,46940,46941,46942,46943,46944,46945, +46946,46947,46948,46949,46950,46951,46952,46953,46954,46955,46956,46957, +46958,46959,46960,46961,46962,46963,46964,46965,46966,46967,46968,46969, +46970,46971,46972,46973,46974,46975,46976,46977,46978,46979,46980,46981, +46982,46983,46984,46985,46986,46987,46988,46989,46990,46991,46992,46993, +46994,46995,46996,46997,46998,46999,47000,47001,47002,47003,47004,47005, +47006,47007,47008,47009,47010,47011,47012,47013,47014,47015,47016,47017, +47018,47019,47020,47021,47022,47023,47024,47025,47026,47027,47028,47029, +47030,47031,47032,47033,47034,47035,47036,47037,47038,47039,47040,47041, +47042,47043,47044,47045,47046,47047,47048,47049,47050,47051,47052,47053, +47054,47055,47056,47057,47058,47059,47060,47061,47062,47063,47064,47065, +47066,47067,47068,47069,47070,47071,47072,47073,47074,47075,47076,47077, +47078,47079,47080,47081,47082,47083,47084,47085,47086,47087,47088,47089, +47090,47091,47092,47093,47094,47095,47096,47097,47098,47099,47100,47101, +47102,47103,47104,47105,47106,47107,47108,47109,47110,47111,47112,47113, +47114,47115,47116,47117,47118,47119,47120,47121,47122,47123,47124,47125, +47126,47127,47128,47129,47130,47131,47132,47133,47134,47135,47136,47137, +47138,47139,47140,47141,47142,47143,47144,47145,47146,47147,47148,47149, +47150,47151,47152,47153,47154,47155,47156,47157,47158,47159,47160,47161, +47162,47163,47164,47165,47166,47167,47168,47169,47170,47171,47172,47173, +47174,47175,47176,47177,47178,47179,47180,47181,47182,47183,47184,47185, +47186,47187,47188,47189,47190,47191,47192,47193,47194,47195,47196,47197, +47198,47199,47200,47201,47202,47203,47204,47205,47206,47207,47208,47209, +47210,47211,47212,47213,47214,47215,47216,47217,47218,47219,47220,47221, +47222,47223,47224,47225,47226,47227,47228,47229,47230,47231,47232,47233, +47234,47235,47236,47237,47238,47239,47240,47241,47242,47243,47244,47245, +47246,47247,47248,47249,47250,47251,47252,47253,47254,47255,47256,47257, +47258,47259,47260,47261,47262,47263,47264,47265,47266,47267,47268,47269, +47270,47271,47272,47273,47274,47275,47276,47277,47278,47279,47280,47281, +47282,47283,47284,47285,47286,47287,47288,47289,47290,47291,47292,47293, +47294,47295,47296,47297,47298,47299,47300,47301,47302,47303,47304,47305, +47306,47307,47308,47309,47310,47311,47312,47313,47314,47315,47316,47317, +47318,47319,47320,47321,47322,47323,47324,47325,47326,47327,47328,47329, +47330,47331,47332,47333,47334,47335,47336,47337,47338,47339,47340,47341, +47342,47343,47344,47345,47346,47347,47348,47349,47350,47351,47352,47353, +47354,47355,47356,47357,47358,47359,47360,47361,47362,47363,47364,47365, +47366,47367,47368,47369,47370,47371,47372,47373,47374,47375,47376,47377, +47378,47379,47380,47381,47382,47383,47384,47385,47386,47387,47388,47389, +47390,47391,47392,47393,47394,47395,47396,47397,47398,47399,47400,47401, +47402,47403,47404,47405,47406,47407,47408,47409,47410,47411,47412,47413, +47414,47415,47416,47417,47418,47419,47420,47421,47422,47423,47424,47425, +47426,47427,47428,47429,47430,47431,47432,47433,47434,47435,47436,47437, +47438,47439,47440,47441,47442,47443,47444,47445,47446,47447,47448,47449, +47450,47451,47452,47453,47454,47455,47456,47457,47458,47459,47460,47461, +47462,47463,47464,47465,47466,47467,47468,47469,47470,47471,47472,47473, +47474,47475,47476,47477,47478,47479,47480,47481,47482,47483,47484,47485, +47486,47487,47488,47489,47490,47491,47492,47493,47494,47495,47496,47497, +47498,47499,47500,47501,47502,47503,47504,47505,47506,47507,47508,47509, +47510,47511,47512,47513,47514,47515,47516,47517,47518,47519,47520,47521, +47522,47523,47524,47525,47526,47527,47528,47529,47530,47531,47532,47533, +47534,47535,47536,47537,47538,47539,47540,47541,47542,47543,47544,47545, +47546,47547,47548,47549,47550,47551,47552,47553,47554,47555,47556,47557, +47558,47559,47560,47561,47562,47563,47564,47565,47566,47567,47568,47569, +47570,47571,47572,47573,47574,47575,47576,47577,47578,47579,47580,47581, +47582,47583,47584,47585,47586,47587,47588,47589,47590,47591,47592,47593, +47594,47595,47596,47597,47598,47599,47600,47601,47602,47603,47604,47605, +47606,47607,47608,47609,47610,47611,47612,47613,47614,47615,47616,47617, +47618,47619,47620,47621,47622,47623,47624,47625,47626,47627,47628,47629, +47630,47631,47632,47633,47634,47635,47636,47637,47638,47639,47640,47641, +47642,47643,47644,47645,47646,47647,47648,47649,47650,47651,47652,47653, +47654,47655,47656,47657,47658,47659,47660,47661,47662,47663,47664,47665, +47666,47667,47668,47669,47670,47671,47672,47673,47674,47675,47676,47677, +47678,47679,47680,47681,47682,47683,47684,47685,47686,47687,47688,47689, +47690,47691,47692,47693,47694,47695,47696,47697,47698,47699,47700,47701, +47702,47703,47704,47705,47706,47707,47708,47709,47710,47711,47712,47713, +47714,47715,47716,47717,47718,47719,47720,47721,47722,47723,47724,47725, +47726,47727,47728,47729,47730,47731,47732,47733,47734,47735,47736,47737, +47738,47739,47740,47741,47742,47743,47744,47745,47746,47747,47748,47749, +47750,47751,47752,47753,47754,47755,47756,47757,47758,47759,47760,47761, +47762,47763,47764,47765,47766,47767,47768,47769,47770,47771,47772,47773, +47774,47775,47776,47777,47778,47779,47780,47781,47782,47783,47784,47785, +47786,47787,47788,47789,47790,47791,47792,47793,47794,47795,47796,47797, +47798,47799,47800,47801,47802,47803,47804,47805,47806,47807,47808,47809, +47810,47811,47812,47813,47814,47815,47816,47817,47818,47819,47820,47821, +47822,47823,47824,47825,47826,47827,47828,47829,47830,47831,47832,47833, +47834,47835,47836,47837,47838,47839,47840,47841,47842,47843,47844,47845, +47846,47847,47848,47849,47850,47851,47852,47853,47854,47855,47856,47857, +47858,47859,47860,47861,47862,47863,47864,47865,47866,47867,47868,47869, +47870,47871,47872,47873,47874,47875,47876,47877,47878,47879,47880,47881, +47882,47883,47884,47885,47886,47887,47888,47889,47890,47891,47892,47893, +47894,47895,47896,47897,47898,47899,47900,47901,47902,47903,47904,47905, +47906,47907,47908,47909,47910,47911,47912,47913,47914,47915,47916,47917, +47918,47919,47920,47921,47922,47923,47924,47925,47926,47927,47928,47929, +47930,47931,47932,47933,47934,47935,47936,47937,47938,47939,47940,47941, +47942,47943,47944,47945,47946,47947,47948,47949,47950,47951,47952,47953, +47954,47955,47956,47957,47958,47959,47960,47961,47962,47963,47964,47965, +47966,47967,47968,47969,47970,47971,47972,47973,47974,47975,47976,47977, +47978,47979,47980,47981,47982,47983,47984,47985,47986,47987,47988,47989, +47990,47991,47992,47993,47994,47995,47996,47997,47998,47999,48000,48001, +48002,48003,48004,48005,48006,48007,48008,48009,48010,48011,48012,48013, +48014,48015,48016,48017,48018,48019,48020,48021,48022,48023,48024,48025, +48026,48027,48028,48029,48030,48031,48032,48033,48034,48035,48036,48037, +48038,48039,48040,48041,48042,48043,48044,48045,48046,48047,48048,48049, +48050,48051,48052,48053,48054,48055,48056,48057,48058,48059,48060,48061, +48062,48063,48064,48065,48066,48067,48068,48069,48070,48071,48072,48073, +48074,48075,48076,48077,48078,48079,48080,48081,48082,48083,48084,48085, +48086,48087,48088,48089,48090,48091,48092,48093,48094,48095,48096,48097, +48098,48099,48100,48101,48102,48103,48104,48105,48106,48107,48108,48109, +48110,48111,48112,48113,48114,48115,48116,48117,48118,48119,48120,48121, +48122,48123,48124,48125,48126,48127,48128,48129,48130,48131,48132,48133, +48134,48135,48136,48137,48138,48139,48140,48141,48142,48143,48144,48145, +48146,48147,48148,48149,48150,48151,48152,48153,48154,48155,48156,48157, +48158,48159,48160,48161,48162,48163,48164,48165,48166,48167,48168,48169, +48170,48171,48172,48173,48174,48175,48176,48177,48178,48179,48180,48181, +48182,48183,48184,48185,48186,48187,48188,48189,48190,48191,48192,48193, +48194,48195,48196,48197,48198,48199,48200,48201,48202,48203,48204,48205, +48206,48207,48208,48209,48210,48211,48212,48213,48214,48215,48216,48217, +48218,48219,48220,48221,48222,48223,48224,48225,48226,48227,48228,48229, +48230,48231,48232,48233,48234,48235,48236,48237,48238,48239,48240,48241, +48242,48243,48244,48245,48246,48247,48248,48249,48250,48251,48252,48253, +48254,48255,48256,48257,48258,48259,48260,48261,48262,48263,48264,48265, +48266,48267,48268,48269,48270,48271,48272,48273,48274,48275,48276,48277, +48278,48279,48280,48281,48282,48283,48284,48285,48286,48287,48288,48289, +48290,48291,48292,48293,48294,48295,48296,48297,48298,48299,48300,48301, +48302,48303,48304,48305,48306,48307,48308,48309,48310,48311,48312,48313, +48314,48315,48316,48317,48318,48319,48320,48321,48322,48323,48324,48325, +48326,48327,48328,48329,48330,48331,48332,48333,48334,48335,48336,48337, +48338,48339,48340,48341,48342,48343,48344,48345,48346,48347,48348,48349, +48350,48351,48352,48353,48354,48355,48356,48357,48358,48359,48360,48361, +48362,48363,48364,48365,48366,48367,48368,48369,48370,48371,48372,48373, +48374,48375,48376,48377,48378,48379,48380,48381,48382,48383,48384,48385, +48386,48387,48388,48389,48390,48391,48392,48393,48394,48395,48396,48397, +48398,48399,48400,48401,48402,48403,48404,48405,48406,48407,48408,48409, +48410,48411,48412,48413,48414,48415,48416,48417,48418,48419,48420,48421, +48422,48423,48424,48425,48426,48427,48428,48429,48430,48431,48432,48433, +48434,48435,48436,48437,48438,48439,48440,48441,48442,48443,48444,48445, +48446,48447,48448,48449,48450,48451,48452,48453,48454,48455,48456,48457, +48458,48459,48460,48461,48462,48463,48464,48465,48466,48467,48468,48469, +48470,48471,48472,48473,48474,48475,48476,48477,48478,48479,48480,48481, +48482,48483,48484,48485,48486,48487,48488,48489,48490,48491,48492,48493, +48494,48495,48496,48497,48498,48499,48500,48501,48502,48503,48504,48505, +48506,48507,48508,48509,48510,48511,48512,48513,48514,48515,48516,48517, +48518,48519,48520,48521,48522,48523,48524,48525,48526,48527,48528,48529, +48530,48531,48532,48533,48534,48535,48536,48537,48538,48539,48540,48541, +48542,48543,48544,48545,48546,48547,48548,48549,48550,48551,48552,48553, +48554,48555,48556,48557,48558,48559,48560,48561,48562,48563,48564,48565, +48566,48567,48568,48569,48570,48571,48572,48573,48574,48575,48576,48577, +48578,48579,48580,48581,48582,48583,48584,48585,48586,48587,48588,48589, +48590,48591,48592,48593,48594,48595,48596,48597,48598,48599,48600,48601, +48602,48603,48604,48605,48606,48607,48608,48609,48610,48611,48612,48613, +48614,48615,48616,48617,48618,48619,48620,48621,48622,48623,48624,48625, +48626,48627,48628,48629,48630,48631,48632,48633,48634,48635,48636,48637, +48638,48639,48640,48641,48642,48643,48644,48645,48646,48647,48648,48649, +48650,48651,48652,48653,48654,48655,48656,48657,48658,48659,48660,48661, +48662,48663,48664,48665,48666,48667,48668,48669,48670,48671,48672,48673, +48674,48675,48676,48677,48678,48679,48680,48681,48682,48683,48684,48685, +48686,48687,48688,48689,48690,48691,48692,48693,48694,48695,48696,48697, +48698,48699,48700,48701,48702,48703,48704,48705,48706,48707,48708,48709, +48710,48711,48712,48713,48714,48715,48716,48717,48718,48719,48720,48721, +48722,48723,48724,48725,48726,48727,48728,48729,48730,48731,48732,48733, +48734,48735,48736,48737,48738,48739,48740,48741,48742,48743,48744,48745, +48746,48747,48748,48749,48750,48751,48752,48753,48754,48755,48756,48757, +48758,48759,48760,48761,48762,48763,48764,48765,48766,48767,48768,48769, +48770,48771,48772,48773,48774,48775,48776,48777,48778,48779,48780,48781, +48782,48783,48784,48785,48786,48787,48788,48789,48790,48791,48792,48793, +48794,48795,48796,48797,48798,48799,48800,48801,48802,48803,48804,48805, +48806,48807,48808,48809,48810,48811,48812,48813,48814,48815,48816,48817, +48818,48819,48820,48821,48822,48823,48824,48825,48826,48827,48828,48829, +48830,48831,48832,48833,48834,48835,48836,48837,48838,48839,48840,48841, +48842,48843,48844,48845,48846,48847,48848,48849,48850,48851,48852,48853, +48854,48855,48856,48857,48858,48859,48860,48861,48862,48863,48864,48865, +48866,48867,48868,48869,48870,48871,48872,48873,48874,48875,48876,48877, +48878,48879,48880,48881,48882,48883,48884,48885,48886,48887,48888,48889, +48890,48891,48892,48893,48894,48895,48896,48897,48898,48899,48900,48901, +48902,48903,48904,48905,48906,48907,48908,48909,48910,48911,48912,48913, +48914,48915,48916,48917,48918,48919,48920,48921,48922,48923,48924,48925, +48926,48927,48928,48929,48930,48931,48932,48933,48934,48935,48936,48937, +48938,48939,48940,48941,48942,48943,48944,48945,48946,48947,48948,48949, +48950,48951,48952,48953,48954,48955,48956,48957,48958,48959,48960,48961, +48962,48963,48964,48965,48966,48967,48968,48969,48970,48971,48972,48973, +48974,48975,48976,48977,48978,48979,48980,48981,48982,48983,48984,48985, +48986,48987,48988,48989,48990,48991,48992,48993,48994,48995,48996,48997, +48998,48999,49000,49001,49002,49003,49004,49005,49006,49007,49008,49009, +49010,49011,49012,49013,49014,49015,49016,49017,49018,49019,49020,49021, +49022,49023,49024,49025,49026,49027,49028,49029,49030,49031,49032,49033, +49034,49035,49036,49037,49038,49039,49040,49041,49042,49043,49044,49045, +49046,49047,49048,49049,49050,49051,49052,49053,49054,49055,49056,49057, +49058,49059,49060,49061,49062,49063,49064,49065,49066,49067,49068,49069, +49070,49071,49072,49073,49074,49075,49076,49077,49078,49079,49080,49081, +49082,49083,49084,49085,49086,49087,49088,49089,49090,49091,49092,49093, +49094,49095,49096,49097,49098,49099,49100,49101,49102,49103,49104,49105, +49106,49107,49108,49109,49110,49111,49112,49113,49114,49115,49116,49117, +49118,49119,49120,49121,49122,49123,49124,49125,49126,49127,49128,49129, +49130,49131,49132,49133,49134,49135,49136,49137,49138,49139,49140,49141, +49142,49143,49144,49145,49146,49147,49148,49149,49150,49151,49152,49153, +49154,49155,49156,49157,49158,49159,49160,49161,49162,49163,49164,49165, +49166,49167,49168,49169,49170,49171,49172,49173,49174,49175,49176,49177, +49178,49179,49180,49181,49182,49183,49184,49185,49186,49187,49188,49189, +49190,49191,49192,49193,49194,49195,49196,49197,49198,49199,49200,49201, +49202,49203,49204,49205,49206,49207,49208,49209,49210,49211,49212,49213, +49214,49215,49216,49217,49218,49219,49220,49221,49222,49223,49224,49225, +49226,49227,49228,49229,49230,49231,49232,49233,49234,49235,49236,49237, +49238,49239,49240,49241,49242,49243,49244,49245,49246,49247,49248,49249, +49250,49251,49252,49253,49254,49255,49256,49257,49258,49259,49260,49261, +49262,49263,49264,49265,49266,49267,49268,49269,49270,49271,49272,49273, +49274,49275,49276,49277,49278,49279,49280,49281,49282,49283,49284,49285, +49286,49287,49288,49289,49290,49291,49292,49293,49294,49295,49296,49297, +49298,49299,49300,49301,49302,49303,49304,49305,49306,49307,49308,49309, +49310,49311,49312,49313,49314,49315,49316,49317,49318,49319,49320,49321, +49322,49323,49324,49325,49326,49327,49328,49329,49330,49331,49332,49333, +49334,49335,49336,49337,49338,49339,49340,49341,49342,49343,49344,49345, +49346,49347,49348,49349,49350,49351,49352,49353,49354,49355,49356,49357, +49358,49359,49360,49361,49362,49363,49364,49365,49366,49367,49368,49369, +49370,49371,49372,49373,49374,49375,49376,49377,49378,49379,49380,49381, +49382,49383,49384,49385,49386,49387,49388,49389,49390,49391,49392,49393, +49394,49395,49396,49397,49398,49399,49400,49401,49402,49403,49404,49405, +49406,49407,49408,49409,49410,49411,49412,49413,49414,49415,49416,49417, +49418,49419,49420,49421,49422,49423,49424,49425,49426,49427,49428,49429, +49430,49431,49432,49433,49434,49435,49436,49437,49438,49439,49440,49441, +49442,49443,49444,49445,49446,49447,49448,49449,49450,49451,49452,49453, +49454,49455,49456,49457,49458,49459,49460,49461,49462,49463,49464,49465, +49466,49467,49468,49469,49470,49471,49472,49473,49474,49475,49476,49477, +49478,49479,49480,49481,49482,49483,49484,49485,49486,49487,49488,49489, +49490,49491,49492,49493,49494,49495,49496,49497,49498,49499,49500,49501, +49502,49503,49504,49505,49506,49507,49508,49509,49510,49511,49512,49513, +49514,49515,49516,49517,49518,49519,49520,49521,49522,49523,49524,49525, +49526,49527,49528,49529,49530,49531,49532,49533,49534,49535,49536,49537, +49538,49539,49540,49541,49542,49543,49544,49545,49546,49547,49548,49549, +49550,49551,49552,49553,49554,49555,49556,49557,49558,49559,49560,49561, +49562,49563,49564,49565,49566,49567,49568,49569,49570,49571,49572,49573, +49574,49575,49576,49577,49578,49579,49580,49581,49582,49583,49584,49585, +49586,49587,49588,49589,49590,49591,49592,49593,49594,49595,49596,49597, +49598,49599,49600,49601,49602,49603,49604,49605,49606,49607,49608,49609, +49610,49611,49612,49613,49614,49615,49616,49617,49618,49619,49620,49621, +49622,49623,49624,49625,49626,49627,49628,49629,49630,49631,49632,49633, +49634,49635,49636,49637,49638,49639,49640,49641,49642,49643,49644,49645, +49646,49647,49648,49649,49650,49651,49652,49653,49654,49655,49656,49657, +49658,49659,49660,49661,49662,49663,49664,49665,49666,49667,49668,49669, +49670,49671,49672,49673,49674,49675,49676,49677,49678,49679,49680,49681, +49682,49683,49684,49685,49686,49687,49688,49689,49690,49691,49692,49693, +49694,49695,49696,49697,49698,49699,49700,49701,49702,49703,49704,49705, +49706,49707,49708,49709,49710,49711,49712,49713,49714,49715,49716,49717, +49718,49719,49720,49721,49722,49723,49724,49725,49726,49727,49728,49729, +49730,49731,49732,49733,49734,49735,49736,49737,49738,49739,49740,49741, +49742,49743,49744,49745,49746,49747,49748,49749,49750,49751,49752,49753, +49754,49755,49756,49757,49758,49759,49760,49761,49762,49763,49764,49765, +49766,49767,49768,49769,49770,49771,49772,49773,49774,49775,49776,49777, +49778,49779,49780,49781,49782,49783,49784,49785,49786,49787,49788,49789, +49790,49791,49792,49793,49794,49795,49796,49797,49798,49799,49800,49801, +49802,49803,49804,49805,49806,49807,49808,49809,49810,49811,49812,49813, +49814,49815,49816,49817,49818,49819,49820,49821,49822,49823,49824,49825, +49826,49827,49828,49829,49830,49831,49832,49833,49834,49835,49836,49837, +49838,49839,49840,49841,49842,49843,49844,49845,49846,49847,49848,49849, +49850,49851,49852,49853,49854,49855,49856,49857,49858,49859,49860,49861, +49862,49863,49864,49865,49866,49867,49868,49869,49870,49871,49872,49873, +49874,49875,49876,49877,49878,49879,49880,49881,49882,49883,49884,49885, +49886,49887,49888,49889,49890,49891,49892,49893,49894,49895,49896,49897, +49898,49899,49900,49901,49902,49903,49904,49905,49906,49907,49908,49909, +49910,49911,49912,49913,49914,49915,49916,49917,49918,49919,49920,49921, +49922,49923,49924,49925,49926,49927,49928,49929,49930,49931,49932,49933, +49934,49935,49936,49937,49938,49939,49940,49941,49942,49943,49944,49945, +49946,49947,49948,49949,49950,49951,49952,49953,49954,49955,49956,49957, +49958,49959,49960,49961,49962,49963,49964,49965,49966,49967,49968,49969, +49970,49971,49972,49973,49974,49975,49976,49977,49978,49979,49980,49981, +49982,49983,49984,49985,49986,49987,49988,49989,49990,49991,49992,49993, +49994,49995,49996,49997,49998,49999,50000,50001,50002,50003,50004,50005, +50006,50007,50008,50009,50010,50011,50012,50013,50014,50015,50016,50017, +50018,50019,50020,50021,50022,50023,50024,50025,50026,50027,50028,50029, +50030,50031,50032,50033,50034,50035,50036,50037,50038,50039,50040,50041, +50042,50043,50044,50045,50046,50047,50048,50049,50050,50051,50052,50053, +50054,50055,50056,50057,50058,50059,50060,50061,50062,50063,50064,50065, +50066,50067,50068,50069,50070,50071,50072,50073,50074,50075,50076,50077, +50078,50079,50080,50081,50082,50083,50084,50085,50086,50087,50088,50089, +50090,50091,50092,50093,50094,50095,50096,50097,50098,50099,50100,50101, +50102,50103,50104,50105,50106,50107,50108,50109,50110,50111,50112,50113, +50114,50115,50116,50117,50118,50119,50120,50121,50122,50123,50124,50125, +50126,50127,50128,50129,50130,50131,50132,50133,50134,50135,50136,50137, +50138,50139,50140,50141,50142,50143,50144,50145,50146,50147,50148,50149, +50150,50151,50152,50153,50154,50155,50156,50157,50158,50159,50160,50161, +50162,50163,50164,50165,50166,50167,50168,50169,50170,50171,50172,50173, +50174,50175,50176,50177,50178,50179,50180,50181,50182,50183,50184,50185, +50186,50187,50188,50189,50190,50191,50192,50193,50194,50195,50196,50197, +50198,50199,50200,50201,50202,50203,50204,50205,50206,50207,50208,50209, +50210,50211,50212,50213,50214,50215,50216,50217,50218,50219,50220,50221, +50222,50223,50224,50225,50226,50227,50228,50229,50230,50231,50232,50233, +50234,50235,50236,50237,50238,50239,50240,50241,50242,50243,50244,50245, +50246,50247,50248,50249,50250,50251,50252,50253,50254,50255,50256,50257, +50258,50259,50260,50261,50262,50263,50264,50265,50266,50267,50268,50269, +50270,50271,50272,50273,50274,50275,50276,50277,50278,50279,50280,50281, +50282,50283,50284,50285,50286,50287,50288,50289,50290,50291,50292,50293, +50294,50295,50296,50297,50298,50299,50300,50301,50302,50303,50304,50305, +50306,50307,50308,50309,50310,50311,50312,50313,50314,50315,50316,50317, +50318,50319,50320,50321,50322,50323,50324,50325,50326,50327,50328,50329, +50330,50331,50332,50333,50334,50335,50336,50337,50338,50339,50340,50341, +50342,50343,50344,50345,50346,50347,50348,50349,50350,50351,50352,50353, +50354,50355,50356,50357,50358,50359,50360,50361,50362,50363,50364,50365, +50366,50367,50368,50369,50370,50371,50372,50373,50374,50375,50376,50377, +50378,50379,50380,50381,50382,50383,50384,50385,50386,50387,50388,50389, +50390,50391,50392,50393,50394,50395,50396,50397,50398,50399,50400,50401, +50402,50403,50404,50405,50406,50407,50408,50409,50410,50411,50412,50413, +50414,50415,50416,50417,50418,50419,50420,50421,50422,50423,50424,50425, +50426,50427,50428,50429,50430,50431,50432,50433,50434,50435,50436,50437, +50438,50439,50440,50441,50442,50443,50444,50445,50446,50447,50448,50449, +50450,50451,50452,50453,50454,50455,50456,50457,50458,50459,50460,50461, +50462,50463,50464,50465,50466,50467,50468,50469,50470,50471,50472,50473, +50474,50475,50476,50477,50478,50479,50480,50481,50482,50483,50484,50485, +50486,50487,50488,50489,50490,50491,50492,50493,50494,50495,50496,50497, +50498,50499,50500,50501,50502,50503,50504,50505,50506,50507,50508,50509, +50510,50511,50512,50513,50514,50515,50516,50517,50518,50519,50520,50521, +50522,50523,50524,50525,50526,50527,50528,50529,50530,50531,50532,50533, +50534,50535,50536,50537,50538,50539,50540,50541,50542,50543,50544,50545, +50546,50547,50548,50549,50550,50551,50552,50553,50554,50555,50556,50557, +50558,50559,50560,50561,50562,50563,50564,50565,50566,50567,50568,50569, +50570,50571,50572,50573,50574,50575,50576,50577,50578,50579,50580,50581, +50582,50583,50584,50585,50586,50587,50588,50589,50590,50591,50592,50593, +50594,50595,50596,50597,50598,50599,50600,50601,50602,50603,50604,50605, +50606,50607,50608,50609,50610,50611,50612,50613,50614,50615,50616,50617, +50618,50619,50620,50621,50622,50623,50624,50625,50626,50627,50628,50629, +50630,50631,50632,50633,50634,50635,50636,50637,50638,50639,50640,50641, +50642,50643,50644,50645,50646,50647,50648,50649,50650,50651,50652,50653, +50654,50655,50656,50657,50658,50659,50660,50661,50662,50663,50664,50665, +50666,50667,50668,50669,50670,50671,50672,50673,50674,50675,50676,50677, +50678,50679,50680,50681,50682,50683,50684,50685,50686,50687,50688,50689, +50690,50691,50692,50693,50694,50695,50696,50697,50698,50699,50700,50701, +50702,50703,50704,50705,50706,50707,50708,50709,50710,50711,50712,50713, +50714,50715,50716,50717,50718,50719,50720,50721,50722,50723,50724,50725, +50726,50727,50728,50729,50730,50731,50732,50733,50734,50735,50736,50737, +50738,50739,50740,50741,50742,50743,50744,50745,50746,50747,50748,50749, +50750,50751,50752,50753,50754,50755,50756,50757,50758,50759,50760,50761, +50762,50763,50764,50765,50766,50767,50768,50769,50770,50771,50772,50773, +50774,50775,50776,50777,50778,50779,50780,50781,50782,50783,50784,50785, +50786,50787,50788,50789,50790,50791,50792,50793,50794,50795,50796,50797, +50798,50799,50800,50801,50802,50803,50804,50805,50806,50807,50808,50809, +50810,50811,50812,50813,50814,50815,50816,50817,50818,50819,50820,50821, +50822,50823,50824,50825,50826,50827,50828,50829,50830,50831,50832,50833, +50834,50835,50836,50837,50838,50839,50840,50841,50842,50843,50844,50845, +50846,50847,50848,50849,50850,50851,50852,50853,50854,50855,50856,50857, +50858,50859,50860,50861,50862,50863,50864,50865,50866,50867,50868,50869, +50870,50871,50872,50873,50874,50875,50876,50877,50878,50879,50880,50881, +50882,50883,50884,50885,50886,50887,50888,50889,50890,50891,50892,50893, +50894,50895,50896,50897,50898,50899,50900,50901,50902,50903,50904,50905, +50906,50907,50908,50909,50910,50911,50912,50913,50914,50915,50916,50917, +50918,50919,50920,50921,50922,50923,50924,50925,50926,50927,50928,50929, +50930,50931,50932,50933,50934,50935,50936,50937,50938,50939,50940,50941, +50942,50943,50944,50945,50946,50947,50948,50949,50950,50951,50952,50953, +50954,50955,50956,50957,50958,50959,50960,50961,50962,50963,50964,50965, +50966,50967,50968,50969,50970,50971,50972,50973,50974,50975,50976,50977, +50978,50979,50980,50981,50982,50983,50984,50985,50986,50987,50988,50989, +50990,50991,50992,50993,50994,50995,50996,50997,50998,50999,51000,51001, +51002,51003,51004,51005,51006,51007,51008,51009,51010,51011,51012,51013, +51014,51015,51016,51017,51018,51019,51020,51021,51022,51023,51024,51025, +51026,51027,51028,51029,51030,51031,51032,51033,51034,51035,51036,51037, +51038,51039,51040,51041,51042,51043,51044,51045,51046,51047,51048,51049, +51050,51051,51052,51053,51054,51055,51056,51057,51058,51059,51060,51061, +51062,51063,51064,51065,51066,51067,51068,51069,51070,51071,51072,51073, +51074,51075,51076,51077,51078,51079,51080,51081,51082,51083,51084,51085, +51086,51087,51088,51089,51090,51091,51092,51093,51094,51095,51096,51097, +51098,51099,51100,51101,51102,51103,51104,51105,51106,51107,51108,51109, +51110,51111,51112,51113,51114,51115,51116,51117,51118,51119,51120,51121, +51122,51123,51124,51125,51126,51127,51128,51129,51130,51131,51132,51133, +51134,51135,51136,51137,51138,51139,51140,51141,51142,51143,51144,51145, +51146,51147,51148,51149,51150,51151,51152,51153,51154,51155,51156,51157, +51158,51159,51160,51161,51162,51163,51164,51165,51166,51167,51168,51169, +51170,51171,51172,51173,51174,51175,51176,51177,51178,51179,51180,51181, +51182,51183,51184,51185,51186,51187,51188,51189,51190,51191,51192,51193, +51194,51195,51196,51197,51198,51199,51200,51201,51202,51203,51204,51205, +51206,51207,51208,51209,51210,51211,51212,51213,51214,51215,51216,51217, +51218,51219,51220,51221,51222,51223,51224,51225,51226,51227,51228,51229, +51230,51231,51232,51233,51234,51235,51236,51237,51238,51239,51240,51241, +51242,51243,51244,51245,51246,51247,51248,51249,51250,51251,51252,51253, +51254,51255,51256,51257,51258,51259,51260,51261,51262,51263,51264,51265, +51266,51267,51268,51269,51270,51271,51272,51273,51274,51275,51276,51277, +51278,51279,51280,51281,51282,51283,51284,51285,51286,51287,51288,51289, +51290,51291,51292,51293,51294,51295,51296,51297,51298,51299,51300,51301, +51302,51303,51304,51305,51306,51307,51308,51309,51310,51311,51312,51313, +51314,51315,51316,51317,51318,51319,51320,51321,51322,51323,51324,51325, +51326,51327,51328,51329,51330,51331,51332,51333,51334,51335,51336,51337, +51338,51339,51340,51341,51342,51343,51344,51345,51346,51347,51348,51349, +51350,51351,51352,51353,51354,51355,51356,51357,51358,51359,51360,51361, +51362,51363,51364,51365,51366,51367,51368,51369,51370,51371,51372,51373, +51374,51375,51376,51377,51378,51379,51380,51381,51382,51383,51384,51385, +51386,51387,51388,51389,51390,51391,51392,51393,51394,51395,51396,51397, +51398,51399,51400,51401,51402,51403,51404,51405,51406,51407,51408,51409, +51410,51411,51412,51413,51414,51415,51416,51417,51418,51419,51420,51421, +51422,51423,51424,51425,51426,51427,51428,51429,51430,51431,51432,51433, +51434,51435,51436,51437,51438,51439,51440,51441,51442,51443,51444,51445, +51446,51447,51448,51449,51450,51451,51452,51453,51454,51455,51456,51457, +51458,51459,51460,51461,51462,51463,51464,51465,51466,51467,51468,51469, +51470,51471,51472,51473,51474,51475,51476,51477,51478,51479,51480,51481, +51482,51483,51484,51485,51486,51487,51488,51489,51490,51491,51492,51493, +51494,51495,51496,51497,51498,51499,51500,51501,51502,51503,51504,51505, +51506,51507,51508,51509,51510,51511,51512,51513,51514,51515,51516,51517, +51518,51519,51520,51521,51522,51523,51524,51525,51526,51527,51528,51529, +51530,51531,51532,51533,51534,51535,51536,51537,51538,51539,51540,51541, +51542,51543,51544,51545,51546,51547,51548,51549,51550,51551,51552,51553, +51554,51555,51556,51557,51558,51559,51560,51561,51562,51563,51564,51565, +51566,51567,51568,51569,51570,51571,51572,51573,51574,51575,51576,51577, +51578,51579,51580,51581,51582,51583,51584,51585,51586,51587,51588,51589, +51590,51591,51592,51593,51594,51595,51596,51597,51598,51599,51600,51601, +51602,51603,51604,51605,51606,51607,51608,51609,51610,51611,51612,51613, +51614,51615,51616,51617,51618,51619,51620,51621,51622,51623,51624,51625, +51626,51627,51628,51629,51630,51631,51632,51633,51634,51635,51636,51637, +51638,51639,51640,51641,51642,51643,51644,51645,51646,51647,51648,51649, +51650,51651,51652,51653,51654,51655,51656,51657,51658,51659,51660,51661, +51662,51663,51664,51665,51666,51667,51668,51669,51670,51671,51672,51673, +51674,51675,51676,51677,51678,51679,51680,51681,51682,51683,51684,51685, +51686,51687,51688,51689,51690,51691,51692,51693,51694,51695,51696,51697, +51698,51699,51700,51701,51702,51703,51704,51705,51706,51707,51708,51709, +51710,51711,51712,51713,51714,51715,51716,51717,51718,51719,51720,51721, +51722,51723,51724,51725,51726,51727,51728,51729,51730,51731,51732,51733, +51734,51735,51736,51737,51738,51739,51740,51741,51742,51743,51744,51745, +51746,51747,51748,51749,51750,51751,51752,51753,51754,51755,51756,51757, +51758,51759,51760,51761,51762,51763,51764,51765,51766,51767,51768,51769, +51770,51771,51772,51773,51774,51775,51776,51777,51778,51779,51780,51781, +51782,51783,51784,51785,51786,51787,51788,51789,51790,51791,51792,51793, +51794,51795,51796,51797,51798,51799,51800,51801,51802,51803,51804,51805, +51806,51807,51808,51809,51810,51811,51812,51813,51814,51815,51816,51817, +51818,51819,51820,51821,51822,51823,51824,51825,51826,51827,51828,51829, +51830,51831,51832,51833,51834,51835,51836,51837,51838,51839,51840,51841, +51842,51843,51844,51845,51846,51847,51848,51849,51850,51851,51852,51853, +51854,51855,51856,51857,51858,51859,51860,51861,51862,51863,51864,51865, +51866,51867,51868,51869,51870,51871,51872,51873,51874,51875,51876,51877, +51878,51879,51880,51881,51882,51883,51884,51885,51886,51887,51888,51889, +51890,51891,51892,51893,51894,51895,51896,51897,51898,51899,51900,51901, +51902,51903,51904,51905,51906,51907,51908,51909,51910,51911,51912,51913, +51914,51915,51916,51917,51918,51919,51920,51921,51922,51923,51924,51925, +51926,51927,51928,51929,51930,51931,51932,51933,51934,51935,51936,51937, +51938,51939,51940,51941,51942,51943,51944,51945,51946,51947,51948,51949, +51950,51951,51952,51953,51954,51955,51956,51957,51958,51959,51960,51961, +51962,51963,51964,51965,51966,51967,51968,51969,51970,51971,51972,51973, +51974,51975,51976,51977,51978,51979,51980,51981,51982,51983,51984,51985, +51986,51987,51988,51989,51990,51991,51992,51993,51994,51995,51996,51997, +51998,51999,52000,52001,52002,52003,52004,52005,52006,52007,52008,52009, +52010,52011,52012,52013,52014,52015,52016,52017,52018,52019,52020,52021, +52022,52023,52024,52025,52026,52027,52028,52029,52030,52031,52032,52033, +52034,52035,52036,52037,52038,52039,52040,52041,52042,52043,52044,52045, +52046,52047,52048,52049,52050,52051,52052,52053,52054,52055,52056,52057, +52058,52059,52060,52061,52062,52063,52064,52065,52066,52067,52068,52069, +52070,52071,52072,52073,52074,52075,52076,52077,52078,52079,52080,52081, +52082,52083,52084,52085,52086,52087,52088,52089,52090,52091,52092,52093, +52094,52095,52096,52097,52098,52099,52100,52101,52102,52103,52104,52105, +52106,52107,52108,52109,52110,52111,52112,52113,52114,52115,52116,52117, +52118,52119,52120,52121,52122,52123,52124,52125,52126,52127,52128,52129, +52130,52131,52132,52133,52134,52135,52136,52137,52138,52139,52140,52141, +52142,52143,52144,52145,52146,52147,52148,52149,52150,52151,52152,52153, +52154,52155,52156,52157,52158,52159,52160,52161,52162,52163,52164,52165, +52166,52167,52168,52169,52170,52171,52172,52173,52174,52175,52176,52177, +52178,52179,52180,52181,52182,52183,52184,52185,52186,52187,52188,52189, +52190,52191,52192,52193,52194,52195,52196,52197,52198,52199,52200,52201, +52202,52203,52204,52205,52206,52207,52208,52209,52210,52211,52212,52213, +52214,52215,52216,52217,52218,52219,52220,52221,52222,52223,52224,52225, +52226,52227,52228,52229,52230,52231,52232,52233,52234,52235,52236,52237, +52238,52239,52240,52241,52242,52243,52244,52245,52246,52247,52248,52249, +52250,52251,52252,52253,52254,52255,52256,52257,52258,52259,52260,52261, +52262,52263,52264,52265,52266,52267,52268,52269,52270,52271,52272,52273, +52274,52275,52276,52277,52278,52279,52280,52281,52282,52283,52284,52285, +52286,52287,52288,52289,52290,52291,52292,52293,52294,52295,52296,52297, +52298,52299,52300,52301,52302,52303,52304,52305,52306,52307,52308,52309, +52310,52311,52312,52313,52314,52315,52316,52317,52318,52319,52320,52321, +52322,52323,52324,52325,52326,52327,52328,52329,52330,52331,52332,52333, +52334,52335,52336,52337,52338,52339,52340,52341,52342,52343,52344,52345, +52346,52347,52348,52349,52350,52351,52352,52353,52354,52355,52356,52357, +52358,52359,52360,52361,52362,52363,52364,52365,52366,52367,52368,52369, +52370,52371,52372,52373,52374,52375,52376,52377,52378,52379,52380,52381, +52382,52383,52384,52385,52386,52387,52388,52389,52390,52391,52392,52393, +52394,52395,52396,52397,52398,52399,52400,52401,52402,52403,52404,52405, +52406,52407,52408,52409,52410,52411,52412,52413,52414,52415,52416,52417, +52418,52419,52420,52421,52422,52423,52424,52425,52426,52427,52428,52429, +52430,52431,52432,52433,52434,52435,52436,52437,52438,52439,52440,52441, +52442,52443,52444,52445,52446,52447,52448,52449,52450,52451,52452,52453, +52454,52455,52456,52457,52458,52459,52460,52461,52462,52463,52464,52465, +52466,52467,52468,52469,52470,52471,52472,52473,52474,52475,52476,52477, +52478,52479,52480,52481,52482,52483,52484,52485,52486,52487,52488,52489, +52490,52491,52492,52493,52494,52495,52496,52497,52498,52499,52500,52501, +52502,52503,52504,52505,52506,52507,52508,52509,52510,52511,52512,52513, +52514,52515,52516,52517,52518,52519,52520,52521,52522,52523,52524,52525, +52526,52527,52528,52529,52530,52531,52532,52533,52534,52535,52536,52537, +52538,52539,52540,52541,52542,52543,52544,52545,52546,52547,52548,52549, +52550,52551,52552,52553,52554,52555,52556,52557,52558,52559,52560,52561, +52562,52563,52564,52565,52566,52567,52568,52569,52570,52571,52572,52573, +52574,52575,52576,52577,52578,52579,52580,52581,52582,52583,52584,52585, +52586,52587,52588,52589,52590,52591,52592,52593,52594,52595,52596,52597, +52598,52599,52600,52601,52602,52603,52604,52605,52606,52607,52608,52609, +52610,52611,52612,52613,52614,52615,52616,52617,52618,52619,52620,52621, +52622,52623,52624,52625,52626,52627,52628,52629,52630,52631,52632,52633, +52634,52635,52636,52637,52638,52639,52640,52641,52642,52643,52644,52645, +52646,52647,52648,52649,52650,52651,52652,52653,52654,52655,52656,52657, +52658,52659,52660,52661,52662,52663,52664,52665,52666,52667,52668,52669, +52670,52671,52672,52673,52674,52675,52676,52677,52678,52679,52680,52681, +52682,52683,52684,52685,52686,52687,52688,52689,52690,52691,52692,52693, +52694,52695,52696,52697,52698,52699,52700,52701,52702,52703,52704,52705, +52706,52707,52708,52709,52710,52711,52712,52713,52714,52715,52716,52717, +52718,52719,52720,52721,52722,52723,52724,52725,52726,52727,52728,52729, +52730,52731,52732,52733,52734,52735,52736,52737,52738,52739,52740,52741, +52742,52743,52744,52745,52746,52747,52748,52749,52750,52751,52752,52753, +52754,52755,52756,52757,52758,52759,52760,52761,52762,52763,52764,52765, +52766,52767,52768,52769,52770,52771,52772,52773,52774,52775,52776,52777, +52778,52779,52780,52781,52782,52783,52784,52785,52786,52787,52788,52789, +52790,52791,52792,52793,52794,52795,52796,52797,52798,52799,52800,52801, +52802,52803,52804,52805,52806,52807,52808,52809,52810,52811,52812,52813, +52814,52815,52816,52817,52818,52819,52820,52821,52822,52823,52824,52825, +52826,52827,52828,52829,52830,52831,52832,52833,52834,52835,52836,52837, +52838,52839,52840,52841,52842,52843,52844,52845,52846,52847,52848,52849, +52850,52851,52852,52853,52854,52855,52856,52857,52858,52859,52860,52861, +52862,52863,52864,52865,52866,52867,52868,52869,52870,52871,52872,52873, +52874,52875,52876,52877,52878,52879,52880,52881,52882,52883,52884,52885, +52886,52887,52888,52889,52890,52891,52892,52893,52894,52895,52896,52897, +52898,52899,52900,52901,52902,52903,52904,52905,52906,52907,52908,52909, +52910,52911,52912,52913,52914,52915,52916,52917,52918,52919,52920,52921, +52922,52923,52924,52925,52926,52927,52928,52929,52930,52931,52932,52933, +52934,52935,52936,52937,52938,52939,52940,52941,52942,52943,52944,52945, +52946,52947,52948,52949,52950,52951,52952,52953,52954,52955,52956,52957, +52958,52959,52960,52961,52962,52963,52964,52965,52966,52967,52968,52969, +52970,52971,52972,52973,52974,52975,52976,52977,52978,52979,52980,52981, +52982,52983,52984,52985,52986,52987,52988,52989,52990,52991,52992,52993, +52994,52995,52996,52997,52998,52999,53000,53001,53002,53003,53004,53005, +53006,53007,53008,53009,53010,53011,53012,53013,53014,53015,53016,53017, +53018,53019,53020,53021,53022,53023,53024,53025,53026,53027,53028,53029, +53030,53031,53032,53033,53034,53035,53036,53037,53038,53039,53040,53041, +53042,53043,53044,53045,53046,53047,53048,53049,53050,53051,53052,53053, +53054,53055,53056,53057,53058,53059,53060,53061,53062,53063,53064,53065, +53066,53067,53068,53069,53070,53071,53072,53073,53074,53075,53076,53077, +53078,53079,53080,53081,53082,53083,53084,53085,53086,53087,53088,53089, +53090,53091,53092,53093,53094,53095,53096,53097,53098,53099,53100,53101, +53102,53103,53104,53105,53106,53107,53108,53109,53110,53111,53112,53113, +53114,53115,53116,53117,53118,53119,53120,53121,53122,53123,53124,53125, +53126,53127,53128,53129,53130,53131,53132,53133,53134,53135,53136,53137, +53138,53139,53140,53141,53142,53143,53144,53145,53146,53147,53148,53149, +53150,53151,53152,53153,53154,53155,53156,53157,53158,53159,53160,53161, +53162,53163,53164,53165,53166,53167,53168,53169,53170,53171,53172,53173, +53174,53175,53176,53177,53178,53179,53180,53181,53182,53183,53184,53185, +53186,53187,53188,53189,53190,53191,53192,53193,53194,53195,53196,53197, +53198,53199,53200,53201,53202,53203,53204,53205,53206,53207,53208,53209, +53210,53211,53212,53213,53214,53215,53216,53217,53218,53219,53220,53221, +53222,53223,53224,53225,53226,53227,53228,53229,53230,53231,53232,53233, +53234,53235,53236,53237,53238,53239,53240,53241,53242,53243,53244,53245, +53246,53247,53248,53249,53250,53251,53252,53253,53254,53255,53256,53257, +53258,53259,53260,53261,53262,53263,53264,53265,53266,53267,53268,53269, +53270,53271,53272,53273,53274,53275,53276,53277,53278,53279,53280,53281, +53282,53283,53284,53285,53286,53287,53288,53289,53290,53291,53292,53293, +53294,53295,53296,53297,53298,53299,53300,53301,53302,53303,53304,53305, +53306,53307,53308,53309,53310,53311,53312,53313,53314,53315,53316,53317, +53318,53319,53320,53321,53322,53323,53324,53325,53326,53327,53328,53329, +53330,53331,53332,53333,53334,53335,53336,53337,53338,53339,53340,53341, +53342,53343,53344,53345,53346,53347,53348,53349,53350,53351,53352,53353, +53354,53355,53356,53357,53358,53359,53360,53361,53362,53363,53364,53365, +53366,53367,53368,53369,53370,53371,53372,53373,53374,53375,53376,53377, +53378,53379,53380,53381,53382,53383,53384,53385,53386,53387,53388,53389, +53390,53391,53392,53393,53394,53395,53396,53397,53398,53399,53400,53401, +53402,53403,53404,53405,53406,53407,53408,53409,53410,53411,53412,53413, +53414,53415,53416,53417,53418,53419,53420,53421,53422,53423,53424,53425, +53426,53427,53428,53429,53430,53431,53432,53433,53434,53435,53436,53437, +53438,53439,53440,53441,53442,53443,53444,53445,53446,53447,53448,53449, +53450,53451,53452,53453,53454,53455,53456,53457,53458,53459,53460,53461, +53462,53463,53464,53465,53466,53467,53468,53469,53470,53471,53472,53473, +53474,53475,53476,53477,53478,53479,53480,53481,53482,53483,53484,53485, +53486,53487,53488,53489,53490,53491,53492,53493,53494,53495,53496,53497, +53498,53499,53500,53501,53502,53503,53504,53505,53506,53507,53508,53509, +53510,53511,53512,53513,53514,53515,53516,53517,53518,53519,53520,53521, +53522,53523,53524,53525,53526,53527,53528,53529,53530,53531,53532,53533, +53534,53535,53536,53537,53538,53539,53540,53541,53542,53543,53544,53545, +53546,53547,53548,53549,53550,53551,53552,53553,53554,53555,53556,53557, +53558,53559,53560,53561,53562,53563,53564,53565,53566,53567,53568,53569, +53570,53571,53572,53573,53574,53575,53576,53577,53578,53579,53580,53581, +53582,53583,53584,53585,53586,53587,53588,53589,53590,53591,53592,53593, +53594,53595,53596,53597,53598,53599,53600,53601,53602,53603,53604,53605, +53606,53607,53608,53609,53610,53611,53612,53613,53614,53615,53616,53617, +53618,53619,53620,53621,53622,53623,53624,53625,53626,53627,53628,53629, +53630,53631,53632,53633,53634,53635,53636,53637,53638,53639,53640,53641, +53642,53643,53644,53645,53646,53647,53648,53649,53650,53651,53652,53653, +53654,53655,53656,53657,53658,53659,53660,53661,53662,53663,53664,53665, +53666,53667,53668,53669,53670,53671,53672,53673,53674,53675,53676,53677, +53678,53679,53680,53681,53682,53683,53684,53685,53686,53687,53688,53689, +53690,53691,53692,53693,53694,53695,53696,53697,53698,53699,53700,53701, +53702,53703,53704,53705,53706,53707,53708,53709,53710,53711,53712,53713, +53714,53715,53716,53717,53718,53719,53720,53721,53722,53723,53724,53725, +53726,53727,53728,53729,53730,53731,53732,53733,53734,53735,53736,53737, +53738,53739,53740,53741,53742,53743,53744,53745,53746,53747,53748,53749, +53750,53751,53752,53753,53754,53755,53756,53757,53758,53759,53760,53761, +53762,53763,53764,53765,53766,53767,53768,53769,53770,53771,53772,53773, +53774,53775,53776,53777,53778,53779,53780,53781,53782,53783,53784,53785, +53786,53787,53788,53789,53790,53791,53792,53793,53794,53795,53796,53797, +53798,53799,53800,53801,53802,53803,53804,53805,53806,53807,53808,53809, +53810,53811,53812,53813,53814,53815,53816,53817,53818,53819,53820,53821, +53822,53823,53824,53825,53826,53827,53828,53829,53830,53831,53832,53833, +53834,53835,53836,53837,53838,53839,53840,53841,53842,53843,53844,53845, +53846,53847,53848,53849,53850,53851,53852,53853,53854,53855,53856,53857, +53858,53859,53860,53861,53862,53863,53864,53865,53866,53867,53868,53869, +53870,53871,53872,53873,53874,53875,53876,53877,53878,53879,53880,53881, +53882,53883,53884,53885,53886,53887,53888,53889,53890,53891,53892,53893, +53894,53895,53896,53897,53898,53899,53900,53901,53902,53903,53904,53905, +53906,53907,53908,53909,53910,53911,53912,53913,53914,53915,53916,53917, +53918,53919,53920,53921,53922,53923,53924,53925,53926,53927,53928,53929, +53930,53931,53932,53933,53934,53935,53936,53937,53938,53939,53940,53941, +53942,53943,53944,53945,53946,53947,53948,53949,53950,53951,53952,53953, +53954,53955,53956,53957,53958,53959,53960,53961,53962,53963,53964,53965, +53966,53967,53968,53969,53970,53971,53972,53973,53974,53975,53976,53977, +53978,53979,53980,53981,53982,53983,53984,53985,53986,53987,53988,53989, +53990,53991,53992,53993,53994,53995,53996,53997,53998,53999,54000,54001, +54002,54003,54004,54005,54006,54007,54008,54009,54010,54011,54012,54013, +54014,54015,54016,54017,54018,54019,54020,54021,54022,54023,54024,54025, +54026,54027,54028,54029,54030,54031,54032,54033,54034,54035,54036,54037, +54038,54039,54040,54041,54042,54043,54044,54045,54046,54047,54048,54049, +54050,54051,54052,54053,54054,54055,54056,54057,54058,54059,54060,54061, +54062,54063,54064,54065,54066,54067,54068,54069,54070,54071,54072,54073, +54074,54075,54076,54077,54078,54079,54080,54081,54082,54083,54084,54085, +54086,54087,54088,54089,54090,54091,54092,54093,54094,54095,54096,54097, +54098,54099,54100,54101,54102,54103,54104,54105,54106,54107,54108,54109, +54110,54111,54112,54113,54114,54115,54116,54117,54118,54119,54120,54121, +54122,54123,54124,54125,54126,54127,54128,54129,54130,54131,54132,54133, +54134,54135,54136,54137,54138,54139,54140,54141,54142,54143,54144,54145, +54146,54147,54148,54149,54150,54151,54152,54153,54154,54155,54156,54157, +54158,54159,54160,54161,54162,54163,54164,54165,54166,54167,54168,54169, +54170,54171,54172,54173,54174,54175,54176,54177,54178,54179,54180,54181, +54182,54183,54184,54185,54186,54187,54188,54189,54190,54191,54192,54193, +54194,54195,54196,54197,54198,54199,54200,54201,54202,54203,54204,54205, +54206,54207,54208,54209,54210,54211,54212,54213,54214,54215,54216,54217, +54218,54219,54220,54221,54222,54223,54224,54225,54226,54227,54228,54229, +54230,54231,54232,54233,54234,54235,54236,54237,54238,54239,54240,54241, +54242,54243,54244,54245,54246,54247,54248,54249,54250,54251,54252,54253, +54254,54255,54256,54257,54258,54259,54260,54261,54262,54263,54264,54265, +54266,54267,54268,54269,54270,54271,54272,54273,54274,54275,54276,54277, +54278,54279,54280,54281,54282,54283,54284,54285,54286,54287,54288,54289, +54290,54291,54292,54293,54294,54295,54296,54297,54298,54299,54300,54301, +54302,54303,54304,54305,54306,54307,54308,54309,54310,54311,54312,54313, +54314,54315,54316,54317,54318,54319,54320,54321,54322,54323,54324,54325, +54326,54327,54328,54329,54330,54331,54332,54333,54334,54335,54336,54337, +54338,54339,54340,54341,54342,54343,54344,54345,54346,54347,54348,54349, +54350,54351,54352,54353,54354,54355,54356,54357,54358,54359,54360,54361, +54362,54363,54364,54365,54366,54367,54368,54369,54370,54371,54372,54373, +54374,54375,54376,54377,54378,54379,54380,54381,54382,54383,54384,54385, +54386,54387,54388,54389,54390,54391,54392,54393,54394,54395,54396,54397, +54398,54399,54400,54401,54402,54403,54404,54405,54406,54407,54408,54409, +54410,54411,54412,54413,54414,54415,54416,54417,54418,54419,54420,54421, +54422,54423,54424,54425,54426,54427,54428,54429,54430,54431,54432,54433, +54434,54435,54436,54437,54438,54439,54440,54441,54442,54443,54444,54445, +54446,54447,54448,54449,54450,54451,54452,54453,54454,54455,54456,54457, +54458,54459,54460,54461,54462,54463,54464,54465,54466,54467,54468,54469, +54470,54471,54472,54473,54474,54475,54476,54477,54478,54479,54480,54481, +54482,54483,54484,54485,54486,54487,54488,54489,54490,54491,54492,54493, +54494,54495,54496,54497,54498,54499,54500,54501,54502,54503,54504,54505, +54506,54507,54508,54509,54510,54511,54512,54513,54514,54515,54516,54517, +54518,54519,54520,54521,54522,54523,54524,54525,54526,54527,54528,54529, +54530,54531,54532,54533,54534,54535,54536,54537,54538,54539,54540,54541, +54542,54543,54544,54545,54546,54547,54548,54549,54550,54551,54552,54553, +54554,54555,54556,54557,54558,54559,54560,54561,54562,54563,54564,54565, +54566,54567,54568,54569,54570,54571,54572,54573,54574,54575,54576,54577, +54578,54579,54580,54581,54582,54583,54584,54585,54586,54587,54588,54589, +54590,54591,54592,54593,54594,54595,54596,54597,54598,54599,54600,54601, +54602,54603,54604,54605,54606,54607,54608,54609,54610,54611,54612,54613, +54614,54615,54616,54617,54618,54619,54620,54621,54622,54623,54624,54625, +54626,54627,54628,54629,54630,54631,54632,54633,54634,54635,54636,54637, +54638,54639,54640,54641,54642,54643,54644,54645,54646,54647,54648,54649, +54650,54651,54652,54653,54654,54655,54656,54657,54658,54659,54660,54661, +54662,54663,54664,54665,54666,54667,54668,54669,54670,54671,54672,54673, +54674,54675,54676,54677,54678,54679,54680,54681,54682,54683,54684,54685, +54686,54687,54688,54689,54690,54691,54692,54693,54694,54695,54696,54697, +54698,54699,54700,54701,54702,54703,54704,54705,54706,54707,54708,54709, +54710,54711,54712,54713,54714,54715,54716,54717,54718,54719,54720,54721, +54722,54723,54724,54725,54726,54727,54728,54729,54730,54731,54732,54733, +54734,54735,54736,54737,54738,54739,54740,54741,54742,54743,54744,54745, +54746,54747,54748,54749,54750,54751,54752,54753,54754,54755,54756,54757, +54758,54759,54760,54761,54762,54763,54764,54765,54766,54767,54768,54769, +54770,54771,54772,54773,54774,54775,54776,54777,54778,54779,54780,54781, +54782,54783,54784,54785,54786,54787,54788,54789,54790,54791,54792,54793, +54794,54795,54796,54797,54798,54799,54800,54801,54802,54803,54804,54805, +54806,54807,54808,54809,54810,54811,54812,54813,54814,54815,54816,54817, +54818,54819,54820,54821,54822,54823,54824,54825,54826,54827,54828,54829, +54830,54831,54832,54833,54834,54835,54836,54837,54838,54839,54840,54841, +54842,54843,54844,54845,54846,54847,54848,54849,54850,54851,54852,54853, +54854,54855,54856,54857,54858,54859,54860,54861,54862,54863,54864,54865, +54866,54867,54868,54869,54870,54871,54872,54873,54874,54875,54876,54877, +54878,54879,54880,54881,54882,54883,54884,54885,54886,54887,54888,54889, +54890,54891,54892,54893,54894,54895,54896,54897,54898,54899,54900,54901, +54902,54903,54904,54905,54906,54907,54908,54909,54910,54911,54912,54913, +54914,54915,54916,54917,54918,54919,54920,54921,54922,54923,54924,54925, +54926,54927,54928,54929,54930,54931,54932,54933,54934,54935,54936,54937, +54938,54939,54940,54941,54942,54943,54944,54945,54946,54947,54948,54949, +54950,54951,54952,54953,54954,54955,54956,54957,54958,54959,54960,54961, +54962,54963,54964,54965,54966,54967,54968,54969,54970,54971,54972,54973, +54974,54975,54976,54977,54978,54979,54980,54981,54982,54983,54984,54985, +54986,54987,54988,54989,54990,54991,54992,54993,54994,54995,54996,54997, +54998,54999,55000,55001,55002,55003,55004,55005,55006,55007,55008,55009, +55010,55011,55012,55013,55014,55015,55016,55017,55018,55019,55020,55021, +55022,55023,55024,55025,55026,55027,55028,55029,55030,55031,55032,55033, +55034,55035,55036,55037,55038,55039,55040,55041,55042,55043,55044,55045, +55046,55047,55048,55049,55050,55051,55052,55053,55054,55055,55056,55057, +55058,55059,55060,55061,55062,55063,55064,55065,55066,55067,55068,55069, +55070,55071,55072,55073,55074,55075,55076,55077,55078,55079,55080,55081, +55082,55083,55084,55085,55086,55087,55088,55089,55090,55091,55092,55093, +55094,55095,55096,55097,55098,55099,55100,55101,55102,55103,55104,55105, +55106,55107,55108,55109,55110,55111,55112,55113,55114,55115,55116,55117, +55118,55119,55120,55121,55122,55123,55124,55125,55126,55127,55128,55129, +55130,55131,55132,55133,55134,55135,55136,55137,55138,55139,55140,55141, +55142,55143,55144,55145,55146,55147,55148,55149,55150,55151,55152,55153, +55154,55155,55156,55157,55158,55159,55160,55161,55162,55163,55164,55165, +55166,55167,55168,55169,55170,55171,55172,55173,55174,55175,55176,55177, +55178,55179,55180,55181,55182,55183,55184,55185,55186,55187,55188,55189, +55190,55191,55192,55193,55194,55195,55196,55197,55198,55199,55200,55201, +55202,55203,55204,55205,55206,55207,55208,55209,55210,55211,55212,55213, +55214,55215,55216,55217,55218,55219,55220,55221,55222,55223,55224,55225, +55226,55227,55228,55229,55230,55231,55232,55233,55234,55235,55236,55237, +55238,55239,55240,55241,55242,55243,55244,55245,55246,55247,55248,55249, +55250,55251,55252,55253,55254,55255,55256,55257,55258,55259,55260,55261, +55262,55263,55264,55265,55266,55267,55268,55269,55270,55271,55272,55273, +55274,55275,55276,55277,55278,55279,55280,55281,55282,55283,55284,55285, +55286,55287,55288,55289,55290,55291,55292,55293,55294,55295,55296,55297, +55298,55299,55300,55301,55302,55303,55304,55305,55306,55307,55308,55309, +55310,55311,55312,55313,55314,55315,55316,55317,55318,55319,55320,55321, +55322,55323,55324,55325,55326,55327,55328,55329,55330,55331,55332,55333, +55334,55335,55336,55337,55338,55339,55340,55341,55342,55343,55344,55345, +55346,55347,55348,55349,55350,55351,55352,55353,55354,55355,55356,55357, +55358,55359,55360,55361,55362,55363,55364,55365,55366,55367,55368,55369, +55370,55371,55372,55373,55374,55375,55376,55377,55378,55379,55380,55381, +55382,55383,55384,55385,55386,55387,55388,55389,55390,55391,55392,55393, +55394,55395,55396,55397,55398,55399,55400,55401,55402,55403,55404,55405, +55406,55407,55408,55409,55410,55411,55412,55413,55414,55415,55416,55417, +55418,55419,55420,55421,55422,55423,55424,55425,55426,55427,55428,55429, +55430,55431,55432,55433,55434,55435,55436,55437,55438,55439,55440,55441, +55442,55443,55444,55445,55446,55447,55448,55449,55450,55451,55452,55453, +55454,55455,55456,55457,55458,55459,55460,55461,55462,55463,55464,55465, +55466,55467,55468,55469,55470,55471,55472,55473,55474,55475,55476,55477, +55478,55479,55480,55481,55482,55483,55484,55485,55486,55487,55488,55489, +55490,55491,55492,55493,55494,55495,55496,55497,55498,55499,55500,55501, +55502,55503,55504,55505,55506,55507,55508,55509,55510,55511,55512,55513, +55514,55515,55516,55517,55518,55519,55520,55521,55522,55523,55524,55525, +55526,55527,55528,55529,55530,55531,55532,55533,55534,55535,55536,55537, +55538,55539,55540,55541,55542,55543,55544,55545,55546,55547,55548,55549, +55550,55551,55552,55553,55554,55555,55556,55557,55558,55559,55560,55561, +55562,55563,55564,55565,55566,55567,55568,55569,55570,55571,55572,55573, +55574,55575,55576,55577,55578,55579,55580,55581,55582,55583,55584,55585, +55586,55587,55588,55589,55590,55591,55592,55593,55594,55595,55596,55597, +55598,55599,55600,55601,55602,55603,55604,55605,55606,55607,55608,55609, +55610,55611,55612,55613,55614,55615,55616,55617,55618,55619,55620,55621, +55622,55623,55624,55625,55626,55627,55628,55629,55630,55631,55632,55633, +55634,55635,55636,55637,55638,55639,55640,55641,55642,55643,55644,55645, +55646,55647,55648,55649,55650,55651,55652,55653,55654,55655,55656,55657, +55658,55659,55660,55661,55662,55663,55664,55665,55666,55667,55668,55669, +55670,55671,55672,55673,55674,55675,55676,55677,55678,55679,55680,55681, +55682,55683,55684,55685,55686,55687,55688,55689,55690,55691,55692,55693, +55694,55695,55696,55697,55698,55699,55700,55701,55702,55703,55704,55705, +55706,55707,55708,55709,55710,55711,55712,55713,55714,55715,55716,55717, +55718,55719,55720,55721,55722,55723,55724,55725,55726,55727,55728,55729, +55730,55731,55732,55733,55734,55735,55736,55737,55738,55739,55740,55741, +55742,55743,55744,55745,55746,55747,55748,55749,55750,55751,55752,55753, +55754,55755,55756,55757,55758,55759,55760,55761,55762,55763,55764,55765, +55766,55767,55768,55769,55770,55771,55772,55773,55774,55775,55776,55777, +55778,55779,55780,55781,55782,55783,55784,55785,55786,55787,55788,55789, +55790,55791,55792,55793,55794,55795,55796,55797,55798,55799,55800,55801, +55802,55803,55804,55805,55806,55807,55808,55809,55810,55811,55812,55813, +55814,55815,55816,55817,55818,55819,55820,55821,55822,55823,55824,55825, +55826,55827,55828,55829,55830,55831,55832,55833,55834,55835,55836,55837, +55838,55839,55840,55841,55842,55843,55844,55845,55846,55847,55848,55849, +55850,55851,55852,55853,55854,55855,55856,55857,55858,55859,55860,55861, +55862,55863,55864,55865,55866,55867,55868,55869,55870,55871,55872,55873, +55874,55875,55876,55877,55878,55879,55880,55881,55882,55883,55884,55885, +55886,55887,55888,55889,55890,55891,55892,55893,55894,55895,55896,55897, +55898,55899,55900,55901,55902,55903,55904,55905,55906,55907,55908,55909, +55910,55911,55912,55913,55914,55915,55916,55917,55918,55919,55920,55921, +55922,55923,55924,55925,55926,55927,55928,55929,55930,55931,55932,55933, +55934,55935,55936,55937,55938,55939,55940,55941,55942,55943,55944,55945, +55946,55947,55948,55949,55950,55951,55952,55953,55954,55955,55956,55957, +55958,55959,55960,55961,55962,55963,55964,55965,55966,55967,55968,55969, +55970,55971,55972,55973,55974,55975,55976,55977,55978,55979,55980,55981, +55982,55983,55984,55985,55986,55987,55988,55989,55990,55991,55992,55993, +55994,55995,55996,55997,55998,55999,56000,56001,56002,56003,56004,56005, +56006,56007,56008,56009,56010,56011,56012,56013,56014,56015,56016,56017, +56018,56019,56020,56021,56022,56023,56024,56025,56026,56027,56028,56029, +56030,56031,56032,56033,56034,56035,56036,56037,56038,56039,56040,56041, +56042,56043,56044,56045,56046,56047,56048,56049,56050,56051,56052,56053, +56054,56055,56056,56057,56058,56059,56060,56061,56062,56063,56064,56065, +56066,56067,56068,56069,56070,56071,56072,56073,56074,56075,56076,56077, +56078,56079,56080,56081,56082,56083,56084,56085,56086,56087,56088,56089, +56090,56091,56092,56093,56094,56095,56096,56097,56098,56099,56100,56101, +56102,56103,56104,56105,56106,56107,56108,56109,56110,56111,56112,56113, +56114,56115,56116,56117,56118,56119,56120,56121,56122,56123,56124,56125, +56126,56127,56128,56129,56130,56131,56132,56133,56134,56135,56136,56137, +56138,56139,56140,56141,56142,56143,56144,56145,56146,56147,56148,56149, +56150,56151,56152,56153,56154,56155,56156,56157,56158,56159,56160,56161, +56162,56163,56164,56165,56166,56167,56168,56169,56170,56171,56172,56173, +56174,56175,56176,56177,56178,56179,56180,56181,56182,56183,56184,56185, +56186,56187,56188,56189,56190,56191,56192,56193,56194,56195,56196,56197, +56198,56199,56200,56201,56202,56203,56204,56205,56206,56207,56208,56209, +56210,56211,56212,56213,56214,56215,56216,56217,56218,56219,56220,56221, +56222,56223,56224,56225,56226,56227,56228,56229,56230,56231,56232,56233, +56234,56235,56236,56237,56238,56239,56240,56241,56242,56243,56244,56245, +56246,56247,56248,56249,56250,56251,56252,56253,56254,56255,56256,56257, +56258,56259,56260,56261,56262,56263,56264,56265,56266,56267,56268,56269, +56270,56271,56272,56273,56274,56275,56276,56277,56278,56279,56280,56281, +56282,56283,56284,56285,56286,56287,56288,56289,56290,56291,56292,56293, +56294,56295,56296,56297,56298,56299,56300,56301,56302,56303,56304,56305, +56306,56307,56308,56309,56310,56311,56312,56313,56314,56315,56316,56317, +56318,56319,56320,56321,56322,56323,56324,56325,56326,56327,56328,56329, +56330,56331,56332,56333,56334,56335,56336,56337,56338,56339,56340,56341, +56342,56343,56344,56345,56346,56347,56348,56349,56350,56351,56352,56353, +56354,56355,56356,56357,56358,56359,56360,56361,56362,56363,56364,56365, +56366,56367,56368,56369,56370,56371,56372,56373,56374,56375,56376,56377, +56378,56379,56380,56381,56382,56383,56384,56385,56386,56387,56388,56389, +56390,56391,56392,56393,56394,56395,56396,56397,56398,56399,56400,56401, +56402,56403,56404,56405,56406,56407,56408,56409,56410,56411,56412,56413, +56414,56415,56416,56417,56418,56419,56420,56421,56422,56423,56424,56425, +56426,56427,56428,56429,56430,56431,56432,56433,56434,56435,56436,56437, +56438,56439,56440,56441,56442,56443,56444,56445,56446,56447,56448,56449, +56450,56451,56452,56453,56454,56455,56456,56457,56458,56459,56460,56461, +56462,56463,56464,56465,56466,56467,56468,56469,56470,56471,56472,56473, +56474,56475,56476,56477,56478,56479,56480,56481,56482,56483,56484,56485, +56486,56487,56488,56489,56490,56491,56492,56493,56494,56495,56496,56497, +56498,56499,56500,56501,56502,56503,56504,56505,56506,56507,56508,56509, +56510,56511,56512,56513,56514,56515,56516,56517,56518,56519,56520,56521, +56522,56523,56524,56525,56526,56527,56528,56529,56530,56531,56532,56533, +56534,56535,56536,56537,56538,56539,56540,56541,56542,56543,56544,56545, +56546,56547,56548,56549,56550,56551,56552,56553,56554,56555,56556,56557, +56558,56559,56560,56561,56562,56563,56564,56565,56566,56567,56568,56569, +56570,56571,56572,56573,56574,56575,56576,56577,56578,56579,56580,56581, +56582,56583,56584,56585,56586,56587,56588,56589,56590,56591,56592,56593, +56594,56595,56596,56597,56598,56599,56600,56601,56602,56603,56604,56605, +56606,56607,56608,56609,56610,56611,56612,56613,56614,56615,56616,56617, +56618,56619,56620,56621,56622,56623,56624,56625,56626,56627,56628,56629, +56630,56631,56632,56633,56634,56635,56636,56637,56638,56639,56640,56641, +56642,56643,56644,56645,56646,56647,56648,56649,56650,56651,56652,56653, +56654,56655,56656,56657,56658,56659,56660,56661,56662,56663,56664,56665, +56666,56667,56668,56669,56670,56671,56672,56673,56674,56675,56676,56677, +56678,56679,56680,56681,56682,56683,56684,56685,56686,56687,56688,56689, +56690,56691,56692,56693,56694,56695,56696,56697,56698,56699,56700,56701, +56702,56703,56704,56705,56706,56707,56708,56709,56710,56711,56712,56713, +56714,56715,56716,56717,56718,56719,56720,56721,56722,56723,56724,56725, +56726,56727,56728,56729,56730,56731,56732,56733,56734,56735,56736,56737, +56738,56739,56740,56741,56742,56743,56744,56745,56746,56747,56748,56749, +56750,56751,56752,56753,56754,56755,56756,56757,56758,56759,56760,56761, +56762,56763,56764,56765,56766,56767,56768,56769,56770,56771,56772,56773, +56774,56775,56776,56777,56778,56779,56780,56781,56782,56783,56784,56785, +56786,56787,56788,56789,56790,56791,56792,56793,56794,56795,56796,56797, +56798,56799,56800,56801,56802,56803,56804,56805,56806,56807,56808,56809, +56810,56811,56812,56813,56814,56815,56816,56817,56818,56819,56820,56821, +56822,56823,56824,56825,56826,56827,56828,56829,56830,56831,56832,56833, +56834,56835,56836,56837,56838,56839,56840,56841,56842,56843,56844,56845, +56846,56847,56848,56849,56850,56851,56852,56853,56854,56855,56856,56857, +56858,56859,56860,56861,56862,56863,56864,56865,56866,56867,56868,56869, +56870,56871,56872,56873,56874,56875,56876,56877,56878,56879,56880,56881, +56882,56883,56884,56885,56886,56887,56888,56889,56890,56891,56892,56893, +56894,56895,56896,56897,56898,56899,56900,56901,56902,56903,56904,56905, +56906,56907,56908,56909,56910,56911,56912,56913,56914,56915,56916,56917, +56918,56919,56920,56921,56922,56923,56924,56925,56926,56927,56928,56929, +56930,56931,56932,56933,56934,56935,56936,56937,56938,56939,56940,56941, +56942,56943,56944,56945,56946,56947,56948,56949,56950,56951,56952,56953, +56954,56955,56956,56957,56958,56959,56960,56961,56962,56963,56964,56965, +56966,56967,56968,56969,56970,56971,56972,56973,56974,56975,56976,56977, +56978,56979,56980,56981,56982,56983,56984,56985,56986,56987,56988,56989, +56990,56991,56992,56993,56994,56995,56996,56997,56998,56999,57000,57001, +57002,57003,57004,57005,57006,57007,57008,57009,57010,57011,57012,57013, +57014,57015,57016,57017,57018,57019,57020,57021,57022,57023,57024,57025, +57026,57027,57028,57029,57030,57031,57032,57033,57034,57035,57036,57037, +57038,57039,57040,57041,57042,57043,57044,57045,57046,57047,57048,57049, +57050,57051,57052,57053,57054,57055,57056,57057,57058,57059,57060,57061, +57062,57063,57064,57065,57066,57067,57068,57069,57070,57071,57072,57073, +57074,57075,57076,57077,57078,57079,57080,57081,57082,57083,57084,57085, +57086,57087,57088,57089,57090,57091,57092,57093,57094,57095,57096,57097, +57098,57099,57100,57101,57102,57103,57104,57105,57106,57107,57108,57109, +57110,57111,57112,57113,57114,57115,57116,57117,57118,57119,57120,57121, +57122,57123,57124,57125,57126,57127,57128,57129,57130,57131,57132,57133, +57134,57135,57136,57137,57138,57139,57140,57141,57142,57143,57144,57145, +57146,57147,57148,57149,57150,57151,57152,57153,57154,57155,57156,57157, +57158,57159,57160,57161,57162,57163,57164,57165,57166,57167,57168,57169, +57170,57171,57172,57173,57174,57175,57176,57177,57178,57179,57180,57181, +57182,57183,57184,57185,57186,57187,57188,57189,57190,57191,57192,57193, +57194,57195,57196,57197,57198,57199,57200,57201,57202,57203,57204,57205, +57206,57207,57208,57209,57210,57211,57212,57213,57214,57215,57216,57217, +57218,57219,57220,57221,57222,57223,57224,57225,57226,57227,57228,57229, +57230,57231,57232,57233,57234,57235,57236,57237,57238,57239,57240,57241, +57242,57243,57244,57245,57246,57247,57248,57249,57250,57251,57252,57253, +57254,57255,57256,57257,57258,57259,57260,57261,57262,57263,57264,57265, +57266,57267,57268,57269,57270,57271,57272,57273,57274,57275,57276,57277, +57278,57279,57280,57281,57282,57283,57284,57285,57286,57287,57288,57289, +57290,57291,57292,57293,57294,57295,57296,57297,57298,57299,57300,57301, +57302,57303,57304,57305,57306,57307,57308,57309,57310,57311,57312,57313, +57314,57315,57316,57317,57318,57319,57320,57321,57322,57323,57324,57325, +57326,57327,57328,57329,57330,57331,57332,57333,57334,57335,57336,57337, +57338,57339,57340,57341,57342,57343,57344,57345,57346,57347,57348,57349, +57350,57351,57352,57353,57354,57355,57356,57357,57358,57359,57360,57361, +57362,57363,57364,57365,57366,57367,57368,57369,57370,57371,57372,57373, +57374,57375,57376,57377,57378,57379,57380,57381,57382,57383,57384,57385, +57386,57387,57388,57389,57390,57391,57392,57393,57394,57395,57396,57397, +57398,57399,57400,57401,57402,57403,57404,57405,57406,57407,57408,57409, +57410,57411,57412,57413,57414,57415,57416,57417,57418,57419,57420,57421, +57422,57423,57424,57425,57426,57427,57428,57429,57430,57431,57432,57433, +57434,57435,57436,57437,57438,57439,57440,57441,57442,57443,57444,57445, +57446,57447,57448,57449,57450,57451,57452,57453,57454,57455,57456,57457, +57458,57459,57460,57461,57462,57463,57464,57465,57466,57467,57468,57469, +57470,57471,57472,57473,57474,57475,57476,57477,57478,57479,57480,57481, +57482,57483,57484,57485,57486,57487,57488,57489,57490,57491,57492,57493, +57494,57495,57496,57497,57498,57499,57500,57501,57502,57503,57504,57505, +57506,57507,57508,57509,57510,57511,57512,57513,57514,57515,57516,57517, +57518,57519,57520,57521,57522,57523,57524,57525,57526,57527,57528,57529, +57530,57531,57532,57533,57534,57535,57536,57537,57538,57539,57540,57541, +57542,57543,57544,57545,57546,57547,57548,57549,57550,57551,57552,57553, +57554,57555,57556,57557,57558,57559,57560,57561,57562,57563,57564,57565, +57566,57567,57568,57569,57570,57571,57572,57573,57574,57575,57576,57577, +57578,57579,57580,57581,57582,57583,57584,57585,57586,57587,57588,57589, +57590,57591,57592,57593,57594,57595,57596,57597,57598,57599,57600,57601, +57602,57603,57604,57605,57606,57607,57608,57609,57610,57611,57612,57613, +57614,57615,57616,57617,57618,57619,57620,57621,57622,57623,57624,57625, +57626,57627,57628,57629,57630,57631,57632,57633,57634,57635,57636,57637, +57638,57639,57640,57641,57642,57643,57644,57645,57646,57647,57648,57649, +57650,57651,57652,57653,57654,57655,57656,57657,57658,57659,57660,57661, +57662,57663,57664,57665,57666,57667,57668,57669,57670,57671,57672,57673, +57674,57675,57676,57677,57678,57679,57680,57681,57682,57683,57684,57685, +57686,57687,57688,57689,57690,57691,57692,57693,57694,57695,57696,57697, +57698,57699,57700,57701,57702,57703,57704,57705,57706,57707,57708,57709, +57710,57711,57712,57713,57714,57715,57716,57717,57718,57719,57720,57721, +57722,57723,57724,57725,57726,57727,57728,57729,57730,57731,57732,57733, +57734,57735,57736,57737,57738,57739,57740,57741,57742,57743,57744,57745, +57746,57747,57748,57749,57750,57751,57752,57753,57754,57755,57756,57757, +57758,57759,57760,57761,57762,57763,57764,57765,57766,57767,57768,57769, +57770,57771,57772,57773,57774,57775,57776,57777,57778,57779,57780,57781, +57782,57783,57784,57785,57786,57787,57788,57789,57790,57791,57792,57793, +57794,57795,57796,57797,57798,57799,57800,57801,57802,57803,57804,57805, +57806,57807,57808,57809,57810,57811,57812,57813,57814,57815,57816,57817, +57818,57819,57820,57821,57822,57823,57824,57825,57826,57827,57828,57829, +57830,57831,57832,57833,57834,57835,57836,57837,57838,57839,57840,57841, +57842,57843,57844,57845,57846,57847,57848,57849,57850,57851,57852,57853, +57854,57855,57856,57857,57858,57859,57860,57861,57862,57863,57864,57865, +57866,57867,57868,57869,57870,57871,57872,57873,57874,57875,57876,57877, +57878,57879,57880,57881,57882,57883,57884,57885,57886,57887,57888,57889, +57890,57891,57892,57893,57894,57895,57896,57897,57898,57899,57900,57901, +57902,57903,57904,57905,57906,57907,57908,57909,57910,57911,57912,57913, +57914,57915,57916,57917,57918,57919,57920,57921,57922,57923,57924,57925, +57926,57927,57928,57929,57930,57931,57932,57933,57934,57935,57936,57937, +57938,57939,57940,57941,57942,57943,57944,57945,57946,57947,57948,57949, +57950,57951,57952,57953,57954,57955,57956,57957,57958,57959,57960,57961, +57962,57963,57964,57965,57966,57967,57968,57969,57970,57971,57972,57973, +57974,57975,57976,57977,57978,57979,57980,57981,57982,57983,57984,57985, +57986,57987,57988,57989,57990,57991,57992,57993,57994,57995,57996,57997, +57998,57999,58000,58001,58002,58003,58004,58005,58006,58007,58008,58009, +58010,58011,58012,58013,58014,58015,58016,58017,58018,58019,58020,58021, +58022,58023,58024,58025,58026,58027,58028,58029,58030,58031,58032,58033, +58034,58035,58036,58037,58038,58039,58040,58041,58042,58043,58044,58045, +58046,58047,58048,58049,58050,58051,58052,58053,58054,58055,58056,58057, +58058,58059,58060,58061,58062,58063,58064,58065,58066,58067,58068,58069, +58070,58071,58072,58073,58074,58075,58076,58077,58078,58079,58080,58081, +58082,58083,58084,58085,58086,58087,58088,58089,58090,58091,58092,58093, +58094,58095,58096,58097,58098,58099,58100,58101,58102,58103,58104,58105, +58106,58107,58108,58109,58110,58111,58112,58113,58114,58115,58116,58117, +58118,58119,58120,58121,58122,58123,58124,58125,58126,58127,58128,58129, +58130,58131,58132,58133,58134,58135,58136,58137,58138,58139,58140,58141, +58142,58143,58144,58145,58146,58147,58148,58149,58150,58151,58152,58153, +58154,58155,58156,58157,58158,58159,58160,58161,58162,58163,58164,58165, +58166,58167,58168,58169,58170,58171,58172,58173,58174,58175,58176,58177, +58178,58179,58180,58181,58182,58183,58184,58185,58186,58187,58188,58189, +58190,58191,58192,58193,58194,58195,58196,58197,58198,58199,58200,58201, +58202,58203,58204,58205,58206,58207,58208,58209,58210,58211,58212,58213, +58214,58215,58216,58217,58218,58219,58220,58221,58222,58223,58224,58225, +58226,58227,58228,58229,58230,58231,58232,58233,58234,58235,58236,58237, +58238,58239,58240,58241,58242,58243,58244,58245,58246,58247,58248,58249, +58250,58251,58252,58253,58254,58255,58256,58257,58258,58259,58260,58261, +58262,58263,58264,58265,58266,58267,58268,58269,58270,58271,58272,58273, +58274,58275,58276,58277,58278,58279,58280,58281,58282,58283,58284,58285, +58286,58287,58288,58289,58290,58291,58292,58293,58294,58295,58296,58297, +58298,58299,58300,58301,58302,58303,58304,58305,58306,58307,58308,58309, +58310,58311,58312,58313,58314,58315,58316,58317,58318,58319,58320,58321, +58322,58323,58324,58325,58326,58327,58328,58329,58330,58331,58332,58333, +58334,58335,58336,58337,58338,58339,58340,58341,58342,58343,58344,58345, +58346,58347,58348,58349,58350,58351,58352,58353,58354,58355,58356,58357, +58358,58359,58360,58361,58362,58363,58364,58365,58366,58367,58368,58369, +58370,58371,58372,58373,58374,58375,58376,58377,58378,58379,58380,58381, +58382,58383,58384,58385,58386,58387,58388,58389,58390,58391,58392,58393, +58394,58395,58396,58397,58398,58399,58400,58401,58402,58403,58404,58405, +58406,58407,58408,58409,58410,58411,58412,58413,58414,58415,58416,58417, +58418,58419,58420,58421,58422,58423,58424,58425,58426,58427,58428,58429, +58430,58431,58432,58433,58434,58435,58436,58437,58438,58439,58440,58441, +58442,58443,58444,58445,58446,58447,58448,58449,58450,58451,58452,58453, +58454,58455,58456,58457,58458,58459,58460,58461,58462,58463,58464,58465, +58466,58467,58468,58469,58470,58471,58472,58473,58474,58475,58476,58477, +58478,58479,58480,58481,58482,58483,58484,58485,58486,58487,58488,58489, +58490,58491,58492,58493,58494,58495,58496,58497,58498,58499,58500,58501, +58502,58503,58504,58505,58506,58507,58508,58509,58510,58511,58512,58513, +58514,58515,58516,58517,58518,58519,58520,58521,58522,58523,58524,58525, +58526,58527,58528,58529,58530,58531,58532,58533,58534,58535,58536,58537, +58538,58539,58540,58541,58542,58543,58544,58545,58546,58547,58548,58549, +58550,58551,58552,58553,58554,58555,58556,58557,58558,58559,58560,58561, +58562,58563,58564,58565,58566,58567,58568,58569,58570,58571,58572,58573, +58574,58575,58576,58577,58578,58579,58580,58581,58582,58583,58584,58585, +58586,58587,58588,58589,58590,58591,58592,58593,58594,58595,58596,58597, +58598,58599,58600,58601,58602,58603,58604,58605,58606,58607,58608,58609, +58610,58611,58612,58613,58614,58615,58616,58617,58618,58619,58620,58621, +58622,58623,58624,58625,58626,58627,58628,58629,58630,58631,58632,58633, +58634,58635,58636,58637,58638,58639,58640,58641,58642,58643,58644,58645, +58646,58647,58648,58649,58650,58651,58652,58653,58654,58655,58656,58657, +58658,58659,58660,58661,58662,58663,58664,58665,58666,58667,58668,58669, +58670,58671,58672,58673,58674,58675,58676,58677,58678,58679,58680,58681, +58682,58683,58684,58685,58686,58687,58688,58689,58690,58691,58692,58693, +58694,58695,58696,58697,58698,58699,58700,58701,58702,58703,58704,58705, +58706,58707,58708,58709,58710,58711,58712,58713,58714,58715,58716,58717, +58718,58719,58720,58721,58722,58723,58724,58725,58726,58727,58728,58729, +58730,58731,58732,58733,58734,58735,58736,58737,58738,58739,58740,58741, +58742,58743,58744,58745,58746,58747,58748,58749,58750,58751,58752,58753, +58754,58755,58756,58757,58758,58759,58760,58761,58762,58763,58764,58765, +58766,58767,58768,58769,58770,58771,58772,58773,58774,58775,58776,58777, +58778,58779,58780,58781,58782,58783,58784,58785,58786,58787,58788,58789, +58790,58791,58792,58793,58794,58795,58796,58797,58798,58799,58800,58801, +58802,58803,58804,58805,58806,58807,58808,58809,58810,58811,58812,58813, +58814,58815,58816,58817,58818,58819,58820,58821,58822,58823,58824,58825, +58826,58827,58828,58829,58830,58831,58832,58833,58834,58835,58836,58837, +58838,58839,58840,58841,58842,58843,58844,58845,58846,58847,58848,58849, +58850,58851,58852,58853,58854,58855,58856,58857,58858,58859,58860,58861, +58862,58863,58864,58865,58866,58867,58868,58869,58870,58871,58872,58873, +58874,58875,58876,58877,58878,58879,58880,58881,58882,58883,58884,58885, +58886,58887,58888,58889,58890,58891,58892,58893,58894,58895,58896,58897, +58898,58899,58900,58901,58902,58903,58904,58905,58906,58907,58908,58909, +58910,58911,58912,58913,58914,58915,58916,58917,58918,58919,58920,58921, +58922,58923,58924,58925,58926,58927,58928,58929,58930,58931,58932,58933, +58934,58935,58936,58937,58938,58939,58940,58941,58942,58943,58944,58945, +58946,58947,58948,58949,58950,58951,58952,58953,58954,58955,58956,58957, +58958,58959,58960,58961,58962,58963,58964,58965,58966,58967,58968,58969, +58970,58971,58972,58973,58974,58975,58976,58977,58978,58979,58980,58981, +58982,58983,58984,58985,58986,58987,58988,58989,58990,58991,58992,58993, +58994,58995,58996,58997,58998,58999,59000,59001,59002,59003,59004,59005, +59006,59007,59008,59009,59010,59011,59012,59013,59014,59015,59016,59017, +59018,59019,59020,59021,59022,59023,59024,59025,59026,59027,59028,59029, +59030,59031,59032,59033,59034,59035,59036,59037,59038,59039,59040,59041, +59042,59043,59044,59045,59046,59047,59048,59049,59050,59051,59052,59053, +59054,59055,59056,59057,59058,59059,59060,59061,59062,59063,59064,59065, +59066,59067,59068,59069,59070,59071,59072,59073,59074,59075,59076,59077, +59078,59079,59080,59081,59082,59083,59084,59085,59086,59087,59088,59089, +59090,59091,59092,59093,59094,59095,59096,59097,59098,59099,59100,59101, +59102,59103,59104,59105,59106,59107,59108,59109,59110,59111,59112,59113, +59114,59115,59116,59117,59118,59119,59120,59121,59122,59123,59124,59125, +59126,59127,59128,59129,59130,59131,59132,59133,59134,59135,59136,59137, +59138,59139,59140,59141,59142,59143,59144,59145,59146,59147,59148,59149, +59150,59151,59152,59153,59154,59155,59156,59157,59158,59159,59160,59161, +59162,59163,59164,59165,59166,59167,59168,59169,59170,59171,59172,59173, +59174,59175,59176,59177,59178,59179,59180,59181,59182,59183,59184,59185, +59186,59187,59188,59189,59190,59191,59192,59193,59194,59195,59196,59197, +59198,59199,59200,59201,59202,59203,59204,59205,59206,59207,59208,59209, +59210,59211,59212,59213,59214,59215,59216,59217,59218,59219,59220,59221, +59222,59223,59224,59225,59226,59227,59228,59229,59230,59231,59232,59233, +59234,59235,59236,59237,59238,59239,59240,59241,59242,59243,59244,59245, +59246,59247,59248,59249,59250,59251,59252,59253,59254,59255,59256,59257, +59258,59259,59260,59261,59262,59263,59264,59265,59266,59267,59268,59269, +59270,59271,59272,59273,59274,59275,59276,59277,59278,59279,59280,59281, +59282,59283,59284,59285,59286,59287,59288,59289,59290,59291,59292,59293, +59294,59295,59296,59297,59298,59299,59300,59301,59302,59303,59304,59305, +59306,59307,59308,59309,59310,59311,59312,59313,59314,59315,59316,59317, +59318,59319,59320,59321,59322,59323,59324,59325,59326,59327,59328,59329, +59330,59331,59332,59333,59334,59335,59336,59337,59338,59339,59340,59341, +59342,59343,59344,59345,59346,59347,59348,59349,59350,59351,59352,59353, +59354,59355,59356,59357,59358,59359,59360,59361,59362,59363,59364,59365, +59366,59367,59368,59369,59370,59371,59372,59373,59374,59375,59376,59377, +59378,59379,59380,59381,59382,59383,59384,59385,59386,59387,59388,59389, +59390,59391,59392,59393,59394,59395,59396,59397,59398,59399,59400,59401, +59402,59403,59404,59405,59406,59407,59408,59409,59410,59411,59412,59413, +59414,59415,59416,59417,59418,59419,59420,59421,59422,59423,59424,59425, +59426,59427,59428,59429,59430,59431,59432,59433,59434,59435,59436,59437, +59438,59439,59440,59441,59442,59443,59444,59445,59446,59447,59448,59449, +59450,59451,59452,59453,59454,59455,59456,59457,59458,59459,59460,59461, +59462,59463,59464,59465,59466,59467,59468,59469,59470,59471,59472,59473, +59474,59475,59476,59477,59478,59479,59480,59481,59482,59483,59484,59485, +59486,59487,59488,59489,59490,59491,59492,59493,59494,59495,59496,59497, +59498,59499,59500,59501,59502,59503,59504,59505,59506,59507,59508,59509, +59510,59511,59512,59513,59514,59515,59516,59517,59518,59519,59520,59521, +59522,59523,59524,59525,59526,59527,59528,59529,59530,59531,59532,59533, +59534,59535,59536,59537,59538,59539,59540,59541,59542,59543,59544,59545, +59546,59547,59548,59549,59550,59551,59552,59553,59554,59555,59556,59557, +59558,59559,59560,59561,59562,59563,59564,59565,59566,59567,59568,59569, +59570,59571,59572,59573,59574,59575,59576,59577,59578,59579,59580,59581, +59582,59583,59584,59585,59586,59587,59588,59589,59590,59591,59592,59593, +59594,59595,59596,59597,59598,59599,59600,59601,59602,59603,59604,59605, +59606,59607,59608,59609,59610,59611,59612,59613,59614,59615,59616,59617, +59618,59619,59620,59621,59622,59623,59624,59625,59626,59627,59628,59629, +59630,59631,59632,59633,59634,59635,59636,59637,59638,59639,59640,59641, +59642,59643,59644,59645,59646,59647,59648,59649,59650,59651,59652,59653, +59654,59655,59656,59657,59658,59659,59660,59661,59662,59663,59664,59665, +59666,59667,59668,59669,59670,59671,59672,59673,59674,59675,59676,59677, +59678,59679,59680,59681,59682,59683,59684,59685,59686,59687,59688,59689, +59690,59691,59692,59693,59694,59695,59696,59697,59698,59699,59700,59701, +59702,59703,59704,59705,59706,59707,59708,59709,59710,59711,59712,59713, +59714,59715,59716,59717,59718,59719,59720,59721,59722,59723,59724,59725, +59726,59727,59728,59729,59730,59731,59732,59733,59734,59735,59736,59737, +59738,59739,59740,59741,59742,59743,59744,59745,59746,59747,59748,59749, +59750,59751,59752,59753,59754,59755,59756,59757,59758,59759,59760,59761, +59762,59763,59764,59765,59766,59767,59768,59769,59770,59771,59772,59773, +59774,59775,59776,59777,59778,59779,59780,59781,59782,59783,59784,59785, +59786,59787,59788,59789,59790,59791,59792,59793,59794,59795,59796,59797, +59798,59799,59800,59801,59802,59803,59804,59805,59806,59807,59808,59809, +59810,59811,59812,59813,59814,59815,59816,59817,59818,59819,59820,59821, +59822,59823,59824,59825,59826,59827,59828,59829,59830,59831,59832,59833, +59834,59835,59836,59837,59838,59839,59840,59841,59842,59843,59844,59845, +59846,59847,59848,59849,59850,59851,59852,59853,59854,59855,59856,59857, +59858,59859,59860,59861,59862,59863,59864,59865,59866,59867,59868,59869, +59870,59871,59872,59873,59874,59875,59876,59877,59878,59879,59880,59881, +59882,59883,59884,59885,59886,59887,59888,59889,59890,59891,59892,59893, +59894,59895,59896,59897,59898,59899,59900,59901,59902,59903,59904,59905, +59906,59907,59908,59909,59910,59911,59912,59913,59914,59915,59916,59917, +59918,59919,59920,59921,59922,59923,59924,59925,59926,59927,59928,59929, +59930,59931,59932,59933,59934,59935,59936,59937,59938,59939,59940,59941, +59942,59943,59944,59945,59946,59947,59948,59949,59950,59951,59952,59953, +59954,59955,59956,59957,59958,59959,59960,59961,59962,59963,59964,59965, +59966,59967,59968,59969,59970,59971,59972,59973,59974,59975,59976,59977, +59978,59979,59980,59981,59982,59983,59984,59985,59986,59987,59988,59989, +59990,59991,59992,59993,59994,59995,59996,59997,59998,59999,60000,60001, +60002,60003,60004,60005,60006,60007,60008,60009,60010,60011,60012,60013, +60014,60015,60016,60017,60018,60019,60020,60021,60022,60023,60024,60025, +60026,60027,60028,60029,60030,60031,60032,60033,60034,60035,60036,60037, +60038,60039,60040,60041,60042,60043,60044,60045,60046,60047,60048,60049, +60050,60051,60052,60053,60054,60055,60056,60057,60058,60059,60060,60061, +60062,60063,60064,60065,60066,60067,60068,60069,60070,60071,60072,60073, +60074,60075,60076,60077,60078,60079,60080,60081,60082,60083,60084,60085, +60086,60087,60088,60089,60090,60091,60092,60093,60094,60095,60096,60097, +60098,60099,60100,60101,60102,60103,60104,60105,60106,60107,60108,60109, +60110,60111,60112,60113,60114,60115,60116,60117,60118,60119,60120,60121, +60122,60123,60124,60125,60126,60127,60128,60129,60130,60131,60132,60133, +60134,60135,60136,60137,60138,60139,60140,60141,60142,60143,60144,60145, +60146,60147,60148,60149,60150,60151,60152,60153,60154,60155,60156,60157, +60158,60159,60160,60161,60162,60163,60164,60165,60166,60167,60168,60169, +60170,60171,60172,60173,60174,60175,60176,60177,60178,60179,60180,60181, +60182,60183,60184,60185,60186,60187,60188,60189,60190,60191,60192,60193, +60194,60195,60196,60197,60198,60199,60200,60201,60202,60203,60204,60205, +60206,60207,60208,60209,60210,60211,60212,60213,60214,60215,60216,60217, +60218,60219,60220,60221,60222,60223,60224,60225,60226,60227,60228,60229, +60230,60231,60232,60233,60234,60235,60236,60237,60238,60239,60240,60241, +60242,60243,60244,60245,60246,60247,60248,60249,60250,60251,60252,60253, +60254,60255,60256,60257,60258,60259,60260,60261,60262,60263,60264,60265, +60266,60267,60268,60269,60270,60271,60272,60273,60274,60275,60276,60277, +60278,60279,60280,60281,60282,60283,60284,60285,60286,60287,60288,60289, +60290,60291,60292,60293,60294,60295,60296,60297,60298,60299,60300,60301, +60302,60303,60304,60305,60306,60307,60308,60309,60310,60311,60312,60313, +60314,60315,60316,60317,60318,60319,60320,60321,60322,60323,60324,60325, +60326,60327,60328,60329,60330,60331,60332,60333,60334,60335,60336,60337, +60338,60339,60340,60341,60342,60343,60344,60345,60346,60347,60348,60349, +60350,60351,60352,60353,60354,60355,60356,60357,60358,60359,60360,60361, +60362,60363,60364,60365,60366,60367,60368,60369,60370,60371,60372,60373, +60374,60375,60376,60377,60378,60379,60380,60381,60382,60383,60384,60385, +60386,60387,60388,60389,60390,60391,60392,60393,60394,60395,60396,60397, +60398,60399,60400,60401,60402,60403,60404,60405,60406,60407,60408,60409, +60410,60411,60412,60413,60414,60415,60416,60417,60418,60419,60420,60421, +60422,60423,60424,60425,60426,60427,60428,60429,60430,60431,60432,60433, +60434,60435,60436,60437,60438,60439,60440,60441,60442,60443,60444,60445, +60446,60447,60448,60449,60450,60451,60452,60453,60454,60455,60456,60457, +60458,60459,60460,60461,60462,60463,60464,60465,60466,60467,60468,60469, +60470,60471,60472,60473,60474,60475,60476,60477,60478,60479,60480,60481, +60482,60483,60484,60485,60486,60487,60488,60489,60490,60491,60492,60493, +60494,60495,60496,60497,60498,60499,60500,60501,60502,60503,60504,60505, +60506,60507,60508,60509,60510,60511,60512,60513,60514,60515,60516,60517, +60518,60519,60520,60521,60522,60523,60524,60525,60526,60527,60528,60529, +60530,60531,60532,60533,60534,60535,60536,60537,60538,60539,60540,60541, +60542,60543,60544,60545,60546,60547,60548,60549,60550,60551,60552,60553, +60554,60555,60556,60557,60558,60559,60560,60561,60562,60563,60564,60565, +60566,60567,60568,60569,60570,60571,60572,60573,60574,60575,60576,60577, +60578,60579,60580,60581,60582,60583,60584,60585,60586,60587,60588,60589, +60590,60591,60592,60593,60594,60595,60596,60597,60598,60599,60600,60601, +60602,60603,60604,60605,60606,60607,60608,60609,60610,60611,60612,60613, +60614,60615,60616,60617,60618,60619,60620,60621,60622,60623,60624,60625, +60626,60627,60628,60629,60630,60631,60632,60633,60634,60635,60636,60637, +60638,60639,60640,60641,60642,60643,60644,60645,60646,60647,60648,60649, +60650,60651,60652,60653,60654,60655,60656,60657,60658,60659,60660,60661, +60662,60663,60664,60665,60666,60667,60668,60669,60670,60671,60672,60673, +60674,60675,60676,60677,60678,60679,60680,60681,60682,60683,60684,60685, +60686,60687,60688,60689,60690,60691,60692,60693,60694,60695,60696,60697, +60698,60699,60700,60701,60702,60703,60704,60705,60706,60707,60708,60709, +60710,60711,60712,60713,60714,60715,60716,60717,60718,60719,60720,60721, +60722,60723,60724,60725,60726,60727,60728,60729,60730,60731,60732,60733, +60734,60735,60736,60737,60738,60739,60740,60741,60742,60743,60744,60745, +60746,60747,60748,60749,60750,60751,60752,60753,60754,60755,60756,60757, +60758,60759,60760,60761,60762,60763,60764,60765,60766,60767,60768,60769, +60770,60771,60772,60773,60774,60775,60776,60777,60778,60779,60780,60781, +60782,60783,60784,60785,60786,60787,60788,60789,60790,60791,60792,60793, +60794,60795,60796,60797,60798,60799,60800,60801,60802,60803,60804,60805, +60806,60807,60808,60809,60810,60811,60812,60813,60814,60815,60816,60817, +60818,60819,60820,60821,60822,60823,60824,60825,60826,60827,60828,60829, +60830,60831,60832,60833,60834,60835,60836,60837,60838,60839,60840,60841, +60842,60843,60844,60845,60846,60847,60848,60849,60850,60851,60852,60853, +60854,60855,60856,60857,60858,60859,60860,60861,60862,60863,60864,60865, +60866,60867,60868,60869,60870,60871,60872,60873,60874,60875,60876,60877, +60878,60879,60880,60881,60882,60883,60884,60885,60886,60887,60888,60889, +60890,60891,60892,60893,60894,60895,60896,60897,60898,60899,60900,60901, +60902,60903,60904,60905,60906,60907,60908,60909,60910,60911,60912,60913, +60914,60915,60916,60917,60918,60919,60920,60921,60922,60923,60924,60925, +60926,60927,60928,60929,60930,60931,60932,60933,60934,60935,60936,60937, +60938,60939,60940,60941,60942,60943,60944,60945,60946,60947,60948,60949, +60950,60951,60952,60953,60954,60955,60956,60957,60958,60959,60960,60961, +60962,60963,60964,60965,60966,60967,60968,60969,60970,60971,60972,60973, +60974,60975,60976,60977,60978,60979,60980,60981,60982,60983,60984,60985, +60986,60987,60988,60989,60990,60991,60992,60993,60994,60995,60996,60997, +60998,60999,61000,61001,61002,61003,61004,61005,61006,61007,61008,61009, +61010,61011,61012,61013,61014,61015,61016,61017,61018,61019,61020,61021, +61022,61023,61024,61025,61026,61027,61028,61029,61030,61031,61032,61033, +61034,61035,61036,61037,61038,61039,61040,61041,61042,61043,61044,61045, +61046,61047,61048,61049,61050,61051,61052,61053,61054,61055,61056,61057, +61058,61059,61060,61061,61062,61063,61064,61065,61066,61067,61068,61069, +61070,61071,61072,61073,61074,61075,61076,61077,61078,61079,61080,61081, +61082,61083,61084,61085,61086,61087,61088,61089,61090,61091,61092,61093, +61094,61095,61096,61097,61098,61099,61100,61101,61102,61103,61104,61105, +61106,61107,61108,61109,61110,61111,61112,61113,61114,61115,61116,61117, +61118,61119,61120,61121,61122,61123,61124,61125,61126,61127,61128,61129, +61130,61131,61132,61133,61134,61135,61136,61137,61138,61139,61140,61141, +61142,61143,61144,61145,61146,61147,61148,61149,61150,61151,61152,61153, +61154,61155,61156,61157,61158,61159,61160,61161,61162,61163,61164,61165, +61166,61167,61168,61169,61170,61171,61172,61173,61174,61175,61176,61177, +61178,61179,61180,61181,61182,61183,61184,61185,61186,61187,61188,61189, +61190,61191,61192,61193,61194,61195,61196,61197,61198,61199,61200,61201, +61202,61203,61204,61205,61206,61207,61208,61209,61210,61211,61212,61213, +61214,61215,61216,61217,61218,61219,61220,61221,61222,61223,61224,61225, +61226,61227,61228,61229,61230,61231,61232,61233,61234,61235,61236,61237, +61238,61239,61240,61241,61242,61243,61244,61245,61246,61247,61248,61249, +61250,61251,61252,61253,61254,61255,61256,61257,61258,61259,61260,61261, +61262,61263,61264,61265,61266,61267,61268,61269,61270,61271,61272,61273, +61274,61275,61276,61277,61278,61279,61280,61281,61282,61283,61284,61285, +61286,61287,61288,61289,61290,61291,61292,61293,61294,61295,61296,61297, +61298,61299,61300,61301,61302,61303,61304,61305,61306,61307,61308,61309, +61310,61311,61312,61313,61314,61315,61316,61317,61318,61319,61320,61321, +61322,61323,61324,61325,61326,61327,61328,61329,61330,61331,61332,61333, +61334,61335,61336,61337,61338,61339,61340,61341,61342,61343,61344,61345, +61346,61347,61348,61349,61350,61351,61352,61353,61354,61355,61356,61357, +61358,61359,61360,61361,61362,61363,61364,61365,61366,61367,61368,61369, +61370,61371,61372,61373,61374,61375,61376,61377,61378,61379,61380,61381, +61382,61383,61384,61385,61386,61387,61388,61389,61390,61391,61392,61393, +61394,61395,61396,61397,61398,61399,61400,61401,61402,61403,61404,61405, +61406,61407,61408,61409,61410,61411,61412,61413,61414,61415,61416,61417, +61418,61419,61420,61421,61422,61423,61424,61425,61426,61427,61428,61429, +61430,61431,61432,61433,61434,61435,61436,61437,61438,61439,61440,61441, +61442,61443,61444,61445,61446,61447,61448,61449,61450,61451,61452,61453, +61454,61455,61456,61457,61458,61459,61460,61461,61462,61463,61464,61465, +61466,61467,61468,61469,61470,61471,61472,61473,61474,61475,61476,61477, +61478,61479,61480,61481,61482,61483,61484,61485,61486,61487,61488,61489, +61490,61491,61492,61493,61494,61495,61496,61497,61498,61499,61500,61501, +61502,61503,61504,61505,61506,61507,61508,61509,61510,61511,61512,61513, +61514,61515,61516,61517,61518,61519,61520,61521,61522,61523,61524,61525, +61526,61527,61528,61529,61530,61531,61532,61533,61534,61535,61536,61537, +61538,61539,61540,61541,61542,61543,61544,61545,61546,61547,61548,61549, +61550,61551,61552,61553,61554,61555,61556,61557,61558,61559,61560,61561, +61562,61563,61564,61565,61566,61567,61568,61569,61570,61571,61572,61573, +61574,61575,61576,61577,61578,61579,61580,61581,61582,61583,61584,61585, +61586,61587,61588,61589,61590,61591,61592,61593,61594,61595,61596,61597, +61598,61599,61600,61601,61602,61603,61604,61605,61606,61607,61608,61609, +61610,61611,61612,61613,61614,61615,61616,61617,61618,61619,61620,61621, +61622,61623,61624,61625,61626,61627,61628,61629,61630,61631,61632,61633, +61634,61635,61636,61637,61638,61639,61640,61641,61642,61643,61644,61645, +61646,61647,61648,61649,61650,61651,61652,61653,61654,61655,61656,61657, +61658,61659,61660,61661,61662,61663,61664,61665,61666,61667,61668,61669, +61670,61671,61672,61673,61674,61675,61676,61677,61678,61679,61680,61681, +61682,61683,61684,61685,61686,61687,61688,61689,61690,61691,61692,61693, +61694,61695,61696,61697,61698,61699,61700,61701,61702,61703,61704,61705, +61706,61707,61708,61709,61710,61711,61712,61713,61714,61715,61716,61717, +61718,61719,61720,61721,61722,61723,61724,61725,61726,61727,61728,61729, +61730,61731,61732,61733,61734,61735,61736,61737,61738,61739,61740,61741, +61742,61743,61744,61745,61746,61747,61748,61749,61750,61751,61752,61753, +61754,61755,61756,61757,61758,61759,61760,61761,61762,61763,61764,61765, +61766,61767,61768,61769,61770,61771,61772,61773,61774,61775,61776,61777, +61778,61779,61780,61781,61782,61783,61784,61785,61786,61787,61788,61789, +61790,61791,61792,61793,61794,61795,61796,61797,61798,61799,61800,61801, +61802,61803,61804,61805,61806,61807,61808,61809,61810,61811,61812,61813, +61814,61815,61816,61817,61818,61819,61820,61821,61822,61823,61824,61825, +61826,61827,61828,61829,61830,61831,61832,61833,61834,61835,61836,61837, +61838,61839,61840,61841,61842,61843,61844,61845,61846,61847,61848,61849, +61850,61851,61852,61853,61854,61855,61856,61857,61858,61859,61860,61861, +61862,61863,61864,61865,61866,61867,61868,61869,61870,61871,61872,61873, +61874,61875,61876,61877,61878,61879,61880,61881,61882,61883,61884,61885, +61886,61887,61888,61889,61890,61891,61892,61893,61894,61895,61896,61897, +61898,61899,61900,61901,61902,61903,61904,61905,61906,61907,61908,61909, +61910,61911,61912,61913,61914,61915,61916,61917,61918,61919,61920,61921, +61922,61923,61924,61925,61926,61927,61928,61929,61930,61931,61932,61933, +61934,61935,61936,61937,61938,61939,61940,61941,61942,61943,61944,61945, +61946,61947,61948,61949,61950,61951,61952,61953,61954,61955,61956,61957, +61958,61959,61960,61961,61962,61963,61964,61965,61966,61967,61968,61969, +61970,61971,61972,61973,61974,61975,61976,61977,61978,61979,61980,61981, +61982,61983,61984,61985,61986,61987,61988,61989,61990,61991,61992,61993, +61994,61995,61996,61997,61998,61999,62000,62001,62002,62003,62004,62005, +62006,62007,62008,62009,62010,62011,62012,62013,62014,62015,62016,62017, +62018,62019,62020,62021,62022,62023,62024,62025,62026,62027,62028,62029, +62030,62031,62032,62033,62034,62035,62036,62037,62038,62039,62040,62041, +62042,62043,62044,62045,62046,62047,62048,62049,62050,62051,62052,62053, +62054,62055,62056,62057,62058,62059,62060,62061,62062,62063,62064,62065, +62066,62067,62068,62069,62070,62071,62072,62073,62074,62075,62076,62077, +62078,62079,62080,62081,62082,62083,62084,62085,62086,62087,62088,62089, +62090,62091,62092,62093,62094,62095,62096,62097,62098,62099,62100,62101, +62102,62103,62104,62105,62106,62107,62108,62109,62110,62111,62112,62113, +62114,62115,62116,62117,62118,62119,62120,62121,62122,62123,62124,62125, +62126,62127,62128,62129,62130,62131,62132,62133,62134,62135,62136,62137, +62138,62139,62140,62141,62142,62143,62144,62145,62146,62147,62148,62149, +62150,62151,62152,62153,62154,62155,62156,62157,62158,62159,62160,62161, +62162,62163,62164,62165,62166,62167,62168,62169,62170,62171,62172,62173, +62174,62175,62176,62177,62178,62179,62180,62181,62182,62183,62184,62185, +62186,62187,62188,62189,62190,62191,62192,62193,62194,62195,62196,62197, +62198,62199,62200,62201,62202,62203,62204,62205,62206,62207,62208,62209, +62210,62211,62212,62213,62214,62215,62216,62217,62218,62219,62220,62221, +62222,62223,62224,62225,62226,62227,62228,62229,62230,62231,62232,62233, +62234,62235,62236,62237,62238,62239,62240,62241,62242,62243,62244,62245, +62246,62247,62248,62249,62250,62251,62252,62253,62254,62255,62256,62257, +62258,62259,62260,62261,62262,62263,62264,62265,62266,62267,62268,62269, +62270,62271,62272,62273,62274,62275,62276,62277,62278,62279,62280,62281, +62282,62283,62284,62285,62286,62287,62288,62289,62290,62291,62292,62293, +62294,62295,62296,62297,62298,62299,62300,62301,62302,62303,62304,62305, +62306,62307,62308,62309,62310,62311,62312,62313,62314,62315,62316,62317, +62318,62319,62320,62321,62322,62323,62324,62325,62326,62327,62328,62329, +62330,62331,62332,62333,62334,62335,62336,62337,62338,62339,62340,62341, +62342,62343,62344,62345,62346,62347,62348,62349,62350,62351,62352,62353, +62354,62355,62356,62357,62358,62359,62360,62361,62362,62363,62364,62365, +62366,62367,62368,62369,62370,62371,62372,62373,62374,62375,62376,62377, +62378,62379,62380,62381,62382,62383,62384,62385,62386,62387,62388,62389, +62390,62391,62392,62393,62394,62395,62396,62397,62398,62399,62400,62401, +62402,62403,62404,62405,62406,62407,62408,62409,62410,62411,62412,62413, +62414,62415,62416,62417,62418,62419,62420,62421,62422,62423,62424,62425, +62426,62427,62428,62429,62430,62431,62432,62433,62434,62435,62436,62437, +62438,62439,62440,62441,62442,62443,62444,62445,62446,62447,62448,62449, +62450,62451,62452,62453,62454,62455,62456,62457,62458,62459,62460,62461, +62462,62463,62464,62465,62466,62467,62468,62469,62470,62471,62472,62473, +62474,62475,62476,62477,62478,62479,62480,62481,62482,62483,62484,62485, +62486,62487,62488,62489,62490,62491,62492,62493,62494,62495,62496,62497, +62498,62499,62500,62501,62502,62503,62504,62505,62506,62507,62508,62509, +62510,62511,62512,62513,62514,62515,62516,62517,62518,62519,62520,62521, +62522,62523,62524,62525,62526,62527,62528,62529,62530,62531,62532,62533, +62534,62535,62536,62537,62538,62539,62540,62541,62542,62543,62544,62545, +62546,62547,62548,62549,62550,62551,62552,62553,62554,62555,62556,62557, +62558,62559,62560,62561,62562,62563,62564,62565,62566,62567,62568,62569, +62570,62571,62572,62573,62574,62575,62576,62577,62578,62579,62580,62581, +62582,62583,62584,62585,62586,62587,62588,62589,62590,62591,62592,62593, +62594,62595,62596,62597,62598,62599,62600,62601,62602,62603,62604,62605, +62606,62607,62608,62609,62610,62611,62612,62613,62614,62615,62616,62617, +62618,62619,62620,62621,62622,62623,62624,62625,62626,62627,62628,62629, +62630,62631,62632,62633,62634,62635,62636,62637,62638,62639,62640,62641, +62642,62643,62644,62645,62646,62647,62648,62649,62650,62651,62652,62653, +62654,62655,62656,62657,62658,62659,62660,62661,62662,62663,62664,62665, +62666,62667,62668,62669,62670,62671,62672,62673,62674,62675,62676,62677, +62678,62679,62680,62681,62682,62683,62684,62685,62686,62687,62688,62689, +62690,62691,62692,62693,62694,62695,62696,62697,62698,62699,62700,62701, +62702,62703,62704,62705,62706,62707,62708,62709,62710,62711,62712,62713, +62714,62715,62716,62717,62718,62719,62720,62721,62722,62723,62724,62725, +62726,62727,62728,62729,62730,62731,62732,62733,62734,62735,62736,62737, +62738,62739,62740,62741,62742,62743,62744,62745,62746,62747,62748,62749, +62750,62751,62752,62753,62754,62755,62756,62757,62758,62759,62760,62761, +62762,62763,62764,62765,62766,62767,62768,62769,62770,62771,62772,62773, +62774,62775,62776,62777,62778,62779,62780,62781,62782,62783,62784,62785, +62786,62787,62788,62789,62790,62791,62792,62793,62794,62795,62796,62797, +62798,62799,62800,62801,62802,62803,62804,62805,62806,62807,62808,62809, +62810,62811,62812,62813,62814,62815,62816,62817,62818,62819,62820,62821, +62822,62823,62824,62825,62826,62827,62828,62829,62830,62831,62832,62833, +62834,62835,62836,62837,62838,62839,62840,62841,62842,62843,62844,62845, +62846,62847,62848,62849,62850,62851,62852,62853,62854,62855,62856,62857, +62858,62859,62860,62861,62862,62863,62864,62865,62866,62867,62868,62869, +62870,62871,62872,62873,62874,62875,62876,62877,62878,62879,62880,62881, +62882,62883,62884,62885,62886,62887,62888,62889,62890,62891,62892,62893, +62894,62895,62896,62897,62898,62899,62900,62901,62902,62903,62904,62905, +62906,62907,62908,62909,62910,62911,62912,62913,62914,62915,62916,62917, +62918,62919,62920,62921,62922,62923,62924,62925,62926,62927,62928,62929, +62930,62931,62932,62933,62934,62935,62936,62937,62938,62939,62940,62941, +62942,62943,62944,62945,62946,62947,62948,62949,62950,62951,62952,62953, +62954,62955,62956,62957,62958,62959,62960,62961,62962,62963,62964,62965, +62966,62967,62968,62969,62970,62971,62972,62973,62974,62975,62976,62977, +62978,62979,62980,62981,62982,62983,62984,62985,62986,62987,62988,62989, +62990,62991,62992,62993,62994,62995,62996,62997,62998,62999,63000,63001, +63002,63003,63004,63005,63006,63007,63008,63009,63010,63011,63012,63013, +63014,63015,63016,63017,63018,63019,63020,63021,63022,63023,63024,63025, +63026,63027,63028,63029,63030,63031,63032,63033,63034,63035,63036,63037, +63038,63039,63040,63041,63042,63043,63044,63045,63046,63047,63048,63049, +63050,63051,63052,63053,63054,63055,63056,63057,63058,63059,63060,63061, +63062,63063,63064,63065,63066,63067,63068,63069,63070,63071,63072,63073, +63074,63075,63076,63077,63078,63079,63080,63081,63082,63083,63084,63085, +63086,63087,63088,63089,63090,63091,63092,63093,63094,63095,63096,63097, +63098,63099,63100,63101,63102,63103,63104,63105,63106,63107,63108,63109, +63110,63111,63112,63113,63114,63115,63116,63117,63118,63119,63120,63121, +63122,63123,63124,63125,63126,63127,63128,63129,63130,63131,63132,63133, +63134,63135,63136,63137,63138,63139,63140,63141,63142,63143,63144,63145, +63146,63147,63148,63149,63150,63151,63152,63153,63154,63155,63156,63157, +63158,63159,63160,63161,63162,63163,63164,63165,63166,63167,63168,63169, +63170,63171,63172,63173,63174,63175,63176,63177,63178,63179,63180,63181, +63182,63183,63184,63185,63186,63187,63188,63189,63190,63191,63192,63193, +63194,63195,63196,63197,63198,63199,63200,63201,63202,63203,63204,63205, +63206,63207,63208,63209,63210,63211,63212,63213,63214,63215,63216,63217, +63218,63219,63220,63221,63222,63223,63224,63225,63226,63227,63228,63229, +63230,63231,63232,63233,63234,63235,63236,63237,63238,63239,63240,63241, +63242,63243,63244,63245,63246,63247,63248,63249,63250,63251,63252,63253, +63254,63255,63256,63257,63258,63259,63260,63261,63262,63263,63264,63265, +63266,63267,63268,63269,63270,63271,63272,63273,63274,63275,63276,63277, +63278,63279,63280,63281,63282,63283,63284,63285,63286,63287,63288,63289, +63290,63291,63292,63293,63294,63295,63296,63297,63298,63299,63300,63301, +63302,63303,63304,63305,63306,63307,63308,63309,63310,63311,63312,63313, +63314,63315,63316,63317,63318,63319,63320,63321,63322,63323,63324,63325, +63326,63327,63328,63329,63330,63331,63332,63333,63334,63335,63336,63337, +63338,63339,63340,63341,63342,63343,63344,63345,63346,63347,63348,63349, +63350,63351,63352,63353,63354,63355,63356,63357,63358,63359,63360,63361, +63362,63363,63364,63365,63366,63367,63368,63369,63370,63371,63372,63373, +63374,63375,63376,63377,63378,63379,63380,63381,63382,63383,63384,63385, +63386,63387,63388,63389,63390,63391,63392,63393,63394,63395,63396,63397, +63398,63399,63400,63401,63402,63403,63404,63405,63406,63407,63408,63409, +63410,63411,63412,63413,63414,63415,63416,63417,63418,63419,63420,63421, +63422,63423,63424,63425,63426,63427,63428,63429,63430,63431,63432,63433, +63434,63435,63436,63437,63438,63439,63440,63441,63442,63443,63444,63445, +63446,63447,63448,63449,63450,63451,63452,63453,63454,63455,63456,63457, +63458,63459,63460,63461,63462,63463,63464,63465,63466,63467,63468,63469, +63470,63471,63472,63473,63474,63475,63476,63477,63478,63479,63480,63481, +63482,63483,63484,63485,63486,63487,63488,63489,63490,63491,63492,63493, +63494,63495,63496,63497,63498,63499,63500,63501,63502,63503,63504,63505, +63506,63507,63508,63509,63510,63511,63512,63513,63514,63515,63516,63517, +63518,63519,63520,63521,63522,63523,63524,63525,63526,63527,63528,63529, +63530,63531,63532,63533,63534,63535,63536,63537,63538,63539,63540,63541, +63542,63543,63544,63545,63546,63547,63548,63549,63550,63551,63552,63553, +63554,63555,63556,63557,63558,63559,63560,63561,63562,63563,63564,63565, +63566,63567,63568,63569,63570,63571,63572,63573,63574,63575,63576,63577, +63578,63579,63580,63581,63582,63583,63584,63585,63586,63587,63588,63589, +63590,63591,63592,63593,63594,63595,63596,63597,63598,63599,63600,63601, +63602,63603,63604,63605,63606,63607,63608,63609,63610,63611,63612,63613, +63614,63615,63616,63617,63618,63619,63620,63621,63622,63623,63624,63625, +63626,63627,63628,63629,63630,63631,63632,63633,63634,63635,63636,63637, +63638,63639,63640,63641,63642,63643,63644,63645,63646,63647,63648,63649, +63650,63651,63652,63653,63654,63655,63656,63657,63658,63659,63660,63661, +63662,63663,63664,63665,63666,63667,63668,63669,63670,63671,63672,63673, +63674,63675,63676,63677,63678,63679,63680,63681,63682,63683,63684,63685, +63686,63687,63688,63689,63690,63691,63692,63693,63694,63695,63696,63697, +63698,63699,63700,63701,63702,63703,63704,63705,63706,63707,63708,63709, +63710,63711,63712,63713,63714,63715,63716,63717,63718,63719,63720,63721, +63722,63723,63724,63725,63726,63727,63728,63729,63730,63731,63732,63733, +63734,63735,63736,63737,63738,63739,63740,63741,63742,63743,63744,63745, +63746,63747,63748,63749,63750,63751,63752,63753,63754,63755,63756,63757, +63758,63759,63760,63761,63762,63763,63764,63765,63766,63767,63768,63769, +63770,63771,63772,63773,63774,63775,63776,63777,63778,63779,63780,63781, +63782,63783,63784,63785,63786,63787,63788,63789,63790,63791,63792,63793, +63794,63795,63796,63797,63798,63799,63800,63801,63802,63803,63804,63805, +63806,63807,63808,63809,63810,63811,63812,63813,63814,63815,63816,63817, +63818,63819,63820,63821,63822,63823,63824,63825,63826,63827,63828,63829, +63830,63831,63832,63833,63834,63835,63836,63837,63838,63839,63840,63841, +63842,63843,63844,63845,63846,63847,63848,63849,63850,63851,63852,63853, +63854,63855,63856,63857,63858,63859,63860,63861,63862,63863,63864,63865, +63866,63867,63868,63869,63870,63871,63872,63873,63874,63875,63876,63877, +63878,63879,63880,63881,63882,63883,63884,63885,63886,63887,63888,63889, +63890,63891,63892,63893,63894,63895,63896,63897,63898,63899,63900,63901, +63902,63903,63904,63905,63906,63907,63908,63909,63910,63911,63912,63913, +63914,63915,63916,63917,63918,63919,63920,63921,63922,63923,63924,63925, +63926,63927,63928,63929,63930,63931,63932,63933,63934,63935,63936,63937, +63938,63939,63940,63941,63942,63943,63944,63945,63946,63947,63948,63949, +63950,63951,63952,63953,63954,63955,63956,63957,63958,63959,63960,63961, +63962,63963,63964,63965,63966,63967,63968,63969,63970,63971,63972,63973, +63974,63975,63976,63977,63978,63979,63980,63981,63982,63983,63984,63985, +63986,63987,63988,63989,63990,63991,63992,63993,63994,63995,63996,63997, +63998,63999,64000,64001,64002,64003,64004,64005,64006,64007,64008,64009, +64010,64011,64012,64013,64014,64015,64016,64017,64018,64019,64020,64021, +64022,64023,64024,64025,64026,64027,64028,64029,64030,64031,64032,64033, +64034,64035,64036,64037,64038,64039,64040,64041,64042,64043,64044,64045, +64046,64047,64048,64049,64050,64051,64052,64053,64054,64055,64056,64057, +64058,64059,64060,64061,64062,64063,64064,64065,64066,64067,64068,64069, +64070,64071,64072,64073,64074,64075,64076,64077,64078,64079,64080,64081, +64082,64083,64084,64085,64086,64087,64088,64089,64090,64091,64092,64093, +64094,64095,64096,64097,64098,64099,64100,64101,64102,64103,64104,64105, +64106,64107,64108,64109,64110,64111,64112,64113,64114,64115,64116,64117, +64118,64119,64120,64121,64122,64123,64124,64125,64126,64127,64128,64129, +64130,64131,64132,64133,64134,64135,64136,64137,64138,64139,64140,64141, +64142,64143,64144,64145,64146,64147,64148,64149,64150,64151,64152,64153, +64154,64155,64156,64157,64158,64159,64160,64161,64162,64163,64164,64165, +64166,64167,64168,64169,64170,64171,64172,64173,64174,64175,64176,64177, +64178,64179,64180,64181,64182,64183,64184,64185,64186,64187,64188,64189, +64190,64191,64192,64193,64194,64195,64196,64197,64198,64199,64200,64201, +64202,64203,64204,64205,64206,64207,64208,64209,64210,64211,64212,64213, +64214,64215,64216,64217,64218,64219,64220,64221,64222,64223,64224,64225, +64226,64227,64228,64229,64230,64231,64232,64233,64234,64235,64236,64237, +64238,64239,64240,64241,64242,64243,64244,64245,64246,64247,64248,64249, +64250,64251,64252,64253,64254,64255,64256,64257,64258,64259,64260,64261, +64262,64263,64264,64265,64266,64267,64268,64269,64270,64271,64272,64273, +64274,64275,64276,64277,64278,64279,64280,64281,64282,64283,64284,64285, +64286,64287,64288,64289,64290,64291,64292,64293,64294,64295,64296,64297, +64298,64299,64300,64301,64302,64303,64304,64305,64306,64307,64308,64309, +64310,64311,64312,64313,64314,64315,64316,64317,64318,64319,64320,64321, +64322,64323,64324,64325,64326,64327,64328,64329,64330,64331,64332,64333, +64334,64335,64336,64337,64338,64339,64340,64341,64342,64343,64344,64345, +64346,64347,64348,64349,64350,64351,64352,64353,64354,64355,64356,64357, +64358,64359,64360,64361,64362,64363,64364,64365,64366,64367,64368,64369, +64370,64371,64372,64373,64374,64375,64376,64377,64378,64379,64380,64381, +64382,64383,64384,64385,64386,64387,64388,64389,64390,64391,64392,64393, +64394,64395,64396,64397,64398,64399,64400,64401,64402,64403,64404,64405, +64406,64407,64408,64409,64410,64411,64412,64413,64414,64415,64416,64417, +64418,64419,64420,64421,64422,64423,64424,64425,64426,64427,64428,64429, +64430,64431,64432,64433,64434,64435,64436,64437,64438,64439,64440,64441, +64442,64443,64444,64445,64446,64447,64448,64449,64450,64451,64452,64453, +64454,64455,64456,64457,64458,64459,64460,64461,64462,64463,64464,64465, +64466,64467,64468,64469,64470,64471,64472,64473,64474,64475,64476,64477, +64478,64479,64480,64481,64482,64483,64484,64485,64486,64487,64488,64489, +64490,64491,64492,64493,64494,64495,64496,64497,64498,64499,64500,64501, +64502,64503,64504,64505,64506,64507,64508,64509,64510,64511,64512,64513, +64514,64515,64516,64517,64518,64519,64520,64521,64522,64523,64524,64525, +64526,64527,64528,64529,64530,64531,64532,64533,64534,64535,64536,64537, +64538,64539,64540,64541,64542,64543,64544,64545,64546,64547,64548,64549, +64550,64551,64552,64553,64554,64555,64556,64557,64558,64559,64560,64561, +64562,64563,64564,64565,64566,64567,64568,64569,64570,64571,64572,64573, +64574,64575,64576,64577,64578,64579,64580,64581,64582,64583,64584,64585, +64586,64587,64588,64589,64590,64591,64592,64593,64594,64595,64596,64597, +64598,64599,64600,64601,64602,64603,64604,64605,64606,64607,64608,64609, +64610,64611,64612,64613,64614,64615,64616,64617,64618,64619,64620,64621, +64622,64623,64624,64625,64626,64627,64628,64629,64630,64631,64632,64633, +64634,64635,64636,64637,64638,64639,64640,64641,64642,64643,64644,64645, +64646,64647,64648,64649,64650,64651,64652,64653,64654,64655,64656,64657, +64658,64659,64660,64661,64662,64663,64664,64665,64666,64667,64668,64669, +64670,64671,64672,64673,64674,64675,64676,64677,64678,64679,64680,64681, +64682,64683,64684,64685,64686,64687,64688,64689,64690,64691,64692,64693, +64694,64695,64696,64697,64698,64699,64700,64701,64702,64703,64704,64705, +64706,64707,64708,64709,64710,64711,64712,64713,64714,64715,64716,64717, +64718,64719,64720,64721,64722,64723,64724,64725,64726,64727,64728,64729, +64730,64731,64732,64733,64734,64735,64736,64737,64738,64739,64740,64741, +64742,64743,64744,64745,64746,64747,64748,64749,64750,64751,64752,64753, +64754,64755,64756,64757,64758,64759,64760,64761,64762,64763,64764,64765, +64766,64767,64768,64769,64770,64771,64772,64773,64774,64775,64776,64777, +64778,64779,64780,64781,64782,64783,64784,64785,64786,64787,64788,64789, +64790,64791,64792,64793,64794,64795,64796,64797,64798,64799,64800,64801, +64802,64803,64804,64805,64806,64807,64808,64809,64810,64811,64812,64813, +64814,64815,64816,64817,64818,64819,64820,64821,64822,64823,64824,64825, +64826,64827,64828,64829,64830,64831,64832,64833,64834,64835,64836,64837, +64838,64839,64840,64841,64842,64843,64844,64845,64846,64847,64848,64849, +64850,64851,64852,64853,64854,64855,64856,64857,64858,64859,64860,64861, +64862,64863,64864,64865,64866,64867,64868,64869,64870,64871,64872,64873, +64874,64875,64876,64877,64878,64879,64880,64881,64882,64883,64884,64885, +64886,64887,64888,64889,64890,64891,64892,64893,64894,64895,64896,64897, +64898,64899,64900,64901,64902,64903,64904,64905,64906,64907,64908,64909, +64910,64911,64912,64913,64914,64915,64916,64917,64918,64919,64920,64921, +64922,64923,64924,64925,64926,64927,64928,64929,64930,64931,64932,64933, +64934,64935,64936,64937,64938,64939,64940,64941,64942,64943,64944,64945, +64946,64947,64948,64949,64950,64951,64952,64953,64954,64955,64956,64957, +64958,64959,64960,64961,64962,64963,64964,64965,64966,64967,64968,64969, +64970,64971,64972,64973,64974,64975,64976,64977,64978,64979,64980,64981, +64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993, +64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005, +65006,65007,65008,65009,65010,65011,65012,65013,65014,65015,65016,65017, +65018,65019,65020,65021,65022,65023,65024,65025,65026,65027,65028,65029, +65030,65031,65032,65033,65034,65035,65036,65037,65038,65039,65040,65041, +65042,65043,65044,65045,65046,65047,65048,65049,65050,65051,65052,65053, +65054,65055,65056,65057,65058,65059,65060,65061,65062,65063,65064,65065, +65066,65067,65068,65069,65070,65071,65072,65073,65074,65075,65076,65077, +65078,65079,65080,65081,65082,65083,65084,65085,65086,65087,65088,65089, +65090,65091,65092,65093,65094,65095,65096,65097,65098,65099,65100,65101, +65102,65103,65104,65105,65106,65107,65108,65109,65110,65111,65112,65113, +65114,65115,65116,65117,65118,65119,65120,65121,65122,65123,65124,65125, +65126,65127,65128,65129,65130,65131,65132,65133,65134,65135,65136,65137, +65138,65139,65140,65141,65142,65143,65144,65145,65146,65147,65148,65149, +65150,65151,65152,65153,65154,65155,65156,65157,65158,65159,65160,65161, +65162,65163,65164,65165,65166,65167,65168,65169,65170,65171,65172,65173, +65174,65175,65176,65177,65178,65179,65180,65181,65182,65183,65184,65185, +65186,65187,65188,65189,65190,65191,65192,65193,65194,65195,65196,65197, +65198,65199,65200,65201,65202,65203,65204,65205,65206,65207,65208,65209, +65210,65211,65212,65213,65214,65215,65216,65217,65218,65219,65220,65221, +65222,65223,65224,65225,65226,65227,65228,65229,65230,65231,65232,65233, +65234,65235,65236,65237,65238,65239,65240,65241,65242,65243,65244,65245, +65246,65247,65248,65249,65250,65251,65252,65253,65254,65255,65256,65257, +65258,65259,65260,65261,65262,65263,65264,65265,65266,65267,65268,65269, +65270,65271,65272,65273,65274,65275,65276,65277,65278,65279,65280,65281, +65282,65283,65284,65285,65286,65287,65288,65289,65290,65291,65292,65293, +65294,65295,65296,65297,65298,65299,65300,65301,65302,65303,65304,65305, +65306,65307,65308,65309,65310,65311,65312,65313,65314,65315,65316,65317, +65318,65319,65320,65321,65322,65323,65324,65325,65326,65327,65328,65329, +65330,65331,65332,65333,65334,65335,65336,65337,65338,65339,65340,65341, +65342,65343,65344,65313,65314,65315,65316,65317,65318,65319,65320,65321, +65322,65323,65324,65325,65326,65327,65328,65329,65330,65331,65332,65333, +65334,65335,65336,65337,65338,65371,65372,65373,65374,65375,65376,65377, +65378,65379,65380,65381,65382,65383,65384,65385,65386,65387,65388,65389, +65390,65391,65392,65393,65394,65395,65396,65397,65398,65399,65400,65401, +65402,65403,65404,65405,65406,65407,65408,65409,65410,65411,65412,65413, +65414,65415,65416,65417,65418,65419,65420,65421,65422,65423,65424,65425, +65426,65427,65428,65429,65430,65431,65432,65433,65434,65435,65436,65437, +65438,65439,65440,65441,65442,65443,65444,65445,65446,65447,65448,65449, +65450,65451,65452,65453,65454,65455,65456,65457,65458,65459,65460,65461, +65462,65463,65464,65465,65466,65467,65468,65469,65470,65471,65472,65473, +65474,65475,65476,65477,65478,65479,65480,65481,65482,65483,65484,65485, +65486,65487,65488,65489,65490,65491,65492,65493,65494,65495,65496,65497, +65498,65499,65500,65501,65502,65503,65504,65505,65506,65507,65508,65509, +65510,65511,65512,65513,65514,65515,65516,65517,65518,65519,65520,65521, +65522,65523,65524,65525,65526,65527,65528,65529,65530,65531,65532,65533, +65534,65535, +}; +#endif #line 1 "duk_util_bitdecoder.c" /* * Bitstream decoder. @@ -72550,6 +87637,367 @@ DUK_INTERNAL void duk_be_finish(duk_bitencoder_ctx *ctx) { } DUK_ASSERT(ctx->currbits == 0); } +#line 1 "duk_util_bufwriter.c" +/* + * Fast buffer writer with spare management. + */ + +/* include removed: duk_internal.h */ + +/* + * Macro support functions (use only macros in calling code) + */ + +DUK_LOCAL void duk__bw_update_ptrs(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t curr_offset, duk_size_t new_length) { + duk_uint8_t *p; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw_ctx != NULL); + DUK_UNREF(thr); + + p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, bw_ctx->buf); + DUK_ASSERT(p != NULL || (DUK_HBUFFER_DYNAMIC_GET_SIZE(bw_ctx->buf) == 0 && curr_offset == 0 && new_length == 0)); + bw_ctx->p = p + curr_offset; + bw_ctx->p_base = p; + bw_ctx->p_limit = p + new_length; +} + +DUK_INTERNAL void duk_bw_init(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_hbuffer_dynamic *h_buf) { + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw_ctx != NULL); + DUK_ASSERT(h_buf != NULL); + DUK_UNREF(thr); + + bw_ctx->buf = h_buf; + duk__bw_update_ptrs(thr, bw_ctx, 0, DUK_HBUFFER_DYNAMIC_GET_SIZE(h_buf)); +} + +DUK_INTERNAL void duk_bw_init_pushbuf(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t buf_size) { + duk_context *ctx; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw_ctx != NULL); + ctx = (duk_context *) thr; + + (void) duk_push_dynamic_buffer(ctx, buf_size); + bw_ctx->buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1); + duk__bw_update_ptrs(thr, bw_ctx, 0, buf_size); +} + +/* Resize target buffer for requested size. Called by the macro only when the + * fast path test (= there is space) fails. + */ +DUK_INTERNAL duk_uint8_t *duk_bw_resize(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t sz) { + duk_size_t curr_off; + duk_size_t add_sz; + duk_size_t new_sz; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw_ctx != NULL); + + /* We could do this operation without caller updating bw_ctx->ptr, + * but by writing it back here we can share code better. + */ + + curr_off = (duk_size_t) (bw_ctx->p - bw_ctx->p_base); + add_sz = (curr_off >> DUK_BW_SPARE_SHIFT) + DUK_BW_SPARE_ADD; + new_sz = curr_off + sz + add_sz; + if (new_sz < curr_off) { + /* overflow */ + DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_BUFFER_TOO_LONG); + return NULL; /* not reachable */ + } +#if 0 /* for manual torture testing: tight allocation, useful with valgrind */ + new_sz = curr_off + sz; +#endif + + /* This is important to ensure dynamic buffer data pointer is not + * NULL (which is possible if buffer size is zero), which in turn + * causes portability issues with e.g. memmove() and memcpy(). + */ + DUK_ASSERT(new_sz >= 1); + + DUK_DD(DUK_DDPRINT("resize bufferwriter from %ld to %ld (add_sz=%ld)", (long) curr_off, (long) new_sz, (long) add_sz)); + + duk_hbuffer_resize(thr, bw_ctx->buf, new_sz); + duk__bw_update_ptrs(thr, bw_ctx, curr_off, new_sz); + return bw_ctx->p; +} + +/* Make buffer compact, matching current written size. */ +DUK_INTERNAL void duk_bw_compact(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx) { + duk_size_t len; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw_ctx != NULL); + DUK_UNREF(thr); + + len = (duk_size_t) (bw_ctx->p - bw_ctx->p_base); + duk_hbuffer_resize(thr, bw_ctx->buf, len); + duk__bw_update_ptrs(thr, bw_ctx, len, len); +} + +DUK_INTERNAL void duk_bw_write_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t src_off, duk_size_t len) { + duk_uint8_t *p_base; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw != NULL); + DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_UNREF(thr); + + p_base = bw->p_base; + DUK_MEMCPY((void *) bw->p, + (const void *) (p_base + src_off), + (size_t) len); + bw->p += len; +} + +DUK_INTERNAL void duk_bw_write_ensure_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t src_off, duk_size_t len) { + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw != NULL); + DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_UNREF(thr); + + DUK_BW_ENSURE(thr, bw, len); + duk_bw_write_raw_slice(thr, bw, src_off, len); +} + +DUK_INTERNAL void duk_bw_insert_raw_bytes(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, const duk_uint8_t *buf, duk_size_t len) { + duk_uint8_t *p_base; + duk_size_t buf_sz, move_sz; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw != NULL); + DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(buf != NULL); + DUK_UNREF(thr); + + p_base = bw->p_base; + buf_sz = bw->p - p_base; + move_sz = buf_sz - dst_off; + + DUK_ASSERT(p_base != NULL); /* buffer size is >= 1 */ + DUK_MEMMOVE((void *) (p_base + dst_off + len), + (const void *) (p_base + dst_off), + (size_t) move_sz); + DUK_MEMCPY((void *) (p_base + dst_off), + (const void *) buf, + (size_t) len); + bw->p += len; +} + +DUK_INTERNAL void duk_bw_insert_ensure_bytes(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, const duk_uint8_t *buf, duk_size_t len) { + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw != NULL); + DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(buf != NULL); + DUK_UNREF(thr); + + DUK_BW_ENSURE(thr, bw, len); + duk_bw_insert_raw_bytes(thr, bw, dst_off, buf, len); +} + +DUK_INTERNAL void duk_bw_insert_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, duk_size_t src_off, duk_size_t len) { + duk_uint8_t *p_base; + duk_size_t buf_sz, move_sz; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw != NULL); + DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_UNREF(thr); + + p_base = bw->p_base; + + /* Don't support "straddled" source now. */ + DUK_ASSERT(dst_off <= src_off || dst_off >= src_off + len); + + if (dst_off <= src_off) { + /* Target is before source. Source offset is expressed as + * a "before change" offset. Account for the memmove. + */ + src_off += len; + } + + buf_sz = bw->p - p_base; + move_sz = buf_sz - dst_off; + + DUK_ASSERT(p_base != NULL); /* buffer size is >= 1 */ + DUK_MEMMOVE((void *) (p_base + dst_off + len), + (const void *) (p_base + dst_off), + (size_t) move_sz); + DUK_MEMCPY((void *) (p_base + dst_off), + (const void *) (p_base + src_off), + (size_t) len); + bw->p += len; +} + +DUK_INTERNAL void duk_bw_insert_ensure_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, duk_size_t src_off, duk_size_t len) { + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw != NULL); + DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_UNREF(thr); + + /* Don't support "straddled" source now. */ + DUK_ASSERT(dst_off <= src_off || dst_off >= src_off + len); + + DUK_BW_ENSURE(thr, bw, len); + duk_bw_insert_raw_slice(thr, bw, dst_off, src_off, len); +} + +DUK_INTERNAL duk_uint8_t *duk_bw_insert_raw_area(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len) { + duk_uint8_t *p_base, *p_dst, *p_src; + duk_size_t buf_sz, move_sz; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw != NULL); + DUK_ASSERT(off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_UNREF(thr); + + p_base = bw->p_base; + buf_sz = bw->p - p_base; + move_sz = buf_sz - off; + p_dst = p_base + off + len; + p_src = p_base + off; + DUK_MEMMOVE((void *) p_dst, (const void *) p_src, (size_t) move_sz); + return p_src; /* point to start of 'reserved area' */ +} + +DUK_INTERNAL duk_uint8_t *duk_bw_insert_ensure_area(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len) { + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw != NULL); + DUK_ASSERT(off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_UNREF(thr); + + DUK_BW_ENSURE(thr, bw, len); + return duk_bw_insert_raw_area(thr, bw, off, len); +} + +DUK_INTERNAL void duk_bw_remove_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len) { + duk_size_t move_sz; + + duk_uint8_t *p_base; + duk_uint8_t *p_src; + duk_uint8_t *p_dst; + + DUK_ASSERT(thr != NULL); + DUK_ASSERT(bw != NULL); + DUK_ASSERT(off <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_ASSERT(off + len <= DUK_BW_GET_SIZE(thr, bw)); + DUK_UNREF(thr); + + p_base = bw->p_base; + p_dst = p_base + off; + p_src = p_dst + len; + move_sz = (duk_size_t) (bw->p - p_src); + DUK_MEMMOVE((void *) p_dst, + (const void *) p_src, + (size_t) move_sz); + bw->p -= len; +} + +/* + * Macro support functions for reading/writing raw data. + * + * These are done using mempcy to ensure they're valid even for unaligned + * reads/writes on platforms where alignment counts. On x86 at least gcc + * is able to compile these into a bswap+mov. "Always inline" is used to + * ensure these macros compile to minimal code. + * + * Not really bufwriter related, but currently used together. + */ + +DUK_INTERNAL DUK_ALWAYS_INLINE duk_uint16_t duk_raw_read_u16_be(duk_uint8_t **p) { + union { + duk_uint8_t b[2]; + duk_uint16_t x; + } u; + + DUK_MEMCPY((void *) u.b, (const void *) (*p), (size_t) 2); + u.x = DUK_NTOH16(u.x); + *p += 2; + return u.x; +} + +DUK_INTERNAL DUK_ALWAYS_INLINE duk_uint32_t duk_raw_read_u32_be(duk_uint8_t **p) { + union { + duk_uint8_t b[4]; + duk_uint32_t x; + } u; + + DUK_MEMCPY((void *) u.b, (const void *) (*p), (size_t) 4); + u.x = DUK_NTOH32(u.x); + *p += 4; + return u.x; +} + +DUK_INTERNAL DUK_ALWAYS_INLINE duk_double_t duk_raw_read_double_be(duk_uint8_t **p) { + duk_double_union du; + union { + duk_uint8_t b[4]; + duk_uint32_t x; + } u; + + DUK_MEMCPY((void *) u.b, (const void *) (*p), (size_t) 4); + u.x = DUK_NTOH32(u.x); + du.ui[DUK_DBL_IDX_UI0] = u.x; + DUK_MEMCPY((void *) u.b, (const void *) (*p + 4), (size_t) 4); + u.x = DUK_NTOH32(u.x); + du.ui[DUK_DBL_IDX_UI1] = u.x; + *p += 8; + + return du.d; +} + +DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_u16_be(duk_uint8_t **p, duk_uint16_t val) { + union { + duk_uint8_t b[2]; + duk_uint16_t x; + } u; + + u.x = DUK_HTON16(val); + DUK_MEMCPY((void *) (*p), (const void *) u.b, (size_t) 2); + *p += 2; +} + +DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_u32_be(duk_uint8_t **p, duk_uint32_t val) { + union { + duk_uint8_t b[4]; + duk_uint32_t x; + } u; + + u.x = DUK_HTON32(val); + DUK_MEMCPY((void *) (*p), (const void *) u.b, (size_t) 4); + *p += 4; +} + +DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_double_be(duk_uint8_t **p, duk_double_t val) { + duk_double_union du; + union { + duk_uint8_t b[4]; + duk_uint32_t x; + } u; + + du.d = val; + u.x = du.ui[DUK_DBL_IDX_UI0]; + u.x = DUK_HTON32(u.x); + DUK_MEMCPY((void *) (*p), (const void *) u.b, (size_t) 4); + u.x = du.ui[DUK_DBL_IDX_UI1]; + u.x = DUK_HTON32(u.x); + DUK_MEMCPY((void *) (*p + 4), (const void *) u.b, (size_t) 4); + *p += 8; +} #line 1 "duk_util_hashbytes.c" /* * Hash function duk_util_hashbytes(). @@ -72562,6 +88010,7 @@ DUK_INTERNAL void duk_be_finish(duk_bitencoder_ctx *ctx) { /* include removed: duk_internal.h */ +#if defined(DUK_USE_STRHASH_DENSE) /* 'magic' constants for Murmurhash2 */ #define DUK__MAGIC_M ((duk_uint32_t) 0x5bd1e995UL) #define DUK__MAGIC_R 24 @@ -72576,7 +88025,7 @@ DUK_INTERNAL duk_uint32_t duk_util_hashbytes(const duk_uint8_t *data, duk_size_t * OK as long as it is consistent for a build. */ #ifdef DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS - duk_uint32_t k = *((duk_uint32_t *) data); + duk_uint32_t k = *((const duk_uint32_t *) (const void *) data); #else duk_uint32_t k = ((duk_uint32_t) data[0]) | (((duk_uint32_t) data[1]) << 8) | @@ -72606,6 +88055,7 @@ DUK_INTERNAL duk_uint32_t duk_util_hashbytes(const duk_uint8_t *data, duk_size_t return h; } +#endif /* DUK_USE_STRHASH_DENSE */ #line 1 "duk_util_tinyrandom.c" /* * A tiny random number generator. diff --git a/src/duktape/duktape/duktape.h b/src/duktape/duktape/duktape.h index 4fe4cddcfd..7f7a7c3273 100644 --- a/src/duktape/duktape/duktape.h +++ b/src/duktape/duktape/duktape.h @@ -1,11 +1,12 @@ /* - * Duktape public API for Duktape 1.2.2. + * Duktape public API for Duktape 1.4.0. * See the API reference for documentation on call semantics. * The exposed API is inside the DUK_API_PUBLIC_H_INCLUDED * include guard. Other parts of the header are Duktape * internal and related to platform/compiler/feature detection. * - * Git commit 5f4302c732d21b3b721db3d3473db32e4eb92470 (v1.2.2). + * Git commit cad6f595382a0cc1a7e4207794ade5be11b3e397 (v1.4.0). + * Git branch master. * * See Duktape AUTHORS.rst and LICENSE.txt for copyright and * licensing information. @@ -19,7 +20,7 @@ * * (http://opensource.org/licenses/MIT) * - * Copyright (c) 2013-2015 by Duktape authors (see AUTHORS.rst) + * Copyright (c) 2013-2016 by Duktape authors (see AUTHORS.rst) * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal @@ -38,7 +39,6 @@ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. - * */ /* AUTHORS.rst */ @@ -60,14 +60,18 @@ * Please include an e-mail address, a link to your GitHub profile, or something * similar to allow your contribution to be identified accurately. * - * The following people have contributed code and agreed to irrevocably license - * their contributions under the Duktape ``LICENSE.txt`` (in order of appearance): + * The following people have contributed code, website contents, or Wiki contents, + * and agreed to irrevocably license their contributions under the Duktape + * ``LICENSE.txt`` (in order of appearance): * * * Sami Vaarala * * Niki Dobrev * * Andreas \u00d6man * * L\u00e1szl\u00f3 Lang\u00f3 * * Legimet + * * Karl Skomski + * * Bruce Pascoe + * * Ren\u00e9 Hollander * * Other contributions * =================== @@ -92,7 +96,7 @@ * * Josh Engebretson (https://github.com/JoshEngebretson) * * Remo Eichenberger (https://github.com/remoe) * * Mamod Mehyar (https://github.com/mamod) - * * David Demelier (https://github.com/hftmarkand) + * * David Demelier (https://github.com/markand) * * Tim Caswell (https://github.com/creationix) * * Mitchell Blank Jr (https://github.com/mitchblank) * * https://github.com/yushli @@ -101,6 +105,10 @@ * * Joshua Peek (https://github.com/josh) * * Bruce E. Pascoe (https://github.com/fatcerberus) * * https://github.com/Kelledin + * * https://github.com/sstruchtrup + * * Michael Drake (https://github.com/tlsa) + * * https://github.com/chris-y + * * Laurent Zubiaur (https://github.com/lzubiaur) * * If you are accidentally missing from this list, send me an e-mail * (``sami.vaarala@iki.fi``) and I'll fix the omission. @@ -111,2979 +119,11 @@ #define DUK_SINGLE_FILE -/* - * Determine platform features, select feature selection defines - * (e.g. _XOPEN_SOURCE), include system headers, and define DUK_USE_XXX - * defines which are (only) checked in Duktape internal code for - * activated features. Duktape feature selection is based on automatic - * feature detection, user supplied DUK_OPT_xxx defines, and optionally - * a "duk_custom.h" user header (if DUK_OPT_HAVE_CUSTOM_H is defined). - * - * When compiling Duktape, DUK_COMPILING_DUKTAPE is set, and this file - * is included before any system headers are included. Feature selection - * defines (e.g. _XOPEN_SOURCE) are defined here before any system headers - * are included (which is a requirement for system headers to work correctly). - * This file is responsible for including all system headers and contains - * all platform dependent cruft in general. When compiling user code, - * DUK_COMPILING_DUKTAPE is not defined, and we must avoid e.g. defining - * unnecessary feature selection defines. - * - * The general order of handling: - * - Compiler feature detection (require no includes) - * - Intermediate platform detection (-> easier platform defines) - * - Platform detection, system includes, byte order detection, etc - * - ANSI C wrappers (e.g. DUK_MEMCMP), wrappers for constants, etc - * - DUK_USE_xxx defines are resolved based on input defines - * - Duktape Date provider settings - * - Final sanity checks - * - * DUK_F_XXX are internal feature detection macros which should not be - * used outside this header. - * - * Useful resources: - * - * http://sourceforge.net/p/predef/wiki/Home/ - * http://sourceforge.net/p/predef/wiki/Architectures/ - * http://stackoverflow.com/questions/5919996/how-to-detect-reliably-mac-os-x-ios-linux-windows-in-c-preprocessor - * http://en.wikipedia.org/wiki/C_data_types#Fixed-width_integer_types - * - * Preprocessor defines available in a particular GCC: - * - * gcc -dM -E - = 199901L) -#define DUK_F_C99 -#endif - -#undef DUK_F_CPP -#if defined(__cplusplus) -#define DUK_F_CPP -#endif - -#undef DUK_F_CPP11 -#if defined(__cplusplus) && (__cplusplus >= 201103L) -#define DUK_F_CPP11 -#endif - -/* - * Provides the duk_rdtsc() inline function (if available), limited to - * GCC C99. - * - * See: http://www.mcs.anl.gov/~kazutomo/rdtsc.html - */ - -/* XXX: more accurate detection of what gcc versions work; more inline - * asm versions for other compilers. - */ -#if defined(__GNUC__) && defined(__i386__) && defined(DUK_F_C99) && \ - !defined(__cplusplus) /* unsigned long long not standard */ -static __inline__ unsigned long long duk_rdtsc(void) { - unsigned long long int x; - __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x)); - return x; -} -#define DUK_RDTSC_AVAILABLE 1 -#elif defined(__GNUC__) && defined(__x86_64__) && defined(DUK_F_C99) && \ - !defined(__cplusplus) /* unsigned long long not standard */ -static __inline__ unsigned long long duk_rdtsc(void) { - unsigned hi, lo; - __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi)); - return ((unsigned long long) lo) | (((unsigned long long) hi) << 32); -} -#define DUK_RDTSC_AVAILABLE 1 -#else -/* not available */ -#undef DUK_RDTSC_AVAILABLE -#endif - -/* - * Intermediate platform, architecture, and compiler detection. These are - * hopelessly intertwined - e.g. architecture defines depend on compiler etc. - * - * Provide easier defines for platforms and compilers which are often tricky - * or verbose to detect. The intent is not to provide intermediate defines for - * all features; only if existing feature defines are inconvenient. - */ - -/* Intel x86 (32-bit) */ -#if defined(i386) || defined(__i386) || defined(__i386__) || \ - defined(__i486__) || defined(__i586__) || defined(__i686__) || \ - defined(__IA32__) || defined(_M_IX86) || defined(__X86__) || \ - defined(_X86_) || defined(__THW_INTEL__) || defined(__I86__) -#define DUK_F_X86 -#endif - -/* AMD64 (64-bit) */ -#if defined(__amd64__) || defined(__amd64) || \ - defined(__x86_64__) || defined(__x86_64) || \ - defined(_M_X64) || defined(_M_AMD64) -#define DUK_F_X64 -#endif - -/* X32: 64-bit with 32-bit pointers (allows packed tvals). X32 support is - * not very mature yet. - * - * https://sites.google.com/site/x32abi/ - */ -#if defined(DUK_F_X64) && \ - (defined(_ILP32) || defined(__ILP32__)) -#define DUK_F_X32 -/* define only one of: DUK_F_X86, DUK_F_X32, or DUK_F_X64 */ -#undef DUK_F_X64 -#undef DUK_F_X86 -#endif - -/* ARM */ -#if defined(__arm__) || defined(__thumb__) || defined(_ARM) || defined(_M_ARM) -#define DUK_F_ARM -#endif - -/* MIPS */ -/* Related defines: __MIPSEB__, __MIPSEL__, __mips_isa_rev, __LP64__ */ -#if defined(__mips__) || defined(mips) || defined(_MIPS_ISA) || \ - defined(_R3000) || defined(_R4000) || defined(_R5900) || \ - defined(_MIPS_ISA_MIPS1) || defined(_MIPS_ISA_MIPS2) || \ - defined(_MIPS_ISA_MIPS3) || defined(_MIPS_ISA_MIPS4) || \ - defined(__mips) || defined(__MIPS__) -#define DUK_F_MIPS -#if defined(__LP64__) || defined(__mips64) || defined(__mips64__) || \ - defined(__mips_n64) -#define DUK_F_MIPS64 -#else -#define DUK_F_MIPS32 -#endif -#endif - -/* SuperH */ -#if defined(__sh__) || \ - defined(__sh1__) || defined(__SH1__) || \ - defined(__sh2__) || defined(__SH2__) || \ - defined(__sh3__) || defined(__SH3__) || \ - defined(__sh4__) || defined(__SH4__) || \ - defined(__sh5__) || defined(__SH5__) -#define DUK_F_SUPERH -#endif - -/* Motorola 68K. Not defined by VBCC, so user must define one of these - * manually when using VBCC. - */ -#if defined(__m68k__) || defined(M68000) || defined(__MC68K__) -#define DUK_F_M68K -#endif - -/* Linux */ -#if defined(__linux) || defined(__linux__) || defined(linux) -#define DUK_F_LINUX -#endif - -/* FreeBSD */ -#if defined(__FreeBSD__) || defined(__FreeBSD) -#define DUK_F_FREEBSD -#endif - -/* NetBSD */ -#if defined(__NetBSD__) || defined(__NetBSD) -#define DUK_F_NETBSD -#endif - -/* OpenBSD */ -#if defined(__OpenBSD__) || defined(__OpenBSD) -#define DUK_F_OPENBSD -#endif - -/* BSD variant */ -#if defined(DUK_F_FREEBSD) || defined(DUK_F_NETBSD) || defined(DUK_F_OPENBSD) || \ - defined(__bsdi__) || defined(__DragonFly__) -#define DUK_F_BSD -#endif - -/* Generic Unix (includes Cygwin) */ -#if defined(__unix) || defined(__unix__) || defined(unix) || \ - defined(DUK_F_LINUX) || defined(DUK_F_BSD) -#define DUK_F_UNIX -#endif - -/* Cygwin */ -#if defined(__CYGWIN__) -#define DUK_F_CYGWIN -#endif - -/* Windows (32-bit or above) */ -#if defined(_WIN32) || defined(WIN32) || defined(_WIN64) || defined(WIN64) || \ - defined(__WIN32__) || defined(__TOS_WIN__) || defined(__WINDOWS__) -#define DUK_F_WINDOWS -#endif - -#if defined(__APPLE__) -#define DUK_F_APPLE -#endif - -/* Atari ST TOS. __TOS__ defined by PureC (which doesn't work as a target now - * because int is 16-bit, to be fixed). No platform define in VBCC apparently, - * so to use with VBCC, user must define '__TOS__' manually. - */ -#if defined(__TOS__) -#define DUK_F_TOS -#endif - -/* AmigaOS. Neither AMIGA nor __amigaos__ is defined on VBCC, so user must - * define 'AMIGA' manually. - */ -#if defined(AMIGA) || defined(__amigaos__) -#define DUK_F_AMIGAOS -#endif - -/* Flash player (e.g. Crossbridge) */ -#if defined(__FLASHPLAYER__) -#define DUK_F_FLASHPLAYER -#endif - -/* Emscripten (provided explicitly by user), improve if possible */ -#if defined(EMSCRIPTEN) -#define DUK_F_EMSCRIPTEN -#endif - -/* QNX */ -#if defined(__QNX__) -#define DUK_F_QNX -#endif - -/* TI-Nspire (using Ndless) */ -#if defined(_TINSPIRE) -#define DUK_F_TINSPIRE -#endif - -/* GCC and GCC version convenience define. */ -#if defined(__GNUC__) -#define DUK_F_GCC -#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) -/* Convenience, e.g. gcc 4.5.1 == 40501; http://stackoverflow.com/questions/6031819/emulating-gccs-builtin-unreachable */ -#define DUK_F_GCC_VERSION (__GNUC__ * 10000L + __GNUC_MINOR__ * 100L + __GNUC_PATCHLEVEL__) -#else -#error cannot figure out gcc version -#endif -#endif - -/* Clang */ -#if defined(__clang__) -#define DUK_F_CLANG -/* It seems clang also defines __GNUC__, so undo the GCC detection. */ -#if defined(DUK_F_GCC) -#undef DUK_F_GCC -#endif -#if defined(DUK_F_GCC_VERSION) -#undef DUK_F_GCC_VERSION -#endif -#endif - -/* MSVC */ -#if defined(_MSC_VER) -/* MSVC preprocessor defines: http://msdn.microsoft.com/en-us/library/b0084kay.aspx - * _MSC_FULL_VER includes the build number, but it has at least two formats, see e.g. - * BOOST_MSVC_FULL_VER in http://www.boost.org/doc/libs/1_52_0/boost/config/compiler/visualc.hpp - */ -#define DUK_F_MSVC -#if defined(_MSC_FULL_VER) -#if (_MSC_FULL_VER > 100000000) -#define DUK_F_MSVC_FULL_VER _MSC_FULL_VER -#else -#define DUK_F_MSCV_FULL_VER (_MSC_FULL_VER * 10) -#endif -#endif -#endif /* _MSC_VER */ - -/* MinGW */ -#if defined(__MINGW32__) || defined(__MINGW64__) -/* NOTE: Also GCC flags are detected (DUK_F_GCC etc). */ -#define DUK_F_MINGW -#endif - -/* BCC (Bruce's C compiler): this is a "torture target" for compilation */ -#if defined(__BCC__) || defined(__BCC_VERSION__) -#define DUK_F_BCC -#endif - -#if defined(__VBCC__) -#define DUK_F_VBCC -#endif - -#if (defined(DUK_F_C99) || defined(DUK_F_CPP11)) && \ - !defined(DUK_F_BCC) -/* ULL / LL preprocessor constants should be avoided because they're not - * always available. With suitable options, some compilers will support - * 64-bit integer types but won't support ULL / LL preprocessor constants. - * Assume C99/C++11 environments have these. However, BCC is nominally - * C99 but doesn't support these constants. - */ -#define DUK_F_ULL_CONSTS -#endif - -/* - * Platform detection, system includes, Date provider selection. - * - * Feature selection (e.g. _XOPEN_SOURCE) must happen before any system - * headers are included. This header should avoid providing any feature - * selection defines when compiling user code (only when compiling Duktape - * itself). If a feature selection option is required for user code to - * compile correctly (e.g. it is needed for type detection), it should - * probably be -checked- here, not defined here. - * - * Date provider selection seems a bit out-of-place here, but since - * the date headers and provider functions are heavily platform - * specific, there's little point in duplicating the platform if-else - * ladder. All platform specific Date provider functions are in - * duk_bi_date.c; here we provide appropriate #defines to enable them, - * and include all the necessary system headers so that duk_bi_date.c - * compiles. Date "providers" are: - * - * NOW = getting current time (required) - * TZO = getting local time offset (required) - * PRS = parse datetime (optional) - * FMT = format datetime (optional) - * - * There's a lot of duplication here, unfortunately, because many - * platforms have similar (but not identical) headers, Date providers, - * etc. The duplication could be removed by more complicated nested - * #ifdefs, but it would then be more difficult to make fixes which - * affect only a specific platform. - * - * XXX: add a way to provide custom functions to provide the critical - * primitives; this would be convenient when porting to unknown platforms - * (rather than muck with Duktape internals). - */ - -#if defined(DUK_COMPILING_DUKTAPE) && \ - (defined(DUK_F_LINUX) || defined(DUK_F_EMSCRIPTEN)) -/* A more recent Emscripten (2014-05) seems to lack "linux" environment - * defines, so check for Emscripten explicitly. - */ -#ifndef _POSIX_C_SOURCE -#define _POSIX_C_SOURCE 200809L -#endif -#ifndef _GNU_SOURCE -#define _GNU_SOURCE /* e.g. getdate_r */ -#endif -#ifndef _XOPEN_SOURCE -#define _XOPEN_SOURCE /* e.g. strptime */ -#endif -#endif - -#if defined(DUK_F_QNX) && defined(DUK_COMPILING_DUKTAPE) -/* See: /opt/qnx650/target/qnx6/usr/include/sys/platform.h */ -#define _XOPEN_SOURCE 600 -#define _POSIX_C_SOURCE 200112L -#endif - -#undef DUK_F_MSVC_CRT_SECURE -#if defined(DUK_F_WINDOWS) && defined(_MSC_VER) -/* http://msdn.microsoft.com/en-us/library/8ef0s5kh.aspx - * http://msdn.microsoft.com/en-us/library/wd3wzwts.aspx - * Seem to be available since VS2005. - */ -#if (_MSC_VER >= 1400) -/* VS2005+, secure CRT functions are preferred. Windows Store applications - * (and probably others) should use these. - */ -#define DUK_F_MSVC_CRT_SECURE -#endif -#if (_MSC_VER < 1700) -/* VS2012+ has stdint.h, < VS2012 does not (but it's available for download). */ -#define DUK_F_NO_STDINT_H -#endif -/* Initial fix: disable secure CRT related warnings when compiling Duktape - * itself (must be defined before including Windows headers). Don't define - * for user code including duktape.h. - */ -#if defined(DUK_COMPILING_DUKTAPE) && !defined(_CRT_SECURE_NO_WARNINGS) -#define _CRT_SECURE_NO_WARNINGS -#endif -#endif /* DUK_F_WINDOWS && _MSC_VER */ - -#if defined(DUK_F_TOS) || defined(DUK_F_BCC) -#define DUK_F_NO_STDINT_H -#endif - -/* Workaround for older C++ compilers before including , - * see e.g.: https://sourceware.org/bugzilla/show_bug.cgi?id=15366 - */ -#if defined(__cplusplus) && !defined(__STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS -#endif -#if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS) -#define __STDC_CONSTANT_MACROS -#endif - -#if defined(__APPLE__) -/* Mac OSX, iPhone, Darwin */ -#define DUK_USE_DATE_NOW_GETTIMEOFDAY -#define DUK_USE_DATE_TZO_GMTIME_R -#define DUK_USE_DATE_PRS_STRPTIME -#define DUK_USE_DATE_FMT_STRFTIME -#include -#include -#include -#include -#include -#include -#elif defined(DUK_F_OPENBSD) -/* http://www.monkey.org/openbsd/archive/ports/0401/msg00089.html */ -#define DUK_USE_DATE_NOW_GETTIMEOFDAY -#define DUK_USE_DATE_TZO_GMTIME_R -#define DUK_USE_DATE_PRS_STRPTIME -#define DUK_USE_DATE_FMT_STRFTIME -#include -#include -#include -#include -#include -#include -#elif defined(DUK_F_BSD) -/* other BSD */ -#define DUK_USE_DATE_NOW_GETTIMEOFDAY -#define DUK_USE_DATE_TZO_GMTIME_R -#define DUK_USE_DATE_PRS_STRPTIME -#define DUK_USE_DATE_FMT_STRFTIME -#include -#include -#include -#include -#include -#include -#elif defined(DUK_F_TOS) -/* Atari ST TOS */ -#define DUK_USE_DATE_NOW_TIME -#define DUK_USE_DATE_TZO_GMTIME -/* no parsing (not an error) */ -#define DUK_USE_DATE_FMT_STRFTIME -#include -#include -#elif defined(DUK_F_AMIGAOS) -#if defined(DUK_F_M68K) -/* AmigaOS on M68k */ -#define DUK_USE_DATE_NOW_TIME -#define DUK_USE_DATE_TZO_GMTIME -/* no parsing (not an error) */ -#define DUK_USE_DATE_FMT_STRFTIME -#include -#include -#else -#error AmigaOS but not M68K, not supported now -#endif -#elif defined(DUK_F_WINDOWS) -/* Windows 32-bit and 64-bit are currently the same. */ -/* MSVC does not have sys/param.h */ -#define DUK_USE_DATE_NOW_WINDOWS -#define DUK_USE_DATE_TZO_WINDOWS -/* Note: PRS and FMT are intentionally left undefined for now. This means - * there is no platform specific date parsing/formatting but there is still - * the ISO 8601 standard format. - */ -#include -#include -#elif defined(DUK_F_FLASHPLAYER) -/* Crossbridge */ -#define DUK_USE_DATE_NOW_GETTIMEOFDAY -#define DUK_USE_DATE_TZO_GMTIME_R -#define DUK_USE_DATE_PRS_STRPTIME -#define DUK_USE_DATE_FMT_STRFTIME -#include -#include -#include -#include -#include -#elif defined(DUK_F_QNX) -#define DUK_USE_DATE_NOW_GETTIMEOFDAY -#define DUK_USE_DATE_TZO_GMTIME_R -#define DUK_USE_DATE_PRS_STRPTIME -#define DUK_USE_DATE_FMT_STRFTIME -#include -#include -#include -#include -#include -#elif defined(DUK_F_TINSPIRE) -#define DUK_USE_DATE_NOW_GETTIMEOFDAY -#define DUK_USE_DATE_TZO_GMTIME_R -#define DUK_USE_DATE_PRS_STRPTIME -#define DUK_USE_DATE_FMT_STRFTIME -#include -#include -#include -#include -#include -#elif defined(DUK_F_LINUX) -#define DUK_USE_DATE_NOW_GETTIMEOFDAY -#define DUK_USE_DATE_TZO_GMTIME_R -#define DUK_USE_DATE_PRS_STRPTIME -#define DUK_USE_DATE_FMT_STRFTIME -#include -#if defined(DUK_F_BCC) -/* no endian.h */ -#else -#include -#endif /* DUK_F_BCC */ -#include -#include -#include -#include -#elif defined(__posix) -/* POSIX */ -#define DUK_USE_DATE_NOW_GETTIMEOFDAY -#define DUK_USE_DATE_TZO_GMTIME_R -#define DUK_USE_DATE_PRS_STRPTIME -#define DUK_USE_DATE_FMT_STRFTIME -#include -#include -#include -#include -#include -#include -#elif defined(DUK_F_CYGWIN) -/* Cygwin -- don't use strptime() for now */ -#define DUK_USE_DATE_NOW_GETTIMEOFDAY -#define DUK_USE_DATE_TZO_GMTIME_R -#define DUK_USE_DATE_FMT_STRFTIME -#include -#include -#include -#include -#include -#include -#else -/* Other UNIX, hopefully others */ -#define DUK_USE_DATE_NOW_GETTIMEOFDAY -#define DUK_USE_DATE_TZO_GMTIME_R -#define DUK_USE_DATE_PRS_STRPTIME -#define DUK_USE_DATE_FMT_STRFTIME -#include -#if defined(DUK_F_BCC) -/* no endian.h */ -#else -#include -#endif /* DUK_F_BCC */ -#include -#include -#include -#include -#endif - -/* Shared includes */ -#include -#include -#include -#include /* varargs */ -#include -#include /* e.g. ptrdiff_t */ -#if defined(DUK_F_NO_STDINT_H) -/* stdint.h not available */ -#else -/* Technically C99 (C++11) but found in many systems. Note the workaround - * above for some C++ compilers (__STDC_LIMIT_MACROS etc). - */ -#include -#endif -#include - -/* - * Detection for specific libc variants (like uclibc) and other libc specific - * features. Potentially depends on the #includes above. - */ - -#if defined(__UCLIBC__) -#define DUK_F_UCLIBC -#endif - -/* - * Wrapper typedefs and constants for integer types, also sanity check types. - * - * C99 typedefs are quite good but not always available, and we want to avoid - * forcibly redefining the C99 typedefs. So, there are Duktape wrappers for - * all C99 typedefs and Duktape code should only use these typedefs. Type - * detection when C99 is not supported is best effort and may end up detecting - * some types incorrectly. - * - * Pointer sizes are a portability problem: pointers to different types may - * have a different size and function pointers are very difficult to manage - * portably. - * - * http://en.wikipedia.org/wiki/C_data_types#Fixed-width_integer_types - * - * Note: there's an interesting corner case when trying to define minimum - * signed integer value constants which leads to the current workaround of - * defining e.g. -0x80000000 as (-0x7fffffffL - 1L). See doc/code-issues.txt - * for a longer discussion. - * - * Note: avoid typecasts and computations in macro integer constants as they - * can then no longer be used in macro relational expressions (such as - * #if DUK_SIZE_MAX < 0xffffffffUL). There is internal code which relies on - * being able to compare DUK_SIZE_MAX against a limit. - */ - -/* XXX: add feature options to force basic types from outside? */ - -#if !defined(INT_MAX) -#error INT_MAX not defined -#endif - -/* Check that architecture is two's complement, standard C allows e.g. - * INT_MIN to be -2**31+1 (instead of -2**31). - */ -#if defined(INT_MAX) && defined(INT_MIN) -#if INT_MAX != -(INT_MIN + 1) -#error platform does not seem complement of two -#endif -#else -#error cannot check complement of two -#endif - -/* Pointer size determination based on architecture. - * XXX: unsure about BCC correctness. - */ -#if defined(DUK_F_X86) || defined(DUK_F_X32) || \ - defined(DUK_F_BCC) || \ - (defined(__WORDSIZE) && (__WORDSIZE == 32)) -#define DUK_F_32BIT_PTRS -#elif defined(DUK_F_X64) || \ - (defined(__WORDSIZE) && (__WORDSIZE == 64)) -#define DUK_F_64BIT_PTRS -#else -/* not sure, not needed with C99 anyway */ -#endif - -/* Intermediate define for 'have inttypes.h' */ -#undef DUK_F_HAVE_INTTYPES -#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ - !(defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC)) -/* vbcc + AmigaOS has C99 but no inttypes.h */ -#define DUK_F_HAVE_INTTYPES -#elif defined(__cplusplus) && (__cplusplus >= 201103L) -/* C++11 apparently ratified stdint.h */ -#define DUK_F_HAVE_INTTYPES -#endif - -/* Basic integer typedefs and limits, preferably from inttypes.h, otherwise - * through automatic detection. - */ -#if defined(DUK_F_HAVE_INTTYPES) -/* C99 or compatible */ - -#define DUK_F_HAVE_64BIT -#include - -typedef uint8_t duk_uint8_t; -typedef int8_t duk_int8_t; -typedef uint16_t duk_uint16_t; -typedef int16_t duk_int16_t; -typedef uint32_t duk_uint32_t; -typedef int32_t duk_int32_t; -typedef uint64_t duk_uint64_t; -typedef int64_t duk_int64_t; -typedef uint_least8_t duk_uint_least8_t; -typedef int_least8_t duk_int_least8_t; -typedef uint_least16_t duk_uint_least16_t; -typedef int_least16_t duk_int_least16_t; -typedef uint_least32_t duk_uint_least32_t; -typedef int_least32_t duk_int_least32_t; -typedef uint_least64_t duk_uint_least64_t; -typedef int_least64_t duk_int_least64_t; -typedef uint_fast8_t duk_uint_fast8_t; -typedef int_fast8_t duk_int_fast8_t; -typedef uint_fast16_t duk_uint_fast16_t; -typedef int_fast16_t duk_int_fast16_t; -typedef uint_fast32_t duk_uint_fast32_t; -typedef int_fast32_t duk_int_fast32_t; -typedef uint_fast64_t duk_uint_fast64_t; -typedef int_fast64_t duk_int_fast64_t; -typedef uintptr_t duk_uintptr_t; -typedef intptr_t duk_intptr_t; -typedef uintmax_t duk_uintmax_t; -typedef intmax_t duk_intmax_t; - -#define DUK_UINT8_MIN 0 -#define DUK_UINT8_MAX UINT8_MAX -#define DUK_INT8_MIN INT8_MIN -#define DUK_INT8_MAX INT8_MAX -#define DUK_UINT_LEAST8_MIN 0 -#define DUK_UINT_LEAST8_MAX UINT_LEAST8_MAX -#define DUK_INT_LEAST8_MIN INT_LEAST8_MIN -#define DUK_INT_LEAST8_MAX INT_LEAST8_MAX -#define DUK_UINT_FAST8_MIN 0 -#define DUK_UINT_FAST8_MAX UINT_FAST8_MAX -#define DUK_INT_FAST8_MIN INT_FAST8_MIN -#define DUK_INT_FAST8_MAX INT_FAST8_MAX -#define DUK_UINT16_MIN 0 -#define DUK_UINT16_MAX UINT16_MAX -#define DUK_INT16_MIN INT16_MIN -#define DUK_INT16_MAX INT16_MAX -#define DUK_UINT_LEAST16_MIN 0 -#define DUK_UINT_LEAST16_MAX UINT_LEAST16_MAX -#define DUK_INT_LEAST16_MIN INT_LEAST16_MIN -#define DUK_INT_LEAST16_MAX INT_LEAST16_MAX -#define DUK_UINT_FAST16_MIN 0 -#define DUK_UINT_FAST16_MAX UINT_FAST16_MAX -#define DUK_INT_FAST16_MIN INT_FAST16_MIN -#define DUK_INT_FAST16_MAX INT_FAST16_MAX -#define DUK_UINT32_MIN 0 -#define DUK_UINT32_MAX UINT32_MAX -#define DUK_INT32_MIN INT32_MIN -#define DUK_INT32_MAX INT32_MAX -#define DUK_UINT_LEAST32_MIN 0 -#define DUK_UINT_LEAST32_MAX UINT_LEAST32_MAX -#define DUK_INT_LEAST32_MIN INT_LEAST32_MIN -#define DUK_INT_LEAST32_MAX INT_LEAST32_MAX -#define DUK_UINT_FAST32_MIN 0 -#define DUK_UINT_FAST32_MAX UINT_FAST32_MAX -#define DUK_INT_FAST32_MIN INT_FAST32_MIN -#define DUK_INT_FAST32_MAX INT_FAST32_MAX -#define DUK_UINT64_MIN 0 -#define DUK_UINT64_MAX UINT64_MAX -#define DUK_INT64_MIN INT64_MIN -#define DUK_INT64_MAX INT64_MAX -#define DUK_UINT_LEAST64_MIN 0 -#define DUK_UINT_LEAST64_MAX UINT_LEAST64_MAX -#define DUK_INT_LEAST64_MIN INT_LEAST64_MIN -#define DUK_INT_LEAST64_MAX INT_LEAST64_MAX -#define DUK_UINT_FAST64_MIN 0 -#define DUK_UINT_FAST64_MAX UINT_FAST64_MAX -#define DUK_INT_FAST64_MIN INT_FAST64_MIN -#define DUK_INT_FAST64_MAX INT_FAST64_MAX - -#define DUK_UINTPTR_MIN 0 -#define DUK_UINTPTR_MAX UINTPTR_MAX -#define DUK_INTPTR_MIN INTPTR_MIN -#define DUK_INTPTR_MAX INTPTR_MAX - -#define DUK_UINTMAX_MIN 0 -#define DUK_UINTMAX_MAX UINTMAX_MAX -#define DUK_INTMAX_MIN INTMAX_MIN -#define DUK_INTMAX_MAX INTMAX_MAX - -#define DUK_SIZE_MIN 0 -#define DUK_SIZE_MAX SIZE_MAX - -#else /* C99 types */ - -/* When C99 types are not available, we use heuristic detection to get - * the basic 8, 16, 32, and (possibly) 64 bit types. The fast/least - * types are then assumed to be exactly the same for now: these could - * be improved per platform but C99 types are very often now available. - * 64-bit types are not available on all platforms; this is OK at least - * on 32-bit platforms. - * - * This detection code is necessarily a bit hacky and can provide typedefs - * and defines that won't work correctly on some exotic platform. - */ - -#if (defined(CHAR_BIT) && (CHAR_BIT == 8)) || \ - (defined(UCHAR_MAX) && (UCHAR_MAX == 255)) -typedef unsigned char duk_uint8_t; -typedef signed char duk_int8_t; -#else -#error cannot detect 8-bit type -#endif - -#if defined(USHRT_MAX) && (USHRT_MAX == 65535UL) -typedef unsigned short duk_uint16_t; -typedef signed short duk_int16_t; -#elif defined(UINT_MAX) && (UINT_MAX == 65535UL) -/* On some platforms int is 16-bit but long is 32-bit (e.g. PureC) */ -typedef unsigned int duk_uint16_t; -typedef signed int duk_int16_t; -#else -#error cannot detect 16-bit type -#endif - -#if defined(UINT_MAX) && (UINT_MAX == 4294967295UL) -typedef unsigned int duk_uint32_t; -typedef signed int duk_int32_t; -#elif defined(ULONG_MAX) && (ULONG_MAX == 4294967295UL) -/* On some platforms int is 16-bit but long is 32-bit (e.g. PureC) */ -typedef unsigned long duk_uint32_t; -typedef signed long duk_int32_t; -#else -#error cannot detect 32-bit type -#endif - -/* 64-bit type detection is a bit tricky. - * - * ULLONG_MAX is a standard define. __LONG_LONG_MAX__ and __ULONG_LONG_MAX__ - * are used by at least GCC (even if system headers don't provide ULLONG_MAX). - * Some GCC variants may provide __LONG_LONG_MAX__ but not __ULONG_LONG_MAX__. - * - * ULL / LL constants are rejected / warned about by some compilers, even if - * the compiler has a 64-bit type and the compiler/system headers provide an - * unsupported constant (ULL/LL)! Try to avoid using ULL / LL constants. - * As a side effect we can only check that e.g. ULONG_MAX is larger than 32 - * bits but can't be sure it is exactly 64 bits. Self tests will catch such - * cases. - */ -#undef DUK_F_HAVE_64BIT -#if !defined(DUK_F_HAVE_64BIT) && defined(ULONG_MAX) -#if (ULONG_MAX > 4294967295UL) -#define DUK_F_HAVE_64BIT -typedef unsigned long duk_uint64_t; -typedef signed long duk_int64_t; -#endif -#endif -#if !defined(DUK_F_HAVE_64BIT) && defined(ULLONG_MAX) -#if (ULLONG_MAX > 4294967295UL) -#define DUK_F_HAVE_64BIT -typedef unsigned long long duk_uint64_t; -typedef signed long long duk_int64_t; -#endif -#endif -#if !defined(DUK_F_HAVE_64BIT) && defined(__ULONG_LONG_MAX__) -#if (__ULONG_LONG_MAX__ > 4294967295UL) -#define DUK_F_HAVE_64BIT -typedef unsigned long long duk_uint64_t; -typedef signed long long duk_int64_t; -#endif -#endif -#if !defined(DUK_F_HAVE_64BIT) && defined(__LONG_LONG_MAX__) -#if (__LONG_LONG_MAX__ > 2147483647L) -#define DUK_F_HAVE_64BIT -typedef unsigned long long duk_uint64_t; -typedef signed long long duk_int64_t; -#endif -#endif -#if !defined(DUK_F_HAVE_64BIT) && \ - (defined(DUK_F_MINGW) || defined(DUK_F_MSVC)) -/* Both MinGW and MSVC have a 64-bit type. */ -#define DUK_F_HAVE_64BIT -typedef unsigned long duk_uint64_t; -typedef signed long duk_int64_t; -#endif -#if !defined(DUK_F_HAVE_64BIT) -/* cannot detect 64-bit type, not always needed so don't error */ -#endif - -typedef duk_uint8_t duk_uint_least8_t; -typedef duk_int8_t duk_int_least8_t; -typedef duk_uint16_t duk_uint_least16_t; -typedef duk_int16_t duk_int_least16_t; -typedef duk_uint32_t duk_uint_least32_t; -typedef duk_int32_t duk_int_least32_t; -typedef duk_uint8_t duk_uint_fast8_t; -typedef duk_int8_t duk_int_fast8_t; -typedef duk_uint16_t duk_uint_fast16_t; -typedef duk_int16_t duk_int_fast16_t; -typedef duk_uint32_t duk_uint_fast32_t; -typedef duk_int32_t duk_int_fast32_t; -#if defined(DUK_F_HAVE_64BIT) -typedef duk_uint64_t duk_uint_least64_t; -typedef duk_int64_t duk_int_least64_t; -typedef duk_uint64_t duk_uint_fast64_t; -typedef duk_int64_t duk_int_fast64_t; -#endif -#if defined(DUK_F_HAVE_64BIT) -typedef duk_uint64_t duk_uintmax_t; -typedef duk_int64_t duk_intmax_t; -#else -typedef duk_uint32_t duk_uintmax_t; -typedef duk_int32_t duk_intmax_t; -#endif - -/* Note: the funny looking computations for signed minimum 16-bit, 32-bit, and - * 64-bit values are intentional as the obvious forms (e.g. -0x80000000L) are - * -not- portable. See code-issues.txt for a detailed discussion. - */ -#define DUK_UINT8_MIN 0UL -#define DUK_UINT8_MAX 0xffUL -#define DUK_INT8_MIN (-0x80L) -#define DUK_INT8_MAX 0x7fL -#define DUK_UINT_LEAST8_MIN 0UL -#define DUK_UINT_LEAST8_MAX 0xffUL -#define DUK_INT_LEAST8_MIN (-0x80L) -#define DUK_INT_LEAST8_MAX 0x7fL -#define DUK_UINT_FAST8_MIN 0UL -#define DUK_UINT_FAST8_MAX 0xffUL -#define DUK_INT_FAST8_MIN (-0x80L) -#define DUK_INT_FAST8_MAX 0x7fL -#define DUK_UINT16_MIN 0UL -#define DUK_UINT16_MAX 0xffffUL -#define DUK_INT16_MIN (-0x7fffL - 1L) -#define DUK_INT16_MAX 0x7fffL -#define DUK_UINT_LEAST16_MIN 0UL -#define DUK_UINT_LEAST16_MAX 0xffffUL -#define DUK_INT_LEAST16_MIN (-0x7fffL - 1L) -#define DUK_INT_LEAST16_MAX 0x7fffL -#define DUK_UINT_FAST16_MIN 0UL -#define DUK_UINT_FAST16_MAX 0xffffUL -#define DUK_INT_FAST16_MIN (-0x7fffL - 1L) -#define DUK_INT_FAST16_MAX 0x7fffL -#define DUK_UINT32_MIN 0UL -#define DUK_UINT32_MAX 0xffffffffUL -#define DUK_INT32_MIN (-0x7fffffffL - 1L) -#define DUK_INT32_MAX 0x7fffffffL -#define DUK_UINT_LEAST32_MIN 0UL -#define DUK_UINT_LEAST32_MAX 0xffffffffUL -#define DUK_INT_LEAST32_MIN (-0x7fffffffL - 1L) -#define DUK_INT_LEAST32_MAX 0x7fffffffL -#define DUK_UINT_FAST32_MIN 0UL -#define DUK_UINT_FAST32_MAX 0xffffffffUL -#define DUK_INT_FAST32_MIN (-0x7fffffffL - 1L) -#define DUK_INT_FAST32_MAX 0x7fffffffL - -/* 64-bit constants. Since LL / ULL constants are not always available, - * use computed values. These values can't be used in preprocessor - * comparisons; flag them as such. - */ -#if defined(DUK_F_HAVE_64BIT) -#define DUK_UINT64_MIN ((duk_uint64_t) 0) -#define DUK_UINT64_MAX ((duk_uint64_t) -1) -#define DUK_INT64_MIN ((duk_int64_t) (~(DUK_UINT64_MAX >> 1))) -#define DUK_INT64_MAX ((duk_int64_t) (DUK_UINT64_MAX >> 1)) -#define DUK_UINT_LEAST64_MIN DUK_UINT64_MIN -#define DUK_UINT_LEAST64_MAX DUK_UINT64_MAX -#define DUK_INT_LEAST64_MIN DUK_INT64_MIN -#define DUK_INT_LEAST64_MAX DUK_INT64_MAX -#define DUK_UINT_FAST64_MIN DUK_UINT64_MIN -#define DUK_UINT_FAST64_MAX DUK_UINT64_MAX -#define DUK_INT_FAST64_MIN DUK_INT64_MIN -#define DUK_INT_FAST64_MAX DUK_INT64_MAX -#define DUK_UINT64_MIN_COMPUTED -#define DUK_UINT64_MAX_COMPUTED -#define DUK_INT64_MIN_COMPUTED -#define DUK_INT64_MAX_COMPUTED -#define DUK_UINT_LEAST64_MIN_COMPUTED -#define DUK_UINT_LEAST64_MAX_COMPUTED -#define DUK_INT_LEAST64_MIN_COMPUTED -#define DUK_INT_LEAST64_MAX_COMPUTED -#define DUK_UINT_FAST64_MIN_COMPUTED -#define DUK_UINT_FAST64_MAX_COMPUTED -#define DUK_INT_FAST64_MIN_COMPUTED -#define DUK_INT_FAST64_MAX_COMPUTED -#endif - -#if defined(DUK_F_HAVE_64BIT) -#define DUK_UINTMAX_MIN DUK_UINT64_MIN -#define DUK_UINTMAX_MAX DUK_UINT64_MAX -#define DUK_INTMAX_MIN DUK_INT64_MIN -#define DUK_INTMAX_MAX DUK_INT64_MAX -#define DUK_UINTMAX_MIN_COMPUTED -#define DUK_UINTMAX_MAX_COMPUTED -#define DUK_INTMAX_MIN_COMPUTED -#define DUK_INTMAX_MAX_COMPUTED -#else -#define DUK_UINTMAX_MIN 0UL -#define DUK_UINTMAX_MAX 0xffffffffUL -#define DUK_INTMAX_MIN (-0x7fffffffL - 1L) -#define DUK_INTMAX_MAX 0x7fffffffL -#endif - -/* This detection is not very reliable. */ -#if defined(DUK_F_32BIT_PTRS) -typedef duk_int32_t duk_intptr_t; -typedef duk_uint32_t duk_uintptr_t; -#define DUK_UINTPTR_MIN DUK_UINT32_MIN -#define DUK_UINTPTR_MAX DUK_UINT32_MAX -#define DUK_INTPTR_MIN DUK_INT32_MIN -#define DUK_INTPTR_MAX DUK_INT32_MAX -#elif defined(DUK_F_64BIT_PTRS) && defined(DUK_F_HAVE_64BIT) -typedef duk_int64_t duk_intptr_t; -typedef duk_uint64_t duk_uintptr_t; -#define DUK_UINTPTR_MIN DUK_UINT64_MIN -#define DUK_UINTPTR_MAX DUK_UINT64_MAX -#define DUK_INTPTR_MIN DUK_INT64_MIN -#define DUK_INTPTR_MAX DUK_INT64_MAX -#define DUK_UINTPTR_MIN_COMPUTED -#define DUK_UINTPTR_MAX_COMPUTED -#define DUK_INTPTR_MIN_COMPUTED -#define DUK_INTPTR_MAX_COMPUTED -#else -#error cannot determine intptr type -#endif - -/* SIZE_MAX may be missing so use an approximate value for it. */ -#undef DUK_SIZE_MAX_COMPUTED -#if !defined(SIZE_MAX) -#define DUK_SIZE_MAX_COMPUTED -#define SIZE_MAX ((size_t) (-1)) -#endif -#define DUK_SIZE_MIN 0 -#define DUK_SIZE_MAX SIZE_MAX - -#endif /* C99 types */ - -/* A few types are assumed to always exist. */ -typedef size_t duk_size_t; -typedef ptrdiff_t duk_ptrdiff_t; - -/* The best type for an "all around int" in Duktape internals is "at least - * 32 bit signed integer" which is most convenient. Same for unsigned type. - * Prefer 'int' when large enough, as it is almost always a convenient type. - */ -#if defined(UINT_MAX) && (UINT_MAX >= 0xffffffffUL) -typedef int duk_int_t; -typedef unsigned int duk_uint_t; -#define DUK_INT_MIN INT_MIN -#define DUK_INT_MAX INT_MAX -#define DUK_UINT_MIN 0 -#define DUK_UINT_MAX UINT_MAX -#else -typedef duk_int_fast32_t duk_int_t; -typedef duk_uint_fast32_t duk_uint_t; -#define DUK_INT_MIN DUK_INT_FAST32_MIN -#define DUK_INT_MAX DUK_INT_FAST32_MAX -#define DUK_UINT_MIN DUK_UINT_FAST32_MIN -#define DUK_UINT_MAX DUK_UINT_FAST32_MAX -#endif - -/* Same as 'duk_int_t' but guaranteed to be a 'fast' variant if this - * distinction matters for the CPU. These types are used mainly in the - * executor where it might really matter. - */ -typedef duk_int_fast32_t duk_int_fast_t; -typedef duk_uint_fast32_t duk_uint_fast_t; -#define DUK_INT_FAST_MIN DUK_INT_FAST32_MIN -#define DUK_INT_FAST_MAX DUK_INT_FAST32_MAX -#define DUK_UINT_FAST_MIN DUK_UINT_FAST32_MIN -#define DUK_UINT_FAST_MAX DUK_UINT_FAST32_MAX - -/* Small integers (16 bits or more) can fall back to the 'int' type, but - * have a typedef so they are marked "small" explicitly. - */ -typedef int duk_small_int_t; -typedef unsigned int duk_small_uint_t; -#define DUK_SMALL_INT_MIN INT_MIN -#define DUK_SMALL_INT_MAX INT_MAX -#define DUK_SMALL_UINT_MIN 0 -#define DUK_SMALL_UINT_MAX UINT_MAX - -/* Fast variants of small integers, again for really fast paths like the - * executor. - */ -typedef duk_int_fast16_t duk_small_int_fast_t; -typedef duk_uint_fast16_t duk_small_uint_fast_t; -#define DUK_SMALL_INT_FAST_MIN DUK_INT_FAST16_MIN -#define DUK_SMALL_INT_FAST_MAX DUK_INT_FAST16_MAX -#define DUK_SMALL_UINT_FAST_MIN DUK_UINT_FAST16_MIN -#define DUK_SMALL_UINT_FAST_MAX DUK_UINT_FAST16_MAX - -/* Boolean values are represented with the platform 'int'. */ -typedef duk_small_int_t duk_bool_t; -#define DUK_BOOL_MIN DUK_SMALL_INT_MIN -#define DUK_BOOL_MAX DUK_SMALL_INT_MAX - -/* Index values must have at least 32-bit signed range. */ -typedef duk_int_t duk_idx_t; -#define DUK_IDX_MIN DUK_INT_MIN -#define DUK_IDX_MAX DUK_INT_MAX - -/* Array index values, could be exact 32 bits. - * Currently no need for signed duk_arridx_t. - */ -typedef duk_uint_t duk_uarridx_t; -#define DUK_UARRIDX_MIN DUK_UINT_MIN -#define DUK_UARRIDX_MAX DUK_UINT_MAX - -/* Duktape/C function return value, platform int is enough for now to - * represent 0, 1, or negative error code. Must be compatible with - * assigning truth values (e.g. duk_ret_t rc = (foo == bar);). - */ -typedef duk_small_int_t duk_ret_t; -#define DUK_RET_MIN DUK_SMALL_INT_MIN -#define DUK_RET_MAX DUK_SMALL_INT_MAX - -/* Error codes are represented with platform int. High bits are used - * for flags and such, so 32 bits are needed. - */ -typedef duk_int_t duk_errcode_t; -#define DUK_ERRCODE_MIN DUK_INT_MIN -#define DUK_ERRCODE_MAX DUK_INT_MAX - -/* Codepoint type. Must be 32 bits or more because it is used also for - * internal codepoints. The type is signed because negative codepoints - * are used as internal markers (e.g. to mark EOF or missing argument). - * (X)UTF-8/CESU-8 encode/decode take and return an unsigned variant to - * ensure duk_uint32_t casts back and forth nicely. Almost everything - * else uses the signed one. - */ -typedef duk_int_t duk_codepoint_t; -typedef duk_uint_t duk_ucodepoint_t; -#define DUK_CODEPOINT_MIN DUK_INT_MIN -#define DUK_CODEPOINT_MAX DUK_INT_MAX -#define DUK_UCODEPOINT_MIN DUK_UINT_MIN -#define DUK_UCODEPOINT_MAX DUK_UINT_MAX - -/* IEEE double typedef. */ -typedef double duk_double_t; - -/* We're generally assuming that we're working on a platform with a 32-bit - * address space. If DUK_SIZE_MAX is a typecast value (which is necessary - * if SIZE_MAX is missing), the check must be avoided because the - * preprocessor can't do a comparison. - */ -#if !defined(DUK_SIZE_MAX) -#error DUK_SIZE_MAX is undefined, probably missing SIZE_MAX -#elif !defined(DUK_SIZE_MAX_COMPUTED) -#if DUK_SIZE_MAX < 0xffffffffUL -/* On some systems SIZE_MAX can be smaller than max unsigned 32-bit value - * which seems incorrect if size_t is (at least) an unsigned 32-bit type. - * However, it doesn't seem useful to error out compilation if this is the - * case. - */ -#endif -#endif - -/* Convenience define: 32-bit pointers. 32-bit platforms are an important - * footprint optimization target, and this define allows e.g. struct sizes - * to be organized for compactness. - */ - -#undef DUK_USE_32BIT_PTRS -#if defined(DUK_UINTPTR_MAX) && !defined(DUK_UINTPTR_MAX_COMPUTED) -#if DUK_UINTPTR_MAX <= 0xffffffffUL -#define DUK_USE_32BIT_PTRS -#endif -#endif - -/* - * Check whether we should use 64-bit integers - */ - -/* Quite incomplete now. Use 64-bit types if detected (C99 or other detection) - * unless they are known to be unreliable. For instance, 64-bit types are - * available on VBCC but seem to misbehave. - */ -#if defined(DUK_F_HAVE_64BIT) && !defined(DUK_F_VBCC) -#define DUK_USE_64BIT_OPS -#else -#undef DUK_USE_64BIT_OPS -#endif - -/* - * Alignment requirement and support for unaligned accesses - * - * Assume unaligned accesses are not supported unless specifically allowed - * in the target platform. Some platforms may support unaligned accesses - * but alignment to 4 or 8 may still be desirable. - */ - -#undef DUK_USE_UNALIGNED_ACCESSES_POSSIBLE -#undef DUK_USE_ALIGN_4 -#undef DUK_USE_ALIGN_8 - -#if defined(DUK_F_EMSCRIPTEN) -/* Required on at least some targets, so use whenever Emscripten used, - * regardless of compilation target. - */ -#define DUK_USE_ALIGN_8 -#elif defined(DUK_F_ARM) -#define DUK_USE_ALIGN_4 -#elif defined(DUK_F_MIPS32) -/* Based on 'make checkalign' there are no alignment requirements on - * Linux MIPS except for doubles, which need align by 4. Alignment - * requirements vary based on target though. - */ -#define DUK_USE_ALIGN_4 -#elif defined(DUK_F_MIPS64) -/* Good default is a bit arbitrary because alignment requirements - * depend on target. See https://github.com/svaarala/duktape/issues/102. - */ -#define DUK_USE_ALIGN_8 -#elif defined(DUK_F_SUPERH) -/* Based on 'make checkalign' there are no alignment requirements on - * Linux SH4, but align by 4 is probably a good basic default. - */ -#define DUK_USE_ALIGN_4 -#elif defined(DUK_F_X86) || defined(DUK_F_X32) || defined(DUK_F_X64) || \ - defined(DUK_F_BCC) -/* XXX: This is technically not guaranteed because it's possible to configure - * an x86 to require aligned accesses with Alignment Check (AC) flag. - */ -#define DUK_USE_UNALIGNED_ACCESSES_POSSIBLE -#else -/* Unknown, use safe default */ -#define DUK_USE_ALIGN_8 -#endif - -/* User forced alignment to 4 or 8. */ -#if defined(DUK_OPT_FORCE_ALIGN) -#undef DUK_USE_UNALIGNED_ACCESSES_POSSIBLE -#undef DUK_USE_ALIGN_4 -#undef DUK_USE_ALIGN_8 -#if (DUK_OPT_FORCE_ALIGN == 4) -#define DUK_USE_ALIGN_4 -#elif (DUK_OPT_FORCE_ALIGN == 8) -#define DUK_USE_ALIGN_8 -#else -#error invalid DUK_OPT_FORCE_ALIGN value -#endif -#endif - -/* Compiler specific hackery needed to force struct size to match aligment, - * see e.g. duk_hbuffer.h. - * - * http://stackoverflow.com/questions/11130109/c-struct-size-alignment - * http://stackoverflow.com/questions/10951039/specifying-64-bit-alignment - */ -#if defined(DUK_F_MSVC) -#define DUK_USE_PACK_MSVC_PRAGMA -#elif defined(DUK_F_GCC) -#define DUK_USE_PACK_GCC_ATTR -#elif defined(DUK_F_CLANG) -#define DUK_USE_PACK_CLANG_ATTR -#else -#define DUK_USE_PACK_DUMMY_MEMBER -#endif - -#ifdef DUK_USE_UNALIGNED_ACCESSES_POSSIBLE -#define DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS -#else -#undef DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS -#endif - -/* Object property allocation layout has implications for memory and code - * footprint and generated code size/speed. The best layout also depends - * on whether the platform has alignment requirements or benefits from - * having mostly aligned accesses. - */ -#undef DUK_USE_HOBJECT_LAYOUT_1 -#undef DUK_USE_HOBJECT_LAYOUT_2 -#undef DUK_USE_HOBJECT_LAYOUT_3 -#if defined(DUK_USE_UNALIGNED_ACCESSES_POSSIBLE) && \ - !defined(DUK_USE_ALIGN_4) && !defined(DUK_USE_ALIGN_8) -/* On platforms without any alignment issues, layout 1 is preferable - * because it compiles to slightly less code and provides direct access - * to property keys. - */ -#define DUK_USE_HOBJECT_LAYOUT_1 -#else -/* On other platforms use layout 2, which requires some padding but - * is a bit more natural than layout 3 in ordering the entries. Layout - * 3 is currently not used. - */ -#define DUK_USE_HOBJECT_LAYOUT_2 -#endif - -/* - * Byte order and double memory layout detection - * - * Endianness detection is a major portability hassle because the macros - * and headers are not standardized. There's even variance across UNIX - * platforms. Even with "standard" headers, details like underscore count - * varies between platforms, e.g. both __BYTE_ORDER and _BYTE_ORDER are used - * (Crossbridge has a single underscore, for instance). - * - * The checks below are structured with this in mind: several approaches are - * used, and at the end we check if any of them worked. This allows generic - * approaches to be tried first, and platform/compiler specific hacks tried - * last. As a last resort, the user can force a specific endianness, as it's - * not likely that automatic detection will work on the most exotic platforms. - * - * Duktape supports little and big endian machines. There's also support - * for a hybrid used by some ARM machines where integers are little endian - * but IEEE double values use a mixed order (12345678 -> 43218765). This - * byte order for doubles is referred to as "mixed endian". - */ - -#undef DUK_F_BYTEORDER -#undef DUK_USE_BYTEORDER_FORCED - -/* DUK_F_BYTEORDER is set as an intermediate value when detection - * succeeds, to one of: - * 1 = little endian - * 2 = mixed (arm hybrid) endian - * 3 = big endian - */ - -/* For custom platforms allow user to define byteorder explicitly. - * Since endianness headers are not standardized, this is a useful - * workaround for custom platforms for which endianness detection - * is not directly supported. Perhaps custom hardware is used and - * user cannot submit upstream patches. - */ -#if defined(DUK_OPT_FORCE_BYTEORDER) -#if (DUK_OPT_FORCE_BYTEORDER == 1) -#define DUK_F_BYTEORDER 1 -#elif (DUK_OPT_FORCE_BYTEORDER == 2) -#define DUK_F_BYTEORDER 2 -#elif (DUK_OPT_FORCE_BYTEORDER == 3) -#define DUK_F_BYTEORDER 3 -#else -#error invalid DUK_OPT_FORCE_BYTEORDER value -#endif -#define DUK_USE_BYTEORDER_FORCED -#endif /* DUK_OPT_FORCE_BYTEORDER */ - -/* More or less standard endianness predefines provided by header files. - * The ARM hybrid case is detected by assuming that __FLOAT_WORD_ORDER - * will be big endian, see: http://lists.mysql.com/internals/443. - */ -#if !defined(DUK_F_BYTEORDER) -#if defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && (__BYTE_ORDER == __LITTLE_ENDIAN) || \ - defined(_BYTE_ORDER) && defined(_LITTLE_ENDIAN) && (_BYTE_ORDER == _LITTLE_ENDIAN) || \ - defined(__LITTLE_ENDIAN__) -/* Integer little endian */ -#if defined(__FLOAT_WORD_ORDER) && defined(__LITTLE_ENDIAN) && (__FLOAT_WORD_ORDER == __LITTLE_ENDIAN) || \ - defined(_FLOAT_WORD_ORDER) && defined(_LITTLE_ENDIAN) && (_FLOAT_WORD_ORDER == _LITTLE_ENDIAN) -#define DUK_F_BYTEORDER 1 -#elif defined(__FLOAT_WORD_ORDER) && defined(__BIG_ENDIAN) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) || \ - defined(_FLOAT_WORD_ORDER) && defined(_BIG_ENDIAN) && (_FLOAT_WORD_ORDER == _BIG_ENDIAN) -#define DUK_F_BYTEORDER 2 -#elif !defined(__FLOAT_WORD_ORDER) && !defined(_FLOAT_WORD_ORDER) -/* Float word order not known, assume not a hybrid. */ -#define DUK_F_BYTEORDER 1 -#else -/* byte order is little endian but cannot determine IEEE double word order */ -#endif /* float word order */ -#elif defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && (__BYTE_ORDER == __BIG_ENDIAN) || \ - defined(_BYTE_ORDER) && defined(_BIG_ENDIAN) && (_BYTE_ORDER == _BIG_ENDIAN) || \ - defined(__BIG_ENDIAN__) -/* Integer big endian */ -#if defined(__FLOAT_WORD_ORDER) && defined(__BIG_ENDIAN) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) || \ - defined(_FLOAT_WORD_ORDER) && defined(_BIG_ENDIAN) && (_FLOAT_WORD_ORDER == _BIG_ENDIAN) -#define DUK_F_BYTEORDER 3 -#elif !defined(__FLOAT_WORD_ORDER) && !defined(_FLOAT_WORD_ORDER) -/* Float word order not known, assume not a hybrid. */ -#define DUK_F_BYTEORDER 3 -#else -/* byte order is big endian but cannot determine IEEE double word order */ -#endif /* float word order */ -#else -/* cannot determine byte order */ -#endif /* integer byte order */ -#endif /* !defined(DUK_F_BYTEORDER) */ - -/* GCC and Clang provide endianness defines as built-in predefines, with - * leading and trailing double underscores (e.g. __BYTE_ORDER__). See - * output of "make gccpredefs" and "make clangpredefs". Clang doesn't - * seem to provide __FLOAT_WORD_ORDER__. - * http://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html - */ -#if !defined(DUK_F_BYTEORDER) && defined(__BYTE_ORDER__) -#if defined(__ORDER_LITTLE_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) -/* Integer little endian */ -#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \ - (__FLOAT_WORD_ORDER__ == __ORDER_LITTLE_ENDIAN__) -#define DUK_F_BYTEORDER 1 -#elif defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \ - (__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__) -#define DUK_F_BYTEORDER 2 -#elif !defined(__FLOAT_WORD_ORDER__) -/* Float word order not known, assume not a hybrid. */ -#define DUK_F_BYTEORDER 1 -#else -/* byte order is little endian but cannot determine IEEE double word order */ -#endif /* float word order */ -#elif defined(__ORDER_BIG_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) -/* Integer big endian */ -#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \ - (__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__) -#define DUK_F_BYTEORDER 3 -#elif !defined(__FLOAT_WORD_ORDER__) -/* Float word order not known, assume not a hybrid. */ -#define DUK_F_BYTEORDER 3 -#else -/* byte order is big endian but cannot determine IEEE double word order */ -#endif /* float word order */ -#else -/* cannot determine byte order; __ORDER_PDP_ENDIAN__ is related to 32-bit - * integer ordering and is not relevant - */ -#endif /* integer byte order */ -#endif /* !defined(DUK_F_BYTEORDER) && defined(__BYTE_ORDER__) */ - -/* Atari ST TOS */ -#if !defined(DUK_F_BYTEORDER) && defined(DUK_F_TOS) -#define DUK_F_BYTEORDER 3 -#endif - -/* AmigaOS on M68k */ -#if !defined(DUK_F_BYTEORDER) && defined(DUK_F_AMIGAOS) -#if defined(DUK_F_M68K) -#define DUK_F_BYTEORDER 3 -#endif -#endif - -/* On Windows, assume we're little endian. Even Itanium which has a - * configurable endianness runs little endian in Windows. - */ -#if !defined(DUK_F_BYTEORDER) && defined(DUK_F_WINDOWS) -/* XXX: verify that Windows on ARM is little endian for floating point - * values too. - */ -#define DUK_F_BYTEORDER 1 -#endif /* Windows */ - -/* Crossbridge should work with the standard byteorder #ifdefs. It doesn't - * provide _FLOAT_WORD_ORDER but the standard approach now covers that case - * too. This has been left here just in case. - */ -#if !defined(DUK_F_BYTEORDER) && defined(DUK_F_FLASHPLAYER) -#define DUK_F_BYTEORDER 1 -#endif - -/* QNX gcc cross compiler seems to define e.g. __LITTLEENDIAN__ or __BIGENDIAN__: - * $ /opt/qnx650/host/linux/x86/usr/bin/i486-pc-nto-qnx6.5.0-gcc -dM -E - - * | 0 | 1 | 2 | ..... - * ^-- p=3, points after last valid byte (2) - * - * If this is a practical issue, wrappers are again needed. - */ - -typedef FILE duk_file; -#define DUK_STDIN stdin -#define DUK_STDOUT stdout -#define DUK_STDERR stderr - -/* Special naming to avoid conflict with e.g. DUK_FREE() in duk_heap.h - * (which is unfortunately named). - */ -#define DUK_ANSI_MALLOC malloc -#define DUK_ANSI_REALLOC realloc -#define DUK_ANSI_CALLOC calloc -#define DUK_ANSI_FREE free - -/* Old uclibcs have a broken memcpy so use memmove instead (this is overly - * wide now on purpose): - * http://lists.uclibc.org/pipermail/uclibc-cvs/2008-October/025511.html - */ -#if defined(DUK_F_UCLIBC) -#define DUK_MEMCPY memmove -#else -#define DUK_MEMCPY memcpy -#endif - -#define DUK_MEMMOVE memmove -#define DUK_MEMCMP memcmp -#define DUK_MEMSET memset -#define DUK_STRLEN strlen -#define DUK_STRCMP strcmp -#define DUK_STRNCMP strncmp -#define DUK_PRINTF printf -#define DUK_FPRINTF fprintf -#define DUK_SPRINTF sprintf - -#if defined(DUK_F_MSVC) -/* _snprintf() does NOT NUL terminate on truncation, but Duktape code never - * assumes that. - * http://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010 - */ -#define DUK_SNPRINTF _snprintf -#else -#define DUK_SNPRINTF snprintf -#endif - -#define DUK_VSPRINTF vsprintf - -#if defined(DUK_F_MSVC) -#if (_MSC_VER < 1600) -/* Older MSVC version are missing vsnprintf() but have _vsnprintf(). */ -#define DUK_VSNPRINTF _vsnprintf -#else -#define DUK_VSNPRINTF vsnprintf -#endif -#else -#define DUK_VSNPRINTF vsnprintf -#endif /* DUK_F_MSVC */ - -#define DUK_SSCANF sscanf -#define DUK_VSSCANF vsscanf -#define DUK_FOPEN fopen -#define DUK_FCLOSE fclose -#define DUK_FREAD fread -#define DUK_FWRITE fwrite -#define DUK_FSEEK fseek -#define DUK_FTELL ftell -#define DUK_FFLUSH fflush -#define DUK_FPUTC fputc - -#define DUK_MEMZERO(p,n) \ - DUK_MEMSET((p), 0, (n)) - -/* - * Avoiding platform function pointers. - * - * On some platforms built-in functions may be implemented as macros or - * inline functions, so they can't be necessarily addressed by function - * pointers. This is certainly the case with some platform "polyfills" - * which provide missing C99/C++11 functions through macros, and may be - * the case with VS2013 (see GH-17). - */ - -/* This is now the default: the cost in footprint is negligible. */ -#define DUK_USE_AVOID_PLATFORM_FUNCPTRS - -/* - * Vararg macro wrappers. We need va_copy() which is defined in C99 / C++11, - * so an awkward replacement is needed for pre-C99 / pre-C++11 environments. - * This will quite likely need portability hacks for some non-C99 environments. - */ - -#if defined(DUK_F_C99) || defined(DUK_F_CPP11) -/* C99 / C++11 and above: rely on va_copy() which is required. - * Omit parenthesis on macro right side on purpose to minimize differences - * to direct use. - */ -#define DUK_VA_COPY(dest,src) va_copy(dest,src) -#elif defined(DUK_F_GCC) || defined(DUK_F_CLANG) -/* GCC: assume we have __va_copy() in non-C99 mode, which should be correct - * for even quite old GCC versions. Clang matches GCC behavior. - */ -#define DUK_VA_COPY(dest,src) __va_copy(dest,src) -#else -/* Pre-C99: va_list type is implementation dependent. This replacement - * assumes it is a plain value so that a simple assignment will work. - * This is not the case on all platforms (it may be a single-array element, - * for instance). - */ -#define DUK_VA_COPY(dest,src) do { (dest) = (src); } while (0) -#endif - -/* - * Miscellaneous ANSI C or other platform wrappers. - */ - -#define DUK_ABORT abort -#define DUK_EXIT exit - -/* - * Macro hackery to convert e.g. __LINE__ to a string without formatting, - * see: http://stackoverflow.com/questions/240353/convert-a-preprocessor-token-to-a-string - */ - -#define DUK_F_STRINGIFY_HELPER(x) #x -#define DUK_MACRO_STRINGIFY(x) DUK_F_STRINGIFY_HELPER(x) - -/* - * Cause segfault macro. - * - * This is optionally used by panic handling to cause the program to segfault - * (instead of e.g. abort()) on panic. Valgrind will then indicate the C - * call stack leading to the panic. - */ - -#define DUK_CAUSE_SEGFAULT() do { \ - *((volatile duk_uint32_t *) NULL) = (duk_uint32_t) 0xdeadbeefUL; \ - } while (0) - -/* - * Macro for suppressing warnings for potentially unreferenced variables. - * The variables can be actually unreferenced or unreferenced in some - * specific cases only; for instance, if a variable is only debug printed, - * it is unreferenced when debug printing is disabled. - * - * (Introduced here because it's potentially compiler specific.) - */ - -#define DUK_UNREF(x) do { \ - (void) (x); \ - } while (0) - -/* - * DUK_NORETURN: macro for declaring a 'noreturn' function. - * Unfortunately the noreturn declaration may appear in various - * places of a function declaration, so the solution is to wrap - * the entire declaration inside the macro. Compiler support - * for using a noreturn declaration on function pointers varies; - * this macro must only be used for actual function declarations. - * - * http://gcc.gnu.org/onlinedocs/gcc-4.3.2//gcc/Function-Attributes.html - * http://clang.llvm.org/docs/LanguageExtensions.html - */ - -#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 20500L) -/* since gcc-2.5 */ -#define DUK_NORETURN(decl) decl __attribute__((noreturn)) -#elif defined(__clang__) -/* syntax same as gcc */ -#define DUK_NORETURN(decl) decl __attribute__((noreturn)) -#elif defined(DUK_F_MSVC) -/* http://msdn.microsoft.com/en-us/library/aa235362(VS.60).aspx */ -#define DUK_NORETURN(decl) __declspec(noreturn) decl -#else -/* Don't know how to declare a noreturn function, so don't do it; this - * may cause some spurious compilation warnings (e.g. "variable used - * uninitialized"). - */ -#define DUK_NORETURN(decl) decl -#endif - -/* - * Macro for stating that a certain line cannot be reached. - * - * http://gcc.gnu.org/onlinedocs/gcc-4.5.0/gcc/Other-Builtins.html#Other-Builtins - * http://clang.llvm.org/docs/LanguageExtensions.html - */ - -#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40500L) -/* since gcc-4.5 */ -#define DUK_UNREACHABLE() do { __builtin_unreachable(); } while(0) -#elif defined(__clang__) && defined(__has_builtin) -#if __has_builtin(__builtin_unreachable) -/* same as gcc */ -#define DUK_UNREACHABLE() do { __builtin_unreachable(); } while(0) -#endif -#else -/* unknown */ -#endif - -#if !defined(DUK_UNREACHABLE) -/* Don't know how to declare unreachable point, so don't do it; this - * may cause some spurious compilation warnings (e.g. "variable used - * uninitialized"). - */ -#define DUK_UNREACHABLE() /* unreachable */ -#endif - -/* - * Likely and unlikely branches. Using these is not at all a clear cut case, - * so the selection is a two-step process: (1) DUK_USE_BRANCH_HINTS is set - * if the architecture, compiler etc make it useful to use the hints, and (2) - * a separate check determines how to do them. - * - * These macros expect the argument to be a relational expression with an - * integer value. If used with pointers, you should use an explicit check - * like: - * - * if (DUK_LIKELY(ptr != NULL)) { ... } - * - * instead of: - * - * if (DUK_LIKELY(ptr)) { ... } - * - * http://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html (__builtin_expect) - */ - -/* pretty much a placeholder now */ -#if defined(DUK_F_GCC) -#define DUK_USE_BRANCH_HINTS -#elif defined(DUK_F_CLANG) -#define DUK_USE_BRANCH_HINTS -#else -#undef DUK_USE_BRANCH_HINTS -#endif - -#if defined(DUK_USE_BRANCH_HINTS) -#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40500L) -/* GCC: test not very accurate; enable only in relatively recent builds - * because of bugs in gcc-4.4 (http://lists.debian.org/debian-gcc/2010/04/msg00000.html) - */ -#define DUK_LIKELY(x) __builtin_expect((x), 1) -#define DUK_UNLIKELY(x) __builtin_expect((x), 0) -#elif defined(DUK_F_CLANG) -#define DUK_LIKELY(x) __builtin_expect((x), 1) -#define DUK_UNLIKELY(x) __builtin_expect((x), 0) -#endif -#endif /* DUK_USE_BRANCH_HINTS */ - -#if !defined(DUK_LIKELY) -#define DUK_LIKELY(x) (x) -#endif -#if !defined(DUK_UNLIKELY) -#define DUK_UNLIKELY(x) (x) -#endif - -/* - * Function inlining control - * - * DUK_NOINLINE: avoid inlining a function. - * DUK_INLINE: suggest inlining a function. - * DUK_ALWAYS_INLINE: force inlining for critical functions. - */ - -#if defined(DUK_F_CLANG) -#define DUK_NOINLINE __attribute__((noinline)) -#define DUK_INLINE inline -#define DUK_ALWAYS_INLINE inline __attribute__((always_inline)) -#elif defined(DUK_F_GCC) && defined(DUK_F_GCC_VERSION) -#if (DUK_F_GCC_VERSION >= 30101) -#define DUK_NOINLINE __attribute__((noinline)) -#define DUK_INLINE inline -#define DUK_ALWAYS_INLINE inline __attribute__((always_inline)) -#endif -#endif - -#if !defined(DUK_NOINLINE) -#define DUK_NOINLINE /*nop*/ -#define DUK_INLINE /*nop*/ -#define DUK_ALWAYS_INLINE /*nop*/ -#endif - -/* - * Symbol visibility macros - * - * To avoid C++ declaration issues (see GH-63): - * - * - Don't use DUK_LOCAL_DECL for local -data symbols- so that you don't - * end up with both a "static" declaration and a definition. - * - * - Wrap any DUK_INTERNAL_DECL with a '#if !defined(DUK_SINGLE_FILE)' - * so that the internal declarations (which would map to "static" in - * a single file distribution) get dropped. - */ - -/* XXX: user override for these? user override for just using the default visibility macros? */ -/* XXX: separate macros for function and data may be necessary at some point. */ - -#if defined(DUK_F_GCC_VERSION) -#if (DUK_F_GCC_VERSION >= 40000) && !(defined(DUK_F_MINGW) || defined(DUK_F_CYGWIN)) -/* Might work on earlier versions too but limit to GCC 4+. - * MinGW should use Windows specific __declspec or no visibility attributes at all, - * otherwise: "warning: visibility attribute not supported in this configuration; ignored". - * Same applies to Cygwin GCC. - */ -#define DUK_F_GCC_SYMBOL_VISIBILITY -#endif -#endif -#if defined(DUK_F_CLANG) && !defined(DUK_F_GCC_SYMBOL_VISIBILITY) -#define DUK_F_GCC_SYMBOL_VISIBILITY -#endif -#if defined(DUK_OPT_DLL_BUILD) && defined(_WIN32) && (defined(_MSC_VER) || defined(__GNUC__)) -/* __declspec(dllexport) and __declspec(dllimport) only for Windows DLL build. - * MSVC: any minimum version? - * MinGW: no minimum version, even gcc-2.95.3 supported dllimport/dllexport. -*/ -#define DUK_F_MSVC_DLL_SYMBOL_VISIBILITY -#endif - -#if defined(DUK_F_GCC_SYMBOL_VISIBILITY) -/* GCC 4+ visibility attributes. */ -#define DUK_EXTERNAL_DECL __attribute__ ((visibility("default"))) extern -#define DUK_EXTERNAL __attribute__ ((visibility("default"))) -#if defined(DUK_SINGLE_FILE) -#define DUK_INTERNAL_DECL static -#define DUK_INTERNAL static -#else -#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) extern -#define DUK_INTERNAL __attribute__ ((visibility("hidden"))) -#endif -#elif defined(DUK_F_MSVC_DLL_SYMBOL_VISIBILITY) -/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're - * compiling Duktape or the application. - */ -#if defined(DUK_COMPILING_DUKTAPE) -#define DUK_EXTERNAL_DECL extern __declspec(dllexport) -#define DUK_EXTERNAL __declspec(dllexport) -#else -#define DUK_EXTERNAL_DECL extern __declspec(dllimport) -#define DUK_EXTERNAL should_not_happen -#endif -#if defined(DUK_SINGLE_FILE) -#define DUK_INTERNAL_DECL static -#define DUK_INTERNAL static -#else -#define DUK_INTERNAL_DECL extern -#define DUK_INTERNAL /*empty*/ -#endif -#else -/* Default visibility. */ -#define DUK_EXTERNAL_DECL extern -#define DUK_EXTERNAL /*empty*/ -#if defined(DUK_SINGLE_FILE) -#define DUK_INTERNAL_DECL static -#define DUK_INTERNAL static -#else /* DUK_SINGLE_FILE */ -#define DUK_INTERNAL_DECL extern -#define DUK_INTERNAL /*empty*/ -#endif -#endif - -/* For now, these are shared. */ -#define DUK_LOCAL_DECL static -#define DUK_LOCAL static - -/* - * __FILE__, __LINE__, __func__ are wrapped. Especially __func__ is a - * problem because it is not available even in some compilers which try - * to be C99 compatible (e.g. VBCC with -c99 option). - */ - -#define DUK_FILE_MACRO __FILE__ - -#define DUK_LINE_MACRO __LINE__ - -#if !defined(DUK_F_VBCC) && !defined(DUK_F_MSVC) -#define DUK_FUNC_MACRO __func__ -#else -#define DUK_FUNC_MACRO "unknown" -#endif - -/* - * Byteswap macros - * - * These are here so that inline assembly or other platform functions can be - * used if available. - */ - -#define DUK_BSWAP32(x) \ - ((((duk_uint32_t) (x)) >> 24) | \ - ((((duk_uint32_t) (x)) >> 8) & 0xff00UL) | \ - ((((duk_uint32_t) (x)) << 8) & 0xff0000UL) | \ - (((duk_uint32_t) (x)) << 24)) - -#define DUK_BSWAP16(x) \ - ((duk_uint16_t) (x) >> 8) | \ - ((duk_uint16_t) (x) << 8) - -/* - * Architecture string, human readable value exposed in Duktape.env - */ - -#if defined(DUK_F_X86) -#define DUK_USE_ARCH_STRING "x86" -#elif defined(DUK_F_X32) -#define DUK_USE_ARCH_STRING "x32" -#elif defined(DUK_F_X64) -#define DUK_USE_ARCH_STRING "x64" -#elif defined(DUK_F_ARM) -#define DUK_USE_ARCH_STRING "arm" -#elif defined(DUK_F_MIPS32) -#define DUK_USE_ARCH_STRING "mips32" -#elif defined(DUK_F_MIPS64) -#define DUK_USE_ARCH_STRING "mips64" -#elif defined(DUK_F_SUPERH) -#define DUK_USE_ARCH_STRING "sh" -#elif defined(DUK_F_M68K) -#define DUK_USE_ARCH_STRING "m68k" -#elif defined(DUK_F_FLASHPLAYER) -#define DUK_USE_ARCH_STRING "flashplayer" -#elif defined(DUK_F_EMSCRIPTEN) -#define DUK_USE_ARCH_STRING "emscripten" -#else -#define DUK_USE_ARCH_STRING "unknown" -#endif - -/* - * OS string, human readable value exposed in Duktape.env - */ - -#if defined(DUK_F_LINUX) -#define DUK_USE_OS_STRING "linux" -#elif defined(__APPLE__) -/* http://stackoverflow.com/questions/5919996/how-to-detect-reliably-mac-os-x-ios-linux-windows-in-c-preprocessor */ -#if TARGET_IPHONE_SIMULATOR -#define DUK_USE_OS_STRING "iphone-sim" -#elif TARGET_OS_IPHONE -#define DUK_USE_OS_STRING "iphone" -#elif TARGET_OS_MAC -#define DUK_USE_OS_STRING "ios" -#else -#define DUK_USE_OS_STRING "ios-unknown" -#endif -#elif defined(DUK_F_FREEBSD) -#define DUK_USE_OS_STRING "freebsd" -#elif defined(DUK_F_OPENBSD) -#define DUK_USE_OS_STRING "openbsd" -#elif defined(DUK_F_NETBSD) -#define DUK_USE_OS_STRING "netbsd" -#elif defined(DUK_F_BSD) -#define DUK_USE_OS_STRING "bsd" -#elif defined(DUK_F_UNIX) -#define DUK_USE_OS_STRING "unix" -#elif defined(DUK_F_WINDOWS) -#define DUK_USE_OS_STRING "windows" -#elif defined(DUK_F_TOS) -#define DUK_USE_OS_STRING "tos" -#elif defined(DUK_F_AMIGAOS) -#define DUK_USE_OS_STRING "amigaos" -#elif defined(DUK_F_QNX) -#define DUK_USE_OS_STRING "qnx" -#elif defined(DUK_F_TINSPIRE) -#define DUK_USE_OS_STRING "tinspire" -#else -#define DUK_USE_OS_STRING "unknown" -#endif - -/* - * Compiler string, human readable value exposed in Duktape.env - */ - -#if defined(DUK_F_MINGW) -#define DUK_USE_COMPILER_STRING "mingw" -#elif defined(DUK_F_GCC) -#if defined(DUK_F_CPP) -#define DUK_USE_COMPILER_STRING "g++" -#else -#define DUK_USE_COMPILER_STRING "gcc" -#endif -#elif defined(DUK_F_CLANG) -#define DUK_USE_COMPILER_STRING "clang" -#elif defined(DUK_F_MSVC) -#define DUK_USE_COMPILER_STRING "msvc" -#elif defined(DUK_F_VBCC) -#define DUK_USE_COMPILER_STRING "vbcc" -#else -#define DUK_USE_COMPILER_STRING "unknown" -#endif - -/* - * Long control transfer, setjmp/longjmp or alternatives - * - * Signal mask is not saved (when that can be communicated to the platform) - */ - -/* dummy non-zero value to be used as an argument for longjmp(), see man longjmp */ -#define DUK_LONGJMP_DUMMY_VALUE 1 - -#if defined(DUK_OPT_SETJMP) -#define DUK_USE_SETJMP -#elif defined(DUK_OPT_UNDERSCORE_SETJMP) -#define DUK_USE_UNDERSCORE_SETJMP -#elif defined(DUK_OPT_SIGSETJMP) -#define DUK_USE_SIGSETJMP -#elif defined(__APPLE__) -/* Use _setjmp() on Apple by default, see GH-55. */ -#define DUK_USE_UNDERSCORE_SETJMP -#else -/* The most portable default is setjmp(). */ -#define DUK_USE_SETJMP -#endif - -#if defined(DUK_USE_UNDERSCORE_SETJMP) -#define DUK_SETJMP(jb) _setjmp((jb)) -#define DUK_LONGJMP(jb) _longjmp((jb), DUK_LONGJMP_DUMMY_VALUE) -#elif defined(DUK_USE_SIGSETJMP) -#define DUK_SETJMP(jb) sigsetjmp((jb), 0 /*savesigs*/) -#define DUK_LONGJMP(jb) siglongjmp((jb), DUK_LONGJMP_DUMMY_VALUE) -#elif defined(DUK_USE_SETJMP) -#define DUK_SETJMP(jb) setjmp((jb)) -#define DUK_LONGJMP(jb) longjmp((jb), DUK_LONGJMP_DUMMY_VALUE) -#else -#error internal error -#endif - -/* - * Target info string - */ - -#if defined(DUK_OPT_TARGET_INFO) -#define DUK_USE_TARGET_INFO DUK_OPT_TARGET_INFO -#else -#define DUK_USE_TARGET_INFO "unknown" -#endif - -/* - * Speed/size and other performance options - */ - -/* Use fast ("inline") refcount operations instead of calling out to helpers - * by default. The difference in binary size is small (~1kB on x64). - */ -#define DUK_USE_FAST_REFCOUNT_DEFAULT - -/* Assert for valstack space but don't check for it in non-assert build. - * Valstack overruns (writing beyond checked space) is memory unsafe and - * potentially a segfault. Produces a smaller and faster binary. - * (In practice the speed difference is small with -O3 so default to - * safer behavior for now.) - */ -#undef DUK_USE_VALSTACK_UNSAFE - -/* Catch-all flag which can be used to choose between variant algorithms - * where a speed-size tradeoff exists (e.g. lookup tables). When it really - * matters, specific use flags may be appropriate. - */ -#define DUK_USE_PREFER_SIZE - -/* - * Tagged type representation (duk_tval) - */ - -#undef DUK_USE_PACKED_TVAL - -#if defined(DUK_USE_PACKED_TVAL_POSSIBLE) && !defined(DUK_OPT_NO_PACKED_TVAL) -#define DUK_USE_PACKED_TVAL -#endif - -/* Support for 48-bit signed integer duk_tval with transparent semantics. */ -#undef DUK_USE_FASTINT -#if defined(DUK_OPT_FASTINT) -#if !defined(DUK_F_HAVE_64BIT) -#error DUK_OPT_FASTINT requires 64-bit integer type support at the moment -#endif -#define DUK_USE_FASTINT -#endif - -/* - * Memory management options - */ - -#define DUK_USE_REFERENCE_COUNTING -#define DUK_USE_DOUBLE_LINKED_HEAP -#define DUK_USE_MARK_AND_SWEEP -#define DUK_USE_MS_STRINGTABLE_RESIZE - -#if defined(DUK_OPT_NO_REFERENCE_COUNTING) -#undef DUK_USE_REFERENCE_COUNTING -#undef DUK_USE_DOUBLE_LINKED_HEAP -/* XXX: undef DUK_USE_MS_STRINGTABLE_RESIZE as it is more expensive - * with more frequent mark-and-sweeps? - */ -#endif - -#if defined(DUK_OPT_NO_MARK_AND_SWEEP) -#undef DUK_USE_MARK_AND_SWEEP -#endif - -#if defined(DUK_USE_MARK_AND_SWEEP) -#define DUK_USE_VOLUNTARY_GC -#if defined(DUK_OPT_NO_VOLUNTARY_GC) -#undef DUK_USE_VOLUNTARY_GC -#endif -#endif - -#if !defined(DUK_USE_MARK_AND_SWEEP) && !defined(DUK_USE_REFERENCE_COUNTING) -#error must have either mark-and-sweep or reference counting enabled -#endif - -#if defined(DUK_OPT_NO_MS_STRINGTABLE_RESIZE) -#undef DUK_USE_MS_STRINGTABLE_RESIZE -#endif - -#undef DUK_USE_GC_TORTURE -#if defined(DUK_OPT_GC_TORTURE) -#define DUK_USE_GC_TORTURE -#endif - -/* - * String table options - */ - -#if defined(DUK_OPT_STRTAB_CHAIN) && defined(DUK_OPT_STRTAB_CHAIN_SIZE) -/* Low memory algorithm: separate chaining using arrays, fixed size hash */ -#define DUK_USE_STRTAB_CHAIN -#define DUK_USE_STRTAB_CHAIN_SIZE DUK_OPT_STRTAB_CHAIN_SIZE -#else -/* Default algorithm: open addressing (probing) */ -#define DUK_USE_STRTAB_PROBE -#endif - -/* - * Error handling options - */ - -#define DUK_USE_AUGMENT_ERROR_CREATE -#define DUK_USE_AUGMENT_ERROR_THROW -#define DUK_USE_TRACEBACKS -#define DUK_USE_ERRCREATE -#define DUK_USE_ERRTHROW - -#define DUK_USE_VERBOSE_ERRORS - -#if defined(DUK_OPT_NO_AUGMENT_ERRORS) -#undef DUK_USE_AUGMENT_ERROR_CREATE -#undef DUK_USE_AUGMENT_ERROR_THROW -#undef DUK_USE_TRACEBACKS -#undef DUK_USE_ERRCREATE -#undef DUK_USE_ERRTHROW -#elif defined(DUK_OPT_NO_TRACEBACKS) -#undef DUK_USE_TRACEBACKS -#endif - -#if defined(DUK_OPT_NO_VERBOSE_ERRORS) -#undef DUK_USE_VERBOSE_ERRORS -#endif - -#if defined(DUK_USE_TRACEBACKS) -#if defined(DUK_OPT_TRACEBACK_DEPTH) -#define DUK_USE_TRACEBACK_DEPTH DUK_OPT_TRACEBACK_DEPTH -#else -#define DUK_USE_TRACEBACK_DEPTH 10 -#endif -#endif - -/* Include messages in executor internal errors. */ -#define DUK_USE_VERBOSE_EXECUTOR_ERRORS - -/* - * Execution and debugger options - */ - -#undef DUK_USE_INTERRUPT_COUNTER -#if defined(DUK_OPT_INTERRUPT_COUNTER) -#define DUK_USE_INTERRUPT_COUNTER -#endif - -#undef DUK_USE_EXEC_TIMEOUT_CHECK -#if defined(DUK_OPT_EXEC_TIMEOUT_CHECK) -#define DUK_USE_EXEC_TIMEOUT_CHECK(udata) DUK_OPT_EXEC_TIMEOUT_CHECK((udata)) -#endif - -#undef DUK_USE_DEBUGGER_SUPPORT -#if defined(DUK_OPT_DEBUGGER_SUPPORT) -#define DUK_USE_DEBUGGER_SUPPORT -#endif - -#undef DUK_USE_DEBUGGER_FWD_PRINTALERT -#if defined(DUK_OPT_DEBUGGER_SUPPORT) && defined(DUK_OPT_DEBUGGER_FWD_PRINTALERT) -#define DUK_USE_DEBUGGER_FWD_PRINTALERT -#endif - -#undef DUK_USE_DEBUGGER_FWD_LOGGING -#if defined(DUK_OPT_DEBUGGER_SUPPORT) && defined(DUK_OPT_DEBUGGER_FWD_LOGGING) -#define DUK_USE_DEBUGGER_FWD_LOGGING -#endif - -/* DumpHeap is optional because it's not always needed and has a relatively - * large footprint. - */ -#undef DUK_USE_DEBUGGER_DUMPHEAP -#if defined(DUK_OPT_DEBUGGER_DUMPHEAP) -#define DUK_USE_DEBUGGER_DUMPHEAP -#endif - -/* Debugger transport read/write torture. */ -#undef DUK_USE_DEBUGGER_TRANSPORT_TORTURE -#if defined(DUK_OPT_DEBUGGER_TRANSPORT_TORTURE) -#define DUK_USE_DEBUGGER_TRANSPORT_TORTURE -#endif - -/* For opcodes with indirect indices, check final index against stack size. - * This should not be necessary because the compiler is trusted, and we don't - * bound check non-indirect indices either. - */ -#undef DUK_USE_EXEC_INDIRECT_BOUND_CHECK -#if defined(DUK_OPT_DEBUG) || defined(DUK_OPT_ASSERTIONS) -/* Enabled with debug/assertions just so that any issues can be caught. */ -#define DUK_USE_EXEC_INDIRECT_BOUND_CHECK -#endif - -/* - * Debug printing and assertion options - */ - -#undef DUK_USE_DEBUG -#undef DUK_USE_DPRINT -#undef DUK_USE_DDPRINT -#undef DUK_USE_DDDPRINT -#undef DUK_USE_DPRINT_RDTSC -#undef DUK_USE_ASSERTIONS - -/* Global debug enable. Compile must be clean on C99 regardless of whether or - * not debugging is enabled. On non-C99 platforms compile should be clean with - * debugging disabled but may produce warnings with debugging enabled (related - * to debug macro hackery and such). - */ -#if defined(DUK_OPT_DEBUG) -#define DUK_USE_DEBUG -#endif - -#if defined(DUK_OPT_DEBUG) && defined(DUK_OPT_DPRINT) -#define DUK_USE_DPRINT -#endif -#if defined(DUK_OPT_DEBUG) && defined(DUK_OPT_DDPRINT) -#define DUK_USE_DDPRINT -#endif -#if defined(DUK_OPT_DEBUG) && defined(DUK_OPT_DDDPRINT) -#define DUK_USE_DDDPRINT -#endif - -#undef DUK_USE_DPRINT_COLORS -#if defined(DUK_OPT_DPRINT_COLORS) -#define DUK_USE_DPRINT_COLORS -#endif - -#if defined(DUK_RDTSC_AVAILABLE) && defined(DUK_OPT_DPRINT_RDTSC) -#define DUK_USE_DPRINT_RDTSC -#else -#undef DUK_USE_DPRINT_RDTSC -#endif - -#if defined(DUK_OPT_ASSERTIONS) -#define DUK_USE_ASSERTIONS -#endif - -/* The static buffer for debug printing is quite large by default, so there - * is an option to shrink it manually for constrained builds. - */ -#if defined(DUK_OPT_DEBUG_BUFSIZE) -#define DUK_USE_DEBUG_BUFSIZE DUK_OPT_DEBUG_BUFSIZE -#else -#define DUK_USE_DEBUG_BUFSIZE 65536L -#endif - -/* - * Ecmascript features / compliance options - */ - -#if defined(DUK_F_BCC) -/* Math built-in is stubbed out on BCC to allow compiler torture testing. */ -#else -#define DUK_USE_MATH_BUILTIN -#endif - -#define DUK_USE_STRICT_DECL -#if defined(DUK_OPT_NO_STRICT_DECL) -#undef DUK_USE_STRICT_DECL -#endif - -#define DUK_USE_REGEXP_SUPPORT -#if defined(DUK_OPT_NO_REGEXP_SUPPORT) -#undef DUK_USE_REGEXP_SUPPORT -#endif - -#undef DUK_USE_STRICT_UTF8_SOURCE -#if defined(DUK_OPT_STRICT_UTF8_SOURCE) -#define DUK_USE_STRICT_UTF8_SOURCE -#endif - -#define DUK_USE_OCTAL_SUPPORT -#if defined(DUK_OPT_NO_OCTAL_SUPPORT) -#undef DUK_USE_OCTAL_SUPPORT -#endif - -#define DUK_USE_SOURCE_NONBMP -#if defined(DUK_OPT_NO_SOURCE_NONBMP) -#undef DUK_USE_SOURCE_NONBMP -#endif - -#define DUK_USE_BROWSER_LIKE -#if defined(DUK_OPT_NO_BROWSER_LIKE) -#undef DUK_USE_BROWSER_LIKE -#endif - -/* E5/E5.1 Section B features. */ -#define DUK_USE_SECTION_B -#if defined(DUK_OPT_NO_SECTION_B) -#undef DUK_USE_SECTION_B -#endif - -/* Non-standard regexp parsing features. */ -#define DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE - -/* Treat function statements (function declarations outside top level of - * Program or FunctionBody) same as normal function declarations. This is - * also V8 behavior. See test-dev-func-decl-outside-top.js. - */ -#define DUK_USE_NONSTD_FUNC_STMT -#if defined(DUK_OPT_NO_NONSTD_FUNC_STMT) -#undef DUK_USE_NONSTD_FUNC_STMT -#endif - -/* Array.prototype.splice() non-standard but real world compatible behavior - * when deleteCount is omitted. - */ -#define DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT -#if defined(DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT) -#undef DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT -#endif - -/* Array.prototype.concat() non-standard but real world compatible behavior - * for non-existent trailing elements. - */ -#define DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER -#if defined(DUK_OPT_NO_NONSTD_ARRAY_CONCAT_TRAILER) -#undef DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER -#endif - -/* Array.prototype.map() non-standard but real world compatible behavior - * for non-existent trailing elements. - */ -#define DUK_USE_NONSTD_ARRAY_MAP_TRAILER -#if defined(DUK_OPT_NO_NONSTD_ARRAY_MAP_TRAILER) -#undef DUK_USE_NONSTD_ARRAY_MAP_TRAILER -#endif - -/* Non-standard 'caller' property for function instances, see - * test-bi-function-nonstd-caller-prop.js. - */ -#undef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY -#if defined(DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY) -#define DUK_USE_NONSTD_FUNC_CALLER_PROPERTY -#endif - -/* Non-standard Object.prototype.__proto__ (ES6 draft), see - * test-bi-object-proto-__proto__.js. - */ -#define DUK_USE_ES6_OBJECT_PROTO_PROPERTY -#if defined(DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY) -#undef DUK_USE_ES6_OBJECT_PROTO_PROPERTY -#endif - -/* Non-standard Object.setPrototypeOf (ES6 draft), see - * test-bi-object-setprototypeof.js. - */ -#define DUK_USE_ES6_OBJECT_SETPROTOTYPEOF -#if defined(DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF) -#undef DUK_USE_ES6_OBJECT_SETPROTOTYPEOF -#endif - -/* ES6 Proxy object (subset for now). */ -#define DUK_USE_ES6_PROXY -#if defined(DUK_OPT_NO_ES6_PROXY) -#undef DUK_USE_ES6_PROXY -#endif - -/* Record pc-to-line information. */ -#define DUK_USE_PC2LINE -#if defined(DUK_OPT_NO_PC2LINE) -#undef DUK_USE_PC2LINE -#endif - -/* Non-standard function 'source' property. */ -#undef DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY -#if defined(DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY) -#define DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY -#endif - -/* CommonJS modules */ -#define DUK_USE_COMMONJS_MODULES -#if defined(DUK_OPT_NO_COMMONJS_MODULES) -#undef DUK_USE_COMMONJS_MODULES -#endif - -/* Additional key argument to setter/getter calls when triggered by property - * accesses. - */ - -#define DUK_USE_NONSTD_GETTER_KEY_ARGUMENT -#define DUK_USE_NONSTD_SETTER_KEY_ARGUMENT -#if defined(DUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT) -#undef DUK_USE_NONSTD_GETTER_KEY_ARGUMENT -#undef DUK_USE_NONSTD_SETTER_KEY_ARGUMENT -#endif - -/* JSON escaping of U+2028 and U+2029. - */ - -#define DUK_USE_NONSTD_JSON_ESC_U2028_U2029 -#if defined(DUK_OPT_NO_NONSTD_JSON_ESC_U2028_U2029) -#undef DUK_USE_NONSTD_JSON_ESC_U2028_U2029 -#endif - -/* Allow 32-bit codepoints in String.fromCharCode. */ -#define DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT -#if defined(DUK_OPT_NO_NONSTD_STRING_FROMCHARCODE_32BIT) -#undef DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT -#endif - -/* Non-standard array fast path write behavior: when writing to numeric - * indexes of an Array instance, assume Array.prototype doesn't have - * conflicting properties (e.g. a non-writable property "7"). - */ -#define DUK_USE_NONSTD_ARRAY_WRITE -#if defined(DUK_OPT_NO_NONSTD_ARRAY_WRITE) -#undef DUK_USE_NONSTD_ARRAY_WRITE -#endif - -/* - * Tailcalls - */ - -/* Tailcalls are enabled by default. The non-standard function 'caller' - * property feature conflicts with tailcalls quite severely so tailcalls - * are disabled if the 'caller' property is enabled. - */ -#define DUK_USE_TAILCALL -#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY) -#undef DUK_USE_TAILCALL -#endif - -/* - * Deep vs. shallow stack. - * - * Some embedded platforms have very shallow stack (e.g. 64kB); default to - * a shallow stack on unknown platforms or known embedded platforms. - */ - -#if defined(DUK_F_LINUX) || defined(DUK_F_BSD) || defined(DUK_F_WINDOWS) || \ - defined(DUK_OPT_DEEP_C_STACK) -#define DUK_USE_DEEP_C_STACK -#else -#undef DUK_USE_DEEP_C_STACK -#endif - -/* - * Ecmascript compiler - */ - -/* Ensure final bytecode never exceeds a certain byte size and never uses - * line numbers above a certain limit. This ensures that there is no need - * to deal with unbounded ranges in e.g. pc2line data structures. For now, - * limits are set so that signed 32-bit values can represent line number - * and byte offset with room to spare. - */ -#define DUK_USE_ESBC_LIMITS -#define DUK_USE_ESBC_MAX_LINENUMBER 0x7fff0000L -#define DUK_USE_ESBC_MAX_BYTES 0x7fff0000L - -#undef DUK_USE_SHUFFLE_TORTURE -#if defined(DUK_OPT_SHUFFLE_TORTURE) -#define DUK_USE_SHUFFLE_TORTURE -#endif - -/* - * User panic handler, panic exit behavior for default panic handler - */ - -#undef DUK_USE_PANIC_HANDLER -#if defined(DUK_OPT_PANIC_HANDLER) -#define DUK_USE_PANIC_HANDLER(code,msg) DUK_OPT_PANIC_HANDLER((code),(msg)) -#endif - -#undef DUK_USE_PANIC_ABORT -#undef DUK_USE_PANIC_EXIT -#undef DUK_USE_PANIC_SEGFAULT - -#if defined(DUK_OPT_SEGFAULT_ON_PANIC) -#define DUK_USE_PANIC_SEGFAULT -#else -#define DUK_USE_PANIC_ABORT -#endif - -/* - * File I/O support. This is now used in a few API calls to e.g. push - * a string from file contents or eval a file. For portability it must - * be possible to disable I/O altogether. - */ - -#undef DUK_USE_FILE_IO -#if !defined(DUK_OPT_NO_FILE_IO) -#define DUK_USE_FILE_IO -#endif - -/* - * Optional run-time self tests executed when a heap is created. Some - * platform/compiler issues cannot be determined at compile time. One - * particular example is the bug described in misc/clang_aliasing.c. - */ - -#undef DUK_USE_SELF_TESTS -#if defined(DUK_OPT_SELF_TESTS) -#define DUK_USE_SELF_TESTS -#endif - -/* Double aliasing testcase fails when Emscripten-generated code is run - * on Firefox. This is not fatal because it only affects packed duk_tval - * which we avoid with Emscripten. - */ -#undef DUK_USE_NO_DOUBLE_ALIASING_SELFTEST -#if defined(DUK_F_EMSCRIPTEN) -#define DUK_USE_NO_DOUBLE_ALIASING_SELFTEST -#endif - -/* - * Codecs - */ - -#define DUK_USE_JX -#if defined(DUK_OPT_NO_JX) -#undef DUK_USE_JX -#endif - -#define DUK_USE_JC -#if defined(DUK_OPT_NO_JC) -#undef DUK_USE_JC -#endif - -/* - * InitJS code - */ - -/* Always use the built-in InitJS code for now. */ -#define DUK_USE_BUILTIN_INITJS - -/* User provided InitJS. */ -#undef DUK_USE_USER_INITJS -#if defined(DUK_OPT_USER_INITJS) -#define DUK_USE_USER_INITJS (DUK_OPT_USER_INITJS) -#endif - -/* - * External string data support - * - * Allow duk_hstrings to store data also behind an external pointer (see - * duk_hstring_external). This increases code size slightly but is useful - * in low memory environments where memory is more limited than flash. - */ - -#undef DUK_USE_HSTRING_EXTDATA -#if defined(DUK_OPT_EXTERNAL_STRINGS) -#define DUK_USE_HSTRING_EXTDATA -#endif - -#undef DUK_USE_EXTSTR_INTERN_CHECK -#if defined(DUK_OPT_EXTERNAL_STRINGS) && defined(DUK_OPT_EXTSTR_INTERN_CHECK) -#define DUK_USE_EXTSTR_INTERN_CHECK(udata,ptr,len) DUK_OPT_EXTSTR_INTERN_CHECK((udata), (ptr), (len)) -#endif - -#undef DUK_USE_EXTSTR_FREE -#if defined(DUK_OPT_EXTERNAL_STRINGS) && defined(DUK_OPT_EXTSTR_FREE) -#define DUK_USE_EXTSTR_FREE(udata,ptr) DUK_OPT_EXTSTR_FREE((udata), (ptr)) -#endif - -/* - * Lightweight functions - */ - -/* Force built-ins to use lightfunc function pointers when possible. This - * makes the built-in functions non-compliant with respect to their property - * values and such, but is very useful in low memory environments (can save - * around 14kB of initial RAM footprint). - */ -#undef DUK_USE_LIGHTFUNC_BUILTINS -#if defined(DUK_OPT_LIGHTFUNC_BUILTINS) -#define DUK_USE_LIGHTFUNC_BUILTINS -#endif - -/* - * Pointer compression and 16-bit header fields for low memory environments - */ - -#undef DUK_USE_HEAPPTR16 -#undef DUK_USE_HEAPPTR_ENC16 -#undef DUK_USE_HEAPPTR_DEC16 -#if defined(DUK_OPT_HEAPPTR16) && defined(DUK_OPT_HEAPPTR_ENC16) && defined(DUK_OPT_HEAPPTR_DEC16) -#define DUK_USE_HEAPPTR16 -#define DUK_USE_HEAPPTR_ENC16(udata,ptr) DUK_OPT_HEAPPTR_ENC16((udata),(ptr)) -#define DUK_USE_HEAPPTR_DEC16(udata,ptr) DUK_OPT_HEAPPTR_DEC16((udata),(ptr)) -#endif - -#undef DUK_USE_DATAPTR16 -#undef DUK_USE_DATAPTR_ENC16 -#undef DUK_USE_DATAPTR_DEC16 -#if defined(DUK_OPT_DATAPTR16) && defined(DUK_OPT_DATAPTR_ENC16) && defined(DUK_OPT_DATAPTR_DEC16) -#define DUK_USE_DATAPTR16 -#define DUK_USE_DATAPTR_ENC16(udata,ptr) DUK_OPT_DATAPTR_ENC16((udata),(ptr)) -#define DUK_USE_DATAPTR_DEC16(udata,ptr) DUK_OPT_DATAPTR_DEC16((udata),(ptr)) -#endif - -#undef DUK_USE_FUNCPTR16 -#undef DUK_USE_FUNCPTR_ENC16 -#undef DUK_USE_FUNCPTR_DEC16 -#if defined(DUK_OPT_FUNCPTR16) && defined(DUK_OPT_FUNCPTR_ENC16) && defined(DUK_OPT_FUNCPTR_DEC16) -#define DUK_USE_FUNCPTR16 -#define DUK_USE_FUNCPTR_ENC16(udata,ptr) DUK_OPT_FUNCPTR_ENC16((udata),(ptr)) -#define DUK_USE_FUNCPTR_DEC16(udata,ptr) DUK_OPT_FUNCPTR_DEC16((udata),(ptr)) -#endif - -#undef DUK_USE_REFCOUNT16 -#if defined(DUK_OPT_REFCOUNT16) -#define DUK_USE_REFCOUNT16 -#endif - -#undef DUK_USE_STRHASH16 -#if defined(DUK_OPT_STRHASH16) -#define DUK_USE_STRHASH16 -#endif - -#undef DUK_USE_STRLEN16 -#if defined(DUK_OPT_STRLEN16) -#define DUK_USE_STRLEN16 -#endif - -#undef DUK_USE_BUFLEN16 -#if defined(DUK_OPT_BUFLEN16) -#define DUK_USE_BUFLEN16 -#endif - -#undef DUK_USE_OBJSIZES16 -#if defined(DUK_OPT_OBJSIZES16) -#define DUK_USE_OBJSIZES16 -#endif - -/* For now, hash part is dropped if and only if 16-bit object fields are used. */ -#define DUK_USE_HOBJECT_HASH_PART -#if defined(DUK_USE_OBJSIZES16) -#undef DUK_USE_HOBJECT_HASH_PART -#endif - -/* - * Miscellaneous - */ - -#define DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS -#undef DUK_USE_EXPLICIT_NULL_INIT - -#if !defined(DUK_USE_PACKED_TVAL) -#define DUK_USE_EXPLICIT_NULL_INIT -#endif - -#define DUK_USE_ZERO_BUFFER_DATA -#if defined(DUK_OPT_NO_ZERO_BUFFER_DATA) -#undef DUK_USE_ZERO_BUFFER_DATA -#endif - -#undef DUK_USE_VARIADIC_MACROS -#if defined(DUK_F_C99) || (defined(DUK_F_CPP11) && defined(__GNUC__)) -#define DUK_USE_VARIADIC_MACROS -#endif -#if defined(_MSC_VER) && !defined(DUK_USE_VARIADIC_MACROS) -#if (_MSC_VER >= 1400) -/* VS2005+ should have variadic macros even when they're not C99. */ -#define DUK_USE_VARIADIC_MACROS -#endif -#endif - -/* - * Variable size array initialization. - * - * Variable size array at the end of a structure is nonportable. - * There are three alternatives: - * - * 1) C99 (flexible array member): char buf[] - * 2) Compiler specific (e.g. GCC): char buf[0] - * 3) Portable but wastes memory / complicates allocation: char buf[1] - */ - -/* XXX: Currently unused, only hbuffer.h needed this at some point. */ -#undef DUK_USE_FLEX_C99 -#undef DUK_USE_FLEX_ZEROSIZE -#undef DUK_USE_FLEX_ONESIZE -#if defined(DUK_F_C99) -#define DUK_USE_FLEX_C99 -#elif defined(__GNUC__) -#define DUK_USE_FLEX_ZEROSIZE -#else -#define DUK_USE_FLEX_ONESIZE -#endif - -/* - * GCC pragmas - */ - -/* XXX: GCC pragma inside a function fails in some earlier GCC versions (e.g. gcc 4.5). - * This is very approximate but allows clean builds for development right now. - */ -/* http://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html */ -#if defined(__GNUC__) && defined(__GNUC_MINOR__) && (__GNUC__ == 4) && (__GNUC_MINOR__ >= 6) -#define DUK_USE_GCC_PRAGMAS -#else -#undef DUK_USE_GCC_PRAGMAS -#endif - -/* - * User declarations - */ - -#if defined(DUK_OPT_DECLARE) -#define DUK_USE_USER_DECLARE() DUK_OPT_DECLARE -#else -#define DUK_USE_USER_DECLARE() /* no user declarations */ -#endif - -/* - * Alternative customization header - * - * If you want to modify the final DUK_USE_xxx flags directly (without - * using the available DUK_OPT_Xxx flags), define DUK_OPT_HAVE_CUSTOM_H - * and tweak the final flags there. - */ - -#if defined(DUK_OPT_HAVE_CUSTOM_H) -#include "duk_custom.h" -#endif - -#endif /* DUK_FEATURES_H_INCLUDED */ +#include "duk_config.h" /* * BEGIN PUBLIC API @@ -3114,9 +154,6 @@ extern "C" { /* * Public API specific typedefs * - * (duk_context *) maps directly to internal type (duk_hthread *). - * Currently only primitive typedefs have a '_t' suffix. - * * Many types are wrapped by Duktape for portability to rare platforms * where e.g. 'int' is a 16-bit type. See practical typing discussion * in Duktape web documentation. @@ -3126,7 +163,9 @@ struct duk_memory_functions; struct duk_function_list_entry; struct duk_number_list_entry; -typedef void duk_context; +/* duk_context is now defined in duk_config.h because it may also be + * referenced there by prototypes. + */ typedef struct duk_memory_functions duk_memory_functions; typedef struct duk_function_list_entry duk_function_list_entry; typedef struct duk_number_list_entry duk_number_list_entry; @@ -3174,13 +213,16 @@ struct duk_number_list_entry { * have 99 for patch level (e.g. 0.10.99 would be a development version * after 0.10.0 but before the next official release). */ -#define DUK_VERSION 10202L +#define DUK_VERSION 10400L -/* Git describe for Duktape build. Useful for non-official snapshot builds - * so that application code can easily log which Duktape snapshot was used. - * Not available in the Ecmascript environment. +/* Git commit, describe, and branch for Duktape build. Useful for + * non-official snapshot builds so that application code can easily log + * which Duktape snapshot was used. Not available in the Ecmascript + * environment. */ -#define DUK_GIT_DESCRIBE "v1.2.2" +#define DUK_GIT_COMMIT "cad6f595382a0cc1a7e4207794ade5be11b3e397" +#define DUK_GIT_DESCRIBE "v1.4.0" +#define DUK_GIT_BRANCH "master" /* Duktape debug protocol version used by this build. */ #define DUK_DEBUG_PROTOCOL_VERSION 1 @@ -3202,6 +244,7 @@ struct duk_number_list_entry { #define DUK_API_ENTRY_STACK 64 /* Value types, used by e.g. duk_get_type() */ +#define DUK_TYPE_MIN 0 #define DUK_TYPE_NONE 0 /* no value, e.g. invalid index */ #define DUK_TYPE_UNDEFINED 1 /* Ecmascript undefined */ #define DUK_TYPE_NULL 2 /* Ecmascript null */ @@ -3212,6 +255,7 @@ struct duk_number_list_entry { #define DUK_TYPE_BUFFER 7 /* fixed or dynamic, garbage collected byte buffer */ #define DUK_TYPE_POINTER 8 /* raw void pointer */ #define DUK_TYPE_LIGHTFUNC 9 /* lightweight function pointer */ +#define DUK_TYPE_MAX 9 /* Value mask types, used by e.g. duk_get_type_mask() */ #define DUK_TYPE_MASK_NONE (1 << DUK_TYPE_NONE) @@ -3242,9 +286,9 @@ struct duk_number_list_entry { #define DUK_ENUM_NO_PROXY_BEHAVIOR (1 << 5) /* enumerate a proxy object itself without invoking proxy behavior */ /* Compilation flags for duk_compile() and duk_eval() */ -#define DUK_COMPILE_EVAL (1 << 0) /* compile eval code (instead of program) */ -#define DUK_COMPILE_FUNCTION (1 << 1) /* compile function code (instead of program) */ -#define DUK_COMPILE_STRICT (1 << 2) /* use strict (outer) context for program, eval, or function */ +#define DUK_COMPILE_EVAL (1 << 0) /* compile eval code (instead of global code) */ +#define DUK_COMPILE_FUNCTION (1 << 1) /* compile function code (instead of global code) */ +#define DUK_COMPILE_STRICT (1 << 2) /* use strict (outer) context for global, eval, or function code */ #define DUK_COMPILE_SAFE (1 << 3) /* (internal) catch compilation errors */ #define DUK_COMPILE_NORESULT (1 << 4) /* (internal) omit eval result */ #define DUK_COMPILE_NOSOURCE (1 << 5) /* (internal) no source string on stack */ @@ -3261,6 +305,12 @@ struct duk_number_list_entry { #define DUK_DEFPROP_HAVE_GETTER (1 << 7) /* set getter (given on value stack) */ #define DUK_DEFPROP_HAVE_SETTER (1 << 8) /* set setter (given on value stack) */ #define DUK_DEFPROP_FORCE (1 << 9) /* force change if possible, may still fail for e.g. virtual properties */ +#define DUK_DEFPROP_SET_WRITABLE (DUK_DEFPROP_HAVE_WRITABLE | DUK_DEFPROP_WRITABLE) +#define DUK_DEFPROP_CLEAR_WRITABLE DUK_DEFPROP_HAVE_WRITABLE +#define DUK_DEFPROP_SET_ENUMERABLE (DUK_DEFPROP_HAVE_ENUMERABLE | DUK_DEFPROP_ENUMERABLE) +#define DUK_DEFPROP_CLEAR_ENUMERABLE DUK_DEFPROP_HAVE_ENUMERABLE +#define DUK_DEFPROP_SET_CONFIGURABLE (DUK_DEFPROP_HAVE_CONFIGURABLE | DUK_DEFPROP_CONFIGURABLE) +#define DUK_DEFPROP_CLEAR_CONFIGURABLE DUK_DEFPROP_HAVE_CONFIGURABLE /* Flags for duk_push_thread_raw() */ #define DUK_THREAD_NEW_GLOBAL_ENV (1 << 0) /* create a new global environment */ @@ -3502,16 +552,36 @@ DUK_EXTERNAL_DECL duk_idx_t duk_push_error_object_va_raw(duk_context *ctx, duk_e duk_push_error_object_va_raw((ctx), (err_code), (const char *) (__FILE__), (duk_int_t) (__LINE__), (fmt), (ap)) #define DUK_BUF_FLAG_DYNAMIC (1 << 0) /* internal flag: dynamic buffer */ -#define DUK_BUF_FLAG_NOZERO (1 << 1) /* internal flag: don't zero allocated buffer */ +#define DUK_BUF_FLAG_EXTERNAL (1 << 1) /* internal flag: external buffer */ +#define DUK_BUF_FLAG_NOZERO (1 << 2) /* internal flag: don't zero allocated buffer */ DUK_EXTERNAL_DECL void *duk_push_buffer_raw(duk_context *ctx, duk_size_t size, duk_small_uint_t flags); #define duk_push_buffer(ctx,size,dynamic) \ - duk_push_buffer_raw((ctx), (size), (dynamic)); + duk_push_buffer_raw((ctx), (size), (dynamic) ? DUK_BUF_FLAG_DYNAMIC : 0) #define duk_push_fixed_buffer(ctx,size) \ - duk_push_buffer_raw((ctx), (size), 0 /*dynamic*/) + duk_push_buffer_raw((ctx), (size), 0 /*flags*/) #define duk_push_dynamic_buffer(ctx,size) \ - duk_push_buffer_raw((ctx), (size), 1 /*dynamic*/) + duk_push_buffer_raw((ctx), (size), DUK_BUF_FLAG_DYNAMIC /*flags*/) +#define duk_push_external_buffer(ctx) \ + ((void) duk_push_buffer_raw((ctx), 0, DUK_BUF_FLAG_DYNAMIC | DUK_BUF_FLAG_EXTERNAL)) + +#define DUK_BUFOBJ_CREATE_ARRBUF (1 << 4) /* internal flag: create backing ArrayBuffer; keep in one byte */ +#define DUK_BUFOBJ_DUKTAPE_BUFFER 0 +#define DUK_BUFOBJ_NODEJS_BUFFER 1 +#define DUK_BUFOBJ_ARRAYBUFFER 2 +#define DUK_BUFOBJ_DATAVIEW (3 | DUK_BUFOBJ_CREATE_ARRBUF) +#define DUK_BUFOBJ_INT8ARRAY (4 | DUK_BUFOBJ_CREATE_ARRBUF) +#define DUK_BUFOBJ_UINT8ARRAY (5 | DUK_BUFOBJ_CREATE_ARRBUF) +#define DUK_BUFOBJ_UINT8CLAMPEDARRAY (6 | DUK_BUFOBJ_CREATE_ARRBUF) +#define DUK_BUFOBJ_INT16ARRAY (7 | DUK_BUFOBJ_CREATE_ARRBUF) +#define DUK_BUFOBJ_UINT16ARRAY (8 | DUK_BUFOBJ_CREATE_ARRBUF) +#define DUK_BUFOBJ_INT32ARRAY (9 | DUK_BUFOBJ_CREATE_ARRBUF) +#define DUK_BUFOBJ_UINT32ARRAY (10 | DUK_BUFOBJ_CREATE_ARRBUF) +#define DUK_BUFOBJ_FLOAT32ARRAY (11 | DUK_BUFOBJ_CREATE_ARRBUF) +#define DUK_BUFOBJ_FLOAT64ARRAY (12 | DUK_BUFOBJ_CREATE_ARRBUF) + +DUK_EXTERNAL_DECL void duk_push_buffer_object(duk_context *ctx, duk_idx_t idx_buffer, duk_size_t byte_offset, duk_size_t byte_length, duk_uint_t flags); DUK_EXTERNAL_DECL duk_idx_t duk_push_heapptr(duk_context *ctx, void *ptr); @@ -3555,11 +625,22 @@ DUK_EXTERNAL_DECL duk_bool_t duk_is_ecmascript_function(duk_context *ctx, duk_id DUK_EXTERNAL_DECL duk_bool_t duk_is_bound_function(duk_context *ctx, duk_idx_t index); DUK_EXTERNAL_DECL duk_bool_t duk_is_thread(duk_context *ctx, duk_idx_t index); -DUK_EXTERNAL_DECL duk_bool_t duk_is_callable(duk_context *ctx, duk_idx_t index); +#define duk_is_callable(ctx,index) \ + duk_is_function((ctx), (index)) DUK_EXTERNAL_DECL duk_bool_t duk_is_dynamic_buffer(duk_context *ctx, duk_idx_t index); DUK_EXTERNAL_DECL duk_bool_t duk_is_fixed_buffer(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL duk_bool_t duk_is_external_buffer(duk_context *ctx, duk_idx_t index); + +#define duk_is_primitive(ctx,index) \ + duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_UNDEFINED | \ + DUK_TYPE_MASK_NULL | \ + DUK_TYPE_MASK_BOOLEAN | \ + DUK_TYPE_MASK_NUMBER | \ + DUK_TYPE_MASK_STRING | \ + DUK_TYPE_MASK_BUFFER | \ + DUK_TYPE_MASK_POINTER | \ + DUK_TYPE_MASK_LIGHTFUNC) -DUK_EXTERNAL_DECL duk_bool_t duk_is_primitive(duk_context *ctx, duk_idx_t index); #define duk_is_object_coercible(ctx,index) \ duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_BOOLEAN | \ DUK_TYPE_MASK_NUMBER | \ @@ -3572,6 +653,18 @@ DUK_EXTERNAL_DECL duk_bool_t duk_is_primitive(duk_context *ctx, duk_idx_t index) DUK_EXTERNAL_DECL duk_errcode_t duk_get_error_code(duk_context *ctx, duk_idx_t index); #define duk_is_error(ctx,index) \ (duk_get_error_code((ctx), (index)) != 0) +#define duk_is_eval_error(ctx,index) \ + (duk_get_error_code((ctx), (index)) == DUK_ERR_EVAL_ERROR) +#define duk_is_range_error(ctx,index) \ + (duk_get_error_code((ctx), (index)) == DUK_ERR_RANGE_ERROR) +#define duk_is_reference_error(ctx,index) \ + (duk_get_error_code((ctx), (index)) == DUK_ERR_REFERENCE_ERROR) +#define duk_is_syntax_error(ctx,index) \ + (duk_get_error_code((ctx), (index)) == DUK_ERR_SYNTAX_ERROR) +#define duk_is_type_error(ctx,index) \ + (duk_get_error_code((ctx), (index)) == DUK_ERR_TYPE_ERROR) +#define duk_is_uri_error(ctx,index) \ + (duk_get_error_code((ctx), (index)) == DUK_ERR_URI_ERROR) /* * Get operations: no coercion, returns default value for invalid @@ -3588,6 +681,7 @@ DUK_EXTERNAL_DECL duk_uint_t duk_get_uint(duk_context *ctx, duk_idx_t index); DUK_EXTERNAL_DECL const char *duk_get_string(duk_context *ctx, duk_idx_t index); DUK_EXTERNAL_DECL const char *duk_get_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len); DUK_EXTERNAL_DECL void *duk_get_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size); +DUK_EXTERNAL_DECL void *duk_get_buffer_data(duk_context *ctx, duk_idx_t index, duk_size_t *out_size); DUK_EXTERNAL_DECL void *duk_get_pointer(duk_context *ctx, duk_idx_t index); DUK_EXTERNAL_DECL duk_c_function duk_get_c_function(duk_context *ctx, duk_idx_t index); DUK_EXTERNAL_DECL duk_context *duk_get_context(duk_context *ctx, duk_idx_t index); @@ -3611,9 +705,13 @@ DUK_EXTERNAL_DECL duk_uint_t duk_require_uint(duk_context *ctx, duk_idx_t index) DUK_EXTERNAL_DECL const char *duk_require_string(duk_context *ctx, duk_idx_t index); DUK_EXTERNAL_DECL const char *duk_require_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len); DUK_EXTERNAL_DECL void *duk_require_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size); +DUK_EXTERNAL_DECL void *duk_require_buffer_data(duk_context *ctx, duk_idx_t index, duk_size_t *out_size); DUK_EXTERNAL_DECL void *duk_require_pointer(duk_context *ctx, duk_idx_t index); DUK_EXTERNAL_DECL duk_c_function duk_require_c_function(duk_context *ctx, duk_idx_t index); DUK_EXTERNAL_DECL duk_context *duk_require_context(duk_context *ctx, duk_idx_t index); +DUK_EXTERNAL_DECL void duk_require_function(duk_context *ctx, duk_idx_t index); +#define duk_require_callable(ctx,index) \ + duk_require_function((ctx), (index)) DUK_EXTERNAL_DECL void *duk_require_heapptr(duk_context *ctx, duk_idx_t index); #define duk_require_object_coercible(ctx,index) \ @@ -3682,6 +780,8 @@ DUK_EXTERNAL_DECL void duk_json_decode(duk_context *ctx, duk_idx_t index); */ DUK_EXTERNAL_DECL void *duk_resize_buffer(duk_context *ctx, duk_idx_t index, duk_size_t new_size); +DUK_EXTERNAL_DECL void *duk_steal_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size); +DUK_EXTERNAL_DECL void duk_config_buffer(duk_context *ctx, duk_idx_t index, void *ptr, duk_size_t len); /* * Property access @@ -3781,6 +881,7 @@ DUK_EXTERNAL_DECL duk_codepoint_t duk_char_code_at(duk_context *ctx, duk_idx_t i DUK_EXTERNAL_DECL duk_bool_t duk_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2); DUK_EXTERNAL_DECL duk_bool_t duk_strict_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2); +DUK_EXTERNAL_DECL duk_bool_t duk_instanceof(duk_context *ctx, duk_idx_t index1, duk_idx_t index2); /* * Function (method) calls @@ -3793,6 +894,7 @@ DUK_EXTERNAL_DECL duk_int_t duk_pcall(duk_context *ctx, duk_idx_t nargs); DUK_EXTERNAL_DECL duk_int_t duk_pcall_method(duk_context *ctx, duk_idx_t nargs); DUK_EXTERNAL_DECL duk_int_t duk_pcall_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs); DUK_EXTERNAL_DECL void duk_new(duk_context *ctx, duk_idx_t nargs); +DUK_EXTERNAL_DECL duk_int_t duk_pnew(duk_context *ctx, duk_idx_t nargs); DUK_EXTERNAL_DECL duk_int_t duk_safe_call(duk_context *ctx, duk_safe_call_function func, duk_idx_t nargs, duk_idx_t nrets); /* @@ -3926,6 +1028,13 @@ DUK_EXTERNAL_DECL duk_int_t duk_compile_raw(duk_context *ctx, const char *src_bu (void) duk_push_string((ctx), (path)), \ duk_compile_raw((ctx), NULL, 0, (flags) | DUK_COMPILE_SAFE)) +/* + * Bytecode load/dump + */ + +DUK_EXTERNAL_DECL void duk_dump_function(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_load_function(duk_context *ctx); + /* * Logging */ @@ -3971,6 +1080,84 @@ DUK_EXTERNAL_DECL void duk_debugger_attach(duk_context *ctx, DUK_EXTERNAL_DECL void duk_debugger_detach(duk_context *ctx); DUK_EXTERNAL_DECL void duk_debugger_cooperate(duk_context *ctx); +/* + * Date provider related constants + * + * NOTE: These are "semi public" - you should only use these if you write + * your own platform specific Date provider, see doc/datetime.rst. + */ + +/* Millisecond count constants. */ +#define DUK_DATE_MSEC_SECOND 1000L +#define DUK_DATE_MSEC_MINUTE (60L * 1000L) +#define DUK_DATE_MSEC_HOUR (60L * 60L * 1000L) +#define DUK_DATE_MSEC_DAY (24L * 60L * 60L * 1000L) + +/* Ecmascript date range is 100 million days from Epoch: + * > 100e6 * 24 * 60 * 60 * 1000 // 100M days in millisecs + * 8640000000000000 + * (= 8.64e15) + */ +#define DUK_DATE_MSEC_100M_DAYS (8.64e15) +#define DUK_DATE_MSEC_100M_DAYS_LEEWAY (8.64e15 + 24 * 3600e3) + +/* Ecmascript year range: + * > new Date(100e6 * 24 * 3600e3).toISOString() + * '+275760-09-13T00:00:00.000Z' + * > new Date(-100e6 * 24 * 3600e3).toISOString() + * '-271821-04-20T00:00:00.000Z' + */ +#define DUK_DATE_MIN_ECMA_YEAR (-271821L) +#define DUK_DATE_MAX_ECMA_YEAR 275760L + +/* Part indices for internal breakdowns. Part order from DUK_DATE_IDX_YEAR + * to DUK_DATE_IDX_MILLISECOND matches argument ordering of Ecmascript API + * calls (like Date constructor call). Some functions in duk_bi_date.c + * depend on the specific ordering, so change with care. 16 bits are not + * enough for all parts (year, specifically). + * + * (Must be in-sync with genbuiltins.py.) + */ +#define DUK_DATE_IDX_YEAR 0 /* year */ +#define DUK_DATE_IDX_MONTH 1 /* month: 0 to 11 */ +#define DUK_DATE_IDX_DAY 2 /* day within month: 0 to 30 */ +#define DUK_DATE_IDX_HOUR 3 +#define DUK_DATE_IDX_MINUTE 4 +#define DUK_DATE_IDX_SECOND 5 +#define DUK_DATE_IDX_MILLISECOND 6 +#define DUK_DATE_IDX_WEEKDAY 7 /* weekday: 0 to 6, 0=sunday, 1=monday, etc */ +#define DUK_DATE_IDX_NUM_PARTS 8 + +/* Internal API call flags, used for various functions in this file. + * Certain flags are used by only certain functions, but since the flags + * don't overlap, a single flags value can be passed around to multiple + * functions. + * + * The unused top bits of the flags field are also used to pass values + * to helpers (duk__get_part_helper() and duk__set_part_helper()). + * + * (Must be in-sync with genbuiltins.py.) + */ + +/* NOTE: when writing a Date provider you only need a few specific + * flags from here, the rest are internal. Avoid using anything you + * don't need. + */ + +#define DUK_DATE_FLAG_NAN_TO_ZERO (1 << 0) /* timeval breakdown: internal time value NaN -> zero */ +#define DUK_DATE_FLAG_NAN_TO_RANGE_ERROR (1 << 1) /* timeval breakdown: internal time value NaN -> RangeError (toISOString) */ +#define DUK_DATE_FLAG_ONEBASED (1 << 2) /* timeval breakdown: convert month and day-of-month parts to one-based (default is zero-based) */ +#define DUK_DATE_FLAG_EQUIVYEAR (1 << 3) /* timeval breakdown: replace year with equivalent year in the [1971,2037] range for DST calculations */ +#define DUK_DATE_FLAG_LOCALTIME (1 << 4) /* convert time value to local time */ +#define DUK_DATE_FLAG_SUB1900 (1 << 5) /* getter: subtract 1900 from year when getting year part */ +#define DUK_DATE_FLAG_TOSTRING_DATE (1 << 6) /* include date part in string conversion result */ +#define DUK_DATE_FLAG_TOSTRING_TIME (1 << 7) /* include time part in string conversion result */ +#define DUK_DATE_FLAG_TOSTRING_LOCALE (1 << 8) /* use locale specific formatting if available */ +#define DUK_DATE_FLAG_TIMESETTER (1 << 9) /* setter: call is a time setter (affects hour, min, sec, ms); otherwise date setter (affects year, month, day-in-month) */ +#define DUK_DATE_FLAG_YEAR_FIXUP (1 << 10) /* setter: perform 2-digit year fixup (00...99 -> 1900...1999) */ +#define DUK_DATE_FLAG_SEP_T (1 << 11) /* string conversion: use 'T' instead of ' ' as a separator */ +#define DUK_DATE_FLAG_VALUE_SHIFT 12 /* additional values begin at bit 12 */ + /* * C++ name mangling */ @@ -3986,117 +1173,6 @@ DUK_EXTERNAL_DECL void duk_debugger_cooperate(duk_context *ctx); * END PUBLIC API */ -/* - * Sanity check for the final effective internal defines. This file also - * double checks user tweaks made by an optional duk_custom.h header. - */ - -#ifndef DUK_FEATURES_SANITY_H_INCLUDED -#define DUK_FEATURES_SANITY_H_INCLUDED - -/* - * Deprecated feature options. - * - * Catch so that user more easily notices and updates build. - */ - -#if defined(DUK_OPT_NO_FUNC_STMT) -#error DUK_OPT_NO_FUNC_STMT is deprecated, use DUK_OPT_NO_NONSTD_FUNC_STMT -#endif - -#if defined(DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY) -#error DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY is deprecated, use DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY -#endif - -#if defined(DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY) -#error DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY is deprecated, use DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY -#endif - -#if defined(DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT) -#error DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT is deprecated, use DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT -#endif - -#if defined(DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY) -#error DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY is deprecated, use DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY -#endif - -#if defined(DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF) -#error DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF is deprecated, use DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF -#endif - -#if defined(DUK_OPT_NO_JSONX) -#error DUK_OPT_NO_JSONX is deprecated, use DUK_OPT_NO_JX -#endif - -#if defined(DUK_OPT_NO_JSONC) -#error DUK_OPT_NO_JSONC is deprecated, use DUK_OPT_NO_JC -#endif - -/* - * Debug print consistency - */ - -#if defined(DUK_USE_DPRINT) && !defined(DUK_USE_DEBUG) -#error DUK_USE_DPRINT without DUK_USE_DEBUG -#endif - -#if defined(DUK_USE_DDPRINT) && !defined(DUK_USE_DEBUG) -#error DUK_USE_DDPRINT without DUK_USE_DEBUG -#endif - -#if defined(DUK_USE_DDDPRINT) && !defined(DUK_USE_DEBUG) -#error DUK_USE_DDDPRINT without DUK_USE_DEBUG -#endif - -#if defined(DUK_USE_HEAPPTR16) && defined(DUK_USE_DEBUG) -/* Debug code doesn't have access to 'heap' so it cannot decode pointers. */ -#error debug printing cannot currently be used with heap pointer compression -#endif - -/* - * Debugger consistency - */ - -#if defined(DUK_USE_DEBUGGER_SUPPORT) -#if !defined(DUK_USE_INTERRUPT_COUNTER) -#error DUK_USE_INTERRUPT_COUNTER is needed when debugger support is enabled -#endif -#if !defined(DUK_USE_PC2LINE) -#error DUK_USE_PC2LINE is needed when debugger support is enabled -#endif -#endif - -/* - * Garbage collection consistency - */ - -#if defined(DUK_USE_REFERENCE_COUNTING) && !defined(DUK_USE_DOUBLE_LINKED_HEAP) -#error DUK_USE_REFERENCE_COUNTING defined without DUK_USE_DOUBLE_LINKED_HEAP -#endif - -#if defined(DUK_USE_GC_TORTURE) && !defined(DUK_USE_MARK_AND_SWEEP) -#error DUK_USE_GC_TORTURE defined without DUK_USE_MARK_AND_SWEEP -#endif - -/* - * Low memory feature consistency - */ - -#if defined(DUK_USE_OBJSIZES16) -#if defined(DUK_USE_HOBJECT_HASH_PART) -#error DUK_USE_OBJSIZES16 assumes DUK_USE_HOBJECT_HASH_PART is not defined -#endif -#endif - -#if defined(DUK_USE_STRTAB_CHAIN) && defined(DUK_USE_STRTAB_PROBE) -#error both DUK_USE_STRTAB_CHAIN and DUK_USE_STRTAB_PROBE defined -#endif -#if !defined(DUK_USE_STRTAB_CHAIN) && !defined(DUK_USE_STRTAB_PROBE) -#error neither DUK_USE_STRTAB_CHAIN nor DUK_USE_STRTAB_PROBE is defined -#endif - -#endif /* DUK_FEATURES_SANITY_H_INCLUDED */ - /* * Union to access IEEE double memory representation, indexes for double * memory representation, and some macros for double manipulation. @@ -4156,13 +1232,14 @@ DUK_EXTERNAL_DECL void duk_debugger_cooperate(duk_context *ctx); union duk_double_union { double d; -#ifdef DUK_USE_64BIT_OPS + float f[2]; +#if defined(DUK_USE_64BIT_OPS) duk_uint64_t ull[1]; #endif duk_uint32_t ui[2]; duk_uint16_t us[4]; duk_uint8_t uc[8]; -#ifdef DUK_USE_PACKED_TVAL_POSSIBLE +#if defined(DUK_USE_PACKED_TVAL) void *vp[2]; /* used by packed duk_tval, assumes sizeof(void *) == 4 */ #endif }; @@ -4301,7 +1378,7 @@ typedef union duk_double_union duk_double_union; * * When packed duk_tval is used, the NaN space is used to store pointers * and other tagged values in addition to NaNs. Actual NaNs are normalized - * to a specific format. The macros below are used by the implementation + * to a specific quiet NaN. The macros below are used by the implementation * to check and normalize NaN values when they might be created. The macros * are essentially NOPs when the non-packed duk_tval representation is used. * @@ -4309,7 +1386,8 @@ typedef union duk_double_union duk_double_union; * the packed duk_tval and works correctly for all NaNs except those that * begin with 0x7ff0. Since the 'normalized NaN' values used with packed * duk_tval begin with 0x7ff8, the partial check is reliable when packed - * duk_tval is used. + * duk_tval is used. The 0x7ff8 prefix means the normalized NaN will be a + * quiet NaN regardless of its remaining lower bits. * * The ME variant below is specifically for ARM byte order, which has the * feature that while doubles have a mixed byte order (32107654), unsigned @@ -4427,9 +1505,24 @@ typedef union duk_double_union duk_double_union; } while (0) #endif /* DUK_USE_PACKED_TVAL */ -/* Byteswap an (aligned) duk_double_union. */ +/* XXX: native 64-bit byteswaps when available */ + +/* 64-bit byteswap, same operation independent of target endianness. */ +#define DUK_DBLUNION_BSWAP64(u) do { \ + duk_uint32_t duk__bswaptmp1, duk__bswaptmp2; \ + duk__bswaptmp1 = (u)->ui[0]; \ + duk__bswaptmp2 = (u)->ui[1]; \ + duk__bswaptmp1 = DUK_BSWAP32(duk__bswaptmp1); \ + duk__bswaptmp2 = DUK_BSWAP32(duk__bswaptmp2); \ + (u)->ui[0] = duk__bswaptmp2; \ + (u)->ui[1] = duk__bswaptmp1; \ + } while (0) + +/* Byteswap an IEEE double in the duk_double_union from host to network + * order. For a big endian target this is a no-op. + */ #if defined(DUK_USE_DOUBLE_LE) -#define DUK_DBLUNION_BSWAP(u) do { \ +#define DUK_DBLUNION_DOUBLE_HTON(u) do { \ duk_uint32_t duk__bswaptmp1, duk__bswaptmp2; \ duk__bswaptmp1 = (u)->ui[0]; \ duk__bswaptmp2 = (u)->ui[1]; \ @@ -4439,7 +1532,7 @@ typedef union duk_double_union duk_double_union; (u)->ui[1] = duk__bswaptmp1; \ } while (0) #elif defined(DUK_USE_DOUBLE_ME) -#define DUK_DBLUNION_BSWAP(u) do { \ +#define DUK_DBLUNION_DOUBLE_HTON(u) do { \ duk_uint32_t duk__bswaptmp1, duk__bswaptmp2; \ duk__bswaptmp1 = (u)->ui[0]; \ duk__bswaptmp2 = (u)->ui[1]; \ @@ -4449,11 +1542,14 @@ typedef union duk_double_union duk_double_union; (u)->ui[1] = duk__bswaptmp2; \ } while (0) #elif defined(DUK_USE_DOUBLE_BE) -#define DUK_DBLUNION_BSWAP(u) do { } while (0) +#define DUK_DBLUNION_DOUBLE_HTON(u) do { } while (0) #else #error internal error, double endianness insane #endif +/* Reverse operation is the same. */ +#define DUK_DBLUNION_DOUBLE_NTOH(u) DUK_DBLUNION_DOUBLE_HTON((u)) + #endif /* DUK_DBLUNION_H_INCLUDED */ #endif /* DUKTAPE_H_INCLUDED */