Mercurial > malikania
view extern/duktape/duk_config.h @ 182:3107ce017c3a
Misc: switch back to SDL
Qt Quick and QML was an exciting experiment but it's definitely not enough
flexible and easy to use for game development.
Using SDL2 will let us focusing on our own drawing functions without any kind of
overhead.
While here, start massive cleanup.
| author | David Demelier <markand@malikania.fr> |
|---|---|
| date | Fri, 19 Oct 2018 20:18:19 +0200 |
| parents | |
| children |
line wrap: on
line source
/* * duk_config.h configuration header generated by genconfig.py. * * Git commit: 1f1f51a4f9595ffe8def0e9ba45b20f14679393a * Git describe: v2.1.0 * Git branch: master * * Supported platforms: * - Mac OSX, iPhone, Darwin * - Orbis * - OpenBSD * - Generic BSD * - Atari ST TOS * - AmigaOS * - Durango (XboxOne) * - Windows * - Flashplayer (Crossbridge) * - QNX * - TI-Nspire * - Emscripten * - Linux * - Solaris * - AIX * - HPUX * - 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 */ /* not configured for DLL build */ #undef DUK_F_DLL_BUILD /* Apple OSX, iOS */ #if defined(__APPLE__) #define DUK_F_APPLE #endif /* FreeBSD */ #if defined(__FreeBSD__) || defined(__FreeBSD) #define DUK_F_FREEBSD #endif /* Orbis (PS4) variant */ #if defined(DUK_F_FREEBSD) && defined(__ORBIS__) #define DUK_F_ORBIS #endif /* OpenBSD */ #if defined(__OpenBSD__) || defined(__OpenBSD) #define DUK_F_OPENBSD #endif /* NetBSD */ #if defined(__NetBSD__) || defined(__NetBSD) #define DUK_F_NETBSD #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 /* Durango (Xbox One) */ #if defined(_DURANGO) || defined(_XBOX_ONE) #define DUK_F_DURANGO #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 #if defined(__SUNPRO_C) && (__SUNPRO_C < 0x550) #define DUK_F_OLD_SOLARIS /* Defines _ILP32 / _LP64 required by DUK_F_X86/DUK_F_X64. Platforms * are processed before architectures, so this happens before the * DUK_F_X86/DUK_F_X64 detection is emitted. */ #include <sys/isa_defs.h> #endif #endif /* AIX */ #if defined(_AIX) /* defined(__xlc__) || defined(__IBMC__): works but too wide */ #define DUK_F_AIX #endif /* HPUX */ #if defined(__hpux) #define DUK_F_HPUX #if defined(__ia64) #define DUK_F_HPUX_ITANIUM #endif #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 /* 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/ * * With DUK_F_OLD_SOLARIS the <sys/isa_defs.h> header must be included * before this. */ #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) || defined(__aarch64__) #define DUK_F_ARM #if defined(__LP64__) || defined(_LP64) || defined(__arm64) || defined(__arm64__) || defined(__aarch64__) #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 #if defined(ANDROID) || defined(__ANDROID__) #define DUK_F_ANDROID #endif /* Atari Mint */ #if defined(__MINT__) #define DUK_F_MINT #endif /* * Platform autodetection */ /* Workaround for older C++ compilers before including <inttypes.h>, * 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 <TargetConditionals.h> #include <architecture/byte_order.h> #include <sys/param.h> #include <sys/time.h> #include <time.h> /* 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 "osx" #else #define DUK_USE_OS_STRING "osx-unknown" #endif /* Use _setjmp() on Apple by default, see GH-55. */ #define DUK_JMPBUF_TYPE jmp_buf #define DUK_SETJMP(jb) _setjmp((jb)) #define DUK_LONGJMP(jb) _longjmp((jb), 1) #elif defined(DUK_F_ORBIS) /* --- Orbis --- */ /* Orbis = PS4 */ #define DUK_USE_DATE_NOW_GETTIMEOFDAY #define DUK_USE_DATE_TZO_GMTIME_S /* no parsing (not an error) */ #define DUK_USE_DATE_FMT_STRFTIME #include <sys/types.h> #include <machine/endian.h> #include <sys/param.h> #include <sys/time.h> #include <time.h> #define DUK_USE_OS_STRING "orbis" #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 <sys/types.h> #include <sys/endian.h> #include <sys/param.h> #include <sys/time.h> #include <time.h> #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 <sys/types.h> #include <sys/endian.h> #include <sys/param.h> #include <sys/time.h> #include <time.h> #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 <time.h> #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 <time.h> #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 <time.h> #if !defined(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_DURANGO) /* --- Durango (XboxOne) --- */ /* Durango = XboxOne * Configuration is nearly identical to Windows, except for * DUK_USE_DATE_TZO_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 /* MSVC does not have sys/param.h */ #define DUK_USE_DATE_NOW_WINDOWS #define DUK_USE_DATE_TZO_WINDOWS_NO_DST /* 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 <windows.h> #endif #define DUK_USE_OS_STRING "durango" #if !defined(DUK_USE_BYTEORDER) #define DUK_USE_BYTEORDER 1 #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 <windows.h> #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 <endian.h> #include <sys/param.h> #include <sys/time.h> #include <time.h> #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 <sys/types.h> #include <sys/param.h> #include <sys/time.h> #include <time.h> #define DUK_USE_OS_STRING "qnx" #elif defined(DUK_F_TINSPIRE) /* --- TI-Nspire --- */ #if defined(DUK_COMPILING_DUKTAPE) && !defined(_XOPEN_SOURCE) #define _XOPEN_SOURCE /* e.g. strptime */ #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 <sys/types.h> #include <sys/param.h> #include <sys/time.h> #include <time.h> #define DUK_USE_OS_STRING "tinspire" #elif defined(DUK_F_EMSCRIPTEN) /* --- Emscripten --- */ #if defined(DUK_COMPILING_DUKTAPE) #if !defined(_POSIX_C_SOURCE) #define _POSIX_C_SOURCE 200809L #endif #if !defined(_GNU_SOURCE) #define _GNU_SOURCE /* e.g. getdate_r */ #endif #if !defined(_XOPEN_SOURCE) #define _XOPEN_SOURCE /* e.g. strptime */ #endif #endif /* DUK_COMPILING_DUKTAPE */ #include <sys/types.h> #if defined(DUK_F_BCC) /* no endian.h */ #else #include <endian.h> #endif /* DUK_F_BCC */ #include <sys/param.h> #include <sys/time.h> #include <time.h> #include <stdint.h> #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) #if !defined(_POSIX_C_SOURCE) #define _POSIX_C_SOURCE 200809L #endif #if !defined(_GNU_SOURCE) #define _GNU_SOURCE /* e.g. getdate_r */ #endif #if !defined(_XOPEN_SOURCE) #define _XOPEN_SOURCE /* e.g. strptime */ #endif #endif /* DUK_COMPILING_DUKTAPE */ #include <sys/types.h> #if defined(DUK_F_BCC) /* no endian.h or stdint.h */ #else #include <endian.h> #include <stdint.h> #endif /* DUK_F_BCC */ #include <sys/param.h> #include <sys/time.h> #include <time.h> #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 <sys/types.h> #if defined(DUK_F_OLD_SOLARIS) /* Old Solaris with no endian.h, stdint.h */ #define DUK_F_NO_STDINT_H #if !defined(DUK_USE_BYTEORDER) #define DUK_USE_BYTEORDER 3 #endif #else /* DUK_F_OLD_SOLARIS */ #include <ast/endian.h> #endif /* DUK_F_OLD_SOLARIS */ #include <sys/param.h> #include <sys/time.h> #include <time.h> #define DUK_USE_OS_STRING "solaris" #elif defined(DUK_F_AIX) /* --- AIX --- */ #if !defined(DUK_USE_BYTEORDER) #define DUK_USE_BYTEORDER 3 #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 <sys/param.h> #include <sys/time.h> #include <time.h> #define DUK_USE_OS_STRING "aix" #elif defined(DUK_F_HPUX) /* --- HPUX --- */ #define DUK_F_NO_STDINT_H #if !defined(DUK_USE_BYTEORDER) #define DUK_USE_BYTEORDER 3 #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 <sys/param.h> #include <sys/time.h> #include <time.h> #define DUK_USE_OS_STRING "hpux" #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 <sys/types.h> #include <endian.h> #include <sys/param.h> #include <sys/time.h> #include <time.h> #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 <sys/types.h> #include <endian.h> #include <sys/param.h> #include <sys/time.h> #include <time.h> #define DUK_JMPBUF_TYPE jmp_buf #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 <time.h> #include <sys/time.h> #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 <time.h> #define DUK_USE_OS_STRING "unknown" #endif /* autodetect platform */ /* Shared includes: C89 */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdarg.h> /* varargs */ #include <setjmp.h> #include <stddef.h> /* e.g. ptrdiff_t */ #include <math.h> #include <limits.h> /* 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 <stdint.h> #endif #if defined(DUK_F_CPP) #include <exception> /* 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. */ #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_MIPS64) /* --- MIPS 64-bit --- */ #define DUK_USE_ARCH_STRING "mips64" /* MIPS 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_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(__clang__) && defined(__has_builtin) #if __has_builtin(__builtin_unpredictable) #define DUK_UNPREDICTABLE(x) __builtin_unpredictable((x)) #endif #endif #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 /* DUK_HOT */ /* DUK_COLD */ #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) #if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG) /* Minimize warnings for unused internal functions with GCC >= 3.1.1 and * Clang. Based on documentation it should suffice to have the attribute * in the declaration only, but in practice some warnings are generated unless * the attribute is also applied to the definition. */ #define DUK_INTERNAL_DECL static __attribute__ ((unused)) #define DUK_INTERNAL static __attribute__ ((unused)) #else #define DUK_INTERNAL_DECL static #define DUK_INTERNAL static #endif #else #if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG) #define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) extern #define DUK_INTERNAL __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) #else #define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) extern #define DUK_INTERNAL __attribute__ ((visibility("hidden"))) #endif #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 #define DUK_USE_UNION_INITIALIZERS #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 #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 /* XXX: equivalent of clang __builtin_unpredictable? */ #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_C99) || defined(DUK_F_CPP11)) && \ defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40300) #define DUK_HOT __attribute__((hot)) #define DUK_COLD __attribute__((cold)) #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) #if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG) /* Minimize warnings for unused internal functions with GCC >= 3.1.1 and * Clang. Based on documentation it should suffice to have the attribute * in the declaration only, but in practice some warnings are generated unless * the attribute is also applied to the definition. */ #define DUK_INTERNAL_DECL static __attribute__ ((unused)) #define DUK_INTERNAL static __attribute__ ((unused)) #else #define DUK_INTERNAL_DECL static #define DUK_INTERNAL static #endif #else #if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG) #define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) extern #define DUK_INTERNAL __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) #else #define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) extern #define DUK_INTERNAL __attribute__ ((visibility("hidden"))) #endif #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 #define DUK_USE_UNION_INITIALIZERS #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 #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_UNION_INITIALIZERS #if defined(_MSC_VER) && (_MSC_VER >= 1800) /* VS2013+ supports union initializers but there's a bug involving union-inside-struct: * https://connect.microsoft.com/VisualStudio/feedback/details/805981 * The bug was fixed (at least) in VS2015 so check for VS2015 for now: * https://blogs.msdn.microsoft.com/vcblog/2015/07/01/c-compiler-front-end-fixes-in-vs2015/ * Manually tested using VS2013, CL reports 18.00.31101, so enable for VS2013 too. */ #define DUK_USE_UNION_INITIALIZERS #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 /* These have been tested from VS2008 onwards; may work in older VS versions * too but not enabled by default. */ #if defined(_MSC_VER) && (_MSC_VER >= 1500) #define DUK_NOINLINE __declspec(noinline) #define DUK_INLINE __inline #define DUK_ALWAYS_INLINE __forceinline #endif #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 /* Avoid warning when doing DUK_UNREF(some_function). */ #define DUK_UNREF(x) do { __pragma(warning(suppress:4100 4101 4550 4551)) (x); } while (0) #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(__clang__) && defined(__has_builtin) #if __has_builtin(__builtin_unpredictable) #define DUK_UNPREDICTABLE(x) __builtin_unpredictable((x)) #endif #endif #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) #if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG) /* Minimize warnings for unused internal functions with GCC >= 3.1.1 and * Clang. Based on documentation it should suffice to have the attribute * in the declaration only, but in practice some warnings are generated unless * the attribute is also applied to the definition. */ #define DUK_INTERNAL_DECL static __attribute__ ((unused)) #define DUK_INTERNAL static __attribute__ ((unused)) #else #define DUK_INTERNAL_DECL static #define DUK_INTERNAL static #endif #else #if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG) #define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) extern #define DUK_INTERNAL __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) #else #define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) extern #define DUK_INTERNAL __attribute__ ((visibility("hidden"))) #endif #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 #define DUK_USE_UNION_INITIALIZERS #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 #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 #define DUK_USE_UNION_INITIALIZERS /* Most portable, wastes space */ #define DUK_USE_FLEX_ONESIZE /* Most portable, potentially wastes space */ #define DUK_USE_PACK_DUMMY_MEMBER #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 /* VBCC supports C99 so check only for C99 for union initializer support. * Designated union initializers would possibly work even without a C99 check. */ #undef DUK_USE_UNION_INITIALIZERS #if defined(DUK_F_C99) #define DUK_USE_UNION_INITIALIZERS #endif #define DUK_USE_FLEX_ZEROSIZE #define DUK_USE_PACK_DUMMY_MEMBER #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 /* Most portable */ #undef DUK_USE_VARIADIC_MACROS /* Most portable, wastes space */ #undef DUK_USE_UNION_INITIALIZERS /* 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 #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 /* C++ doesn't have standard designated union initializers ({ .foo = 1 }). */ #undef DUK_USE_UNION_INITIALIZERS #if defined(DUK_F_C99) #define DUK_USE_UNION_INITIALIZERS #endif /* Most portable, wastes space */ #define DUK_USE_FLEX_ONESIZE /* Most portable, potentially wastes space */ #define DUK_USE_PACK_DUMMY_MEMBER #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)) || \ ((defined(DUK_F_OLD_SOLARIS) || defined(DUK_F_AIX) || \ defined(DUK_F_HPUX)) && defined(_ILP32)) #define DUK_F_32BIT_PTRS #elif defined(DUK_F_X64) || \ (defined(__WORDSIZE) && (__WORDSIZE == 64)) || \ ((defined(DUK_F_OLD_SOLARIS) || defined(DUK_F_AIX) || \ defined(DUK_F_HPUX)) && defined(_LP64)) #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 <inttypes.h> 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 */ /* An abort()-like primitive is needed by the default fatal error handler. */ #if !defined(DUK_ABORT) #define DUK_ABORT abort #endif #if !defined(DUK_SETJMP) #define DUK_JMPBUF_TYPE jmp_buf #define DUK_SETJMP(jb) setjmp((jb)) #define DUK_LONGJMP(jb) longjmp((jb), 1) #endif #if 0 /* sigsetjmp() alternative */ #define DUK_JMPBUF_TYPE sigjmp_buf #define DUK_SETJMP(jb) sigsetjmp((jb)) #define DUK_LONGJMP(jb) siglongjmp((jb), 1) #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_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_MEMZERO) #define DUK_MEMZERO(p,n) DUK_MEMSET((p), 0, (n)) #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) && \ !defined(DUK_F_OLD_SOLARIS) && !defined(DUK_F_AIX) #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) && \ !defined(DUK_F_OLD_SOLARIS) && !defined(DUK_F_AIX) #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_AMIGAOS) && defined(DUK_F_M68K) /* AmigaOS + M68K seems to have math issues even when using GCC cross * compilation. Use replacements for all AmigaOS versions on M68K * regardless of compiler. */ #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 #elif defined(DUK_F_AIX) /* Older versions may be missing isnan(), etc. */ #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 /* 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_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 /* The functions below exist only in C99/C++11 or later and need a workaround * for platforms that don't include them. MSVC isn't detected as C99, but * these functions also exist in MSVC 2013 and later so include a clause for * that too. Android doesn't have log2; disable all of these for Android. */ #if (defined(DUK_F_C99) || defined(DUK_F_CPP11) || (defined(_MSC_VER) && (_MSC_VER >= 1800))) && \ !defined(DUK_F_ANDROID) && !defined(DUK_F_MINT) #if !defined(DUK_CBRT) #define DUK_CBRT cbrt #endif #if !defined(DUK_LOG2) #define DUK_LOG2 log2 #endif #if !defined(DUK_LOG10) #define DUK_LOG10 log10 #endif #if !defined(DUK_TRUNC) #define DUK_TRUNC trunc #endif #endif /* DUK_F_C99 etc */ /* NetBSD 6.0 x86 (at least) has a few problems with pow() semantics, * see test-bug-netbsd-math-pow.js. MinGW has similar (but different) * issues, see test-bug-mingw-math-issues.js. Enable pow() workarounds * for these targets. */ #undef DUK_USE_POW_WORKAROUNDS #if defined(DUK_F_NETBSD) || defined(DUK_F_MINGW) #define DUK_USE_POW_WORKAROUNDS #endif /* Similar workarounds for atan2() semantics issues. MinGW issues are * documented in test-bug-mingw-math-issues.js. */ #undef DUK_USE_ATAN2_WORKAROUNDS #if defined(DUK_F_MINGW) #define DUK_USE_ATAN2_WORKAROUNDS #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". */ /* 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 - </dev/null | grep -ni endian * 67:#define __LITTLEENDIAN__ 1 * $ /opt/qnx650/host/linux/x86/usr/bin/mips-unknown-nto-qnx6.5.0-gcc -dM -E - </dev/null | grep -ni endian * 81:#define __BIGENDIAN__ 1 * $ /opt/qnx650/host/linux/x86/usr/bin/arm-unknown-nto-qnx6.5.0-gcc -dM -E - </dev/null | grep -ni endian * 70:#define __LITTLEENDIAN__ 1 */ #if !defined(DUK_USE_BYTEORDER) #if defined(__LITTLEENDIAN__) #define DUK_USE_BYTEORDER 1 #elif defined(__BIGENDIAN__) #define DUK_USE_BYTEORDER 3 #endif #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. */ /* If not provided, use safe default for alignment. */ #if !defined(DUK_USE_ALIGN_BY) #define DUK_USE_ALIGN_BY 8 #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_USE_PACK_MSVC_PRAGMA) || defined(DUK_USE_PACK_GCC_ATTR) || \ defined(DUK_USE_PACK_CLANG_ATTR) || defined(DUK_USE_PACK_DUMMY_MEMBER)) #define DUK_USE_PACK_DUMMY_MEMBER #endif #if !defined(DUK_VA_COPY) /* 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) #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 #endif #if !defined(DUK_MACRO_STRINGIFY) /* 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_MACRO_STRINGIFY_HELPER(x) #x #define DUK_MACRO_STRINGIFY(x) DUK_MACRO_STRINGIFY_HELPER(x) #endif #if !defined(DUK_CAUSE_SEGFAULT) /* This can be used for testing; valgrind will then indicate the C call stack * leading to the call site. */ #define DUK_CAUSE_SEGFAULT() do { *((volatile duk_uint32_t *) NULL) = (duk_uint32_t) 0xdeadbeefUL; } while (0) #endif #if !defined(DUK_UNREF) /* 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. May cause warnings * for volatile arguments. */ #define DUK_UNREF(x) do { (void) (x); } while (0) #endif #if !defined(DUK_NORETURN) #define DUK_NORETURN(decl) decl #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() do { } while (0) #endif #if !defined(DUK_LOSE_CONST) /* Convert any input pointer into a "void *", losing a const qualifier. * This is not fully portable because casting through duk_uintptr_t may * not work on all architectures (e.g. those with long, segmented pointers). */ #define DUK_LOSE_CONST(src) ((void *) (duk_uintptr_t) (src)) #endif #if !defined(DUK_LIKELY) #define DUK_LIKELY(x) (x) #endif #if !defined(DUK_UNLIKELY) #define DUK_UNLIKELY(x) (x) #endif #if !defined(DUK_UNPREDICTABLE) #define DUK_UNPREDICTABLE(x) (x) #endif #if !defined(DUK_NOINLINE) #define DUK_NOINLINE /*nop*/ #endif #if !defined(DUK_INLINE) #define DUK_INLINE /*nop*/ #endif #if !defined(DUK_ALWAYS_INLINE) #define DUK_ALWAYS_INLINE /*nop*/ #endif #if !defined(DUK_HOT) #define DUK_HOT /*nop*/ #endif #if !defined(DUK_COLD) #define DUK_COLD /*nop*/ #endif #if !defined(DUK_EXTERNAL_DECL) #define DUK_EXTERNAL_DECL extern #endif #if !defined(DUK_EXTERNAL) #define DUK_EXTERNAL /*empty*/ #endif #if !defined(DUK_INTERNAL_DECL) #if defined(DUK_SINGLE_FILE) #define DUK_INTERNAL_DECL static #else #define DUK_INTERNAL_DECL extern #endif #endif #if !defined(DUK_INTERNAL) #if defined(DUK_SINGLE_FILE) #define DUK_INTERNAL static #else #define DUK_INTERNAL /*empty*/ #endif #endif #if !defined(DUK_LOCAL_DECL) #define DUK_LOCAL_DECL static #endif #if !defined(DUK_LOCAL) #define DUK_LOCAL static #endif #if !defined(DUK_FILE_MACRO) #define DUK_FILE_MACRO __FILE__ #endif #if !defined(DUK_LINE_MACRO) #define DUK_LINE_MACRO __LINE__ #endif #if !defined(DUK_FUNC_MACRO) #if defined(DUK_F_C99) || defined(DUK_F_CPP11) #define DUK_FUNC_MACRO __func__ #elif defined(__FUNCTION__) #define DUK_FUNC_MACRO __FUNCTION__ #else #define DUK_FUNC_MACRO "unknown" #endif #endif #if !defined(DUK_BSWAP32) #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)) #endif #if !defined(DUK_BSWAP16) #define DUK_BSWAP16(x) \ ((duk_uint16_t) (x) >> 8) | \ ((duk_uint16_t) (x) << 8) #endif /* DUK_USE_VARIADIC_MACROS: required from compilers, so no fill-in. */ /* DUK_USE_UNION_INITIALIZERS: required from compilers, so no fill-in. */ #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 */ /* 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 /* * Autogenerated defaults */ #define DUK_USE_ARRAY_BUILTIN #define DUK_USE_ARRAY_FASTPATH #define DUK_USE_ARRAY_PROP_FASTPATH #undef DUK_USE_ASSERTIONS #define DUK_USE_AUGMENT_ERROR_CREATE #define DUK_USE_AUGMENT_ERROR_THROW #define DUK_USE_AVOID_PLATFORM_FUNCPTRS #define DUK_USE_BASE64_FASTPATH #define DUK_USE_BOOLEAN_BUILTIN #define DUK_USE_BUFFEROBJECT_SUPPORT #undef DUK_USE_BUFLEN16 #define DUK_USE_BYTECODE_DUMP_SUPPORT #define DUK_USE_COMMONJS_MODULES #define DUK_USE_COMPILER_RECLIMIT 2500 #define DUK_USE_COROUTINE_SUPPORT #undef DUK_USE_CPP_EXCEPTIONS #undef DUK_USE_DATAPTR16 #undef DUK_USE_DATAPTR_DEC16 #undef DUK_USE_DATAPTR_ENC16 #define DUK_USE_DATE_BUILTIN #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 #undef DUK_USE_DEBUG #undef DUK_USE_DEBUGGER_DUMPHEAP #undef DUK_USE_DEBUGGER_INSPECT #undef DUK_USE_DEBUGGER_PAUSE_UNCAUGHT #undef DUK_USE_DEBUGGER_SUPPORT #define DUK_USE_DEBUGGER_THROW_NOTIFY #undef DUK_USE_DEBUGGER_TRANSPORT_TORTURE #define DUK_USE_DEBUG_BUFSIZE 65536L #define DUK_USE_DEBUG_LEVEL 0 #undef DUK_USE_DEBUG_WRITE #define DUK_USE_DOUBLE_LINKED_HEAP #define DUK_USE_DUKTAPE_BUILTIN #define DUK_USE_ENCODING_BUILTINS #define DUK_USE_ERRCREATE #define DUK_USE_ERRTHROW #define DUK_USE_ES6 #define DUK_USE_ES6_OBJECT_PROTO_PROPERTY #define DUK_USE_ES6_OBJECT_SETPROTOTYPEOF #define DUK_USE_ES6_PROXY #define DUK_USE_ES6_REGEXP_SYNTAX #define DUK_USE_ES6_UNICODE_ESCAPE #define DUK_USE_ES7_EXP_OPERATOR #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_EXEC_INDIRECT_BOUND_CHECK #undef DUK_USE_EXEC_PREFER_SIZE #define DUK_USE_EXEC_REGCONST_OPTIMIZE #undef DUK_USE_EXEC_TIMEOUT_CHECK #undef DUK_USE_EXPLICIT_NULL_INIT #undef DUK_USE_EXTSTR_FREE #undef DUK_USE_EXTSTR_INTERN_CHECK #undef DUK_USE_FASTINT #define DUK_USE_FAST_REFCOUNT_DEFAULT #undef DUK_USE_FATAL_HANDLER #define DUK_USE_FINALIZER_SUPPORT #undef DUK_USE_FINALIZER_TORTURE #undef DUK_USE_FUNCPTR16 #undef DUK_USE_FUNCPTR_DEC16 #undef DUK_USE_FUNCPTR_ENC16 #define DUK_USE_FUNCTION_BUILTIN #define DUK_USE_FUNC_FILENAME_PROPERTY #define DUK_USE_FUNC_NAME_PROPERTY #undef DUK_USE_GC_TORTURE #undef DUK_USE_GET_RANDOM_DOUBLE #undef DUK_USE_GLOBAL_BINDING #define DUK_USE_GLOBAL_BUILTIN #undef DUK_USE_HEAPPTR16 #undef DUK_USE_HEAPPTR_DEC16 #undef DUK_USE_HEAPPTR_ENC16 #define DUK_USE_HEX_FASTPATH #define DUK_USE_HOBJECT_ARRAY_ABANDON_LIMIT 2 #define DUK_USE_HOBJECT_ARRAY_FAST_RESIZE_LIMIT 9 #define DUK_USE_HOBJECT_ARRAY_MINGROW_ADD 16 #define DUK_USE_HOBJECT_ARRAY_MINGROW_DIVISOR 8 #define DUK_USE_HOBJECT_ENTRY_MINGROW_ADD 16 #define DUK_USE_HOBJECT_ENTRY_MINGROW_DIVISOR 8 #define DUK_USE_HOBJECT_HASH_PART #define DUK_USE_HOBJECT_HASH_PROP_LIMIT 8 #define DUK_USE_HSTRING_ARRIDX #define DUK_USE_HSTRING_CLEN #undef DUK_USE_HSTRING_EXTDATA #define DUK_USE_HTML_COMMENTS #define DUK_USE_IDCHAR_FASTPATH #undef DUK_USE_INJECT_HEAP_ALLOC_ERROR #undef DUK_USE_INTERRUPT_COUNTER #undef DUK_USE_INTERRUPT_DEBUG_FIXUP #define DUK_USE_JC #define DUK_USE_JSON_BUILTIN #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 #undef DUK_USE_JSON_STRINGIFY_FASTPATH #define DUK_USE_JSON_SUPPORT #define DUK_USE_JX #define DUK_USE_LEXER_SLIDING_WINDOW #undef DUK_USE_LIGHTFUNC_BUILTINS #define DUK_USE_MARK_AND_SWEEP_RECLIMIT 256 #define DUK_USE_MATH_BUILTIN #define DUK_USE_NATIVE_CALL_RECLIMIT 1000 #define DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER #define DUK_USE_NONSTD_ARRAY_MAP_TRAILER #define DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT #undef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY #undef DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY #define DUK_USE_NONSTD_FUNC_STMT #define DUK_USE_NONSTD_GETTER_KEY_ARGUMENT #define DUK_USE_NONSTD_JSON_ESC_U2028_U2029 #define DUK_USE_NONSTD_SETTER_KEY_ARGUMENT #define DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT #define DUK_USE_NUMBER_BUILTIN #define DUK_USE_OBJECT_BUILTIN #undef DUK_USE_OBJSIZES16 #undef DUK_USE_PARANOID_ERRORS #define DUK_USE_PC2LINE #undef DUK_USE_PREFER_SIZE #define DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS #undef DUK_USE_REFCOUNT16 #define DUK_USE_REFCOUNT32 #define DUK_USE_REFERENCE_COUNTING #define DUK_USE_REFLECT_BUILTIN #undef DUK_USE_REGEXP_CANON_WORKAROUND #define DUK_USE_REGEXP_COMPILER_RECLIMIT 10000 #define DUK_USE_REGEXP_EXECUTOR_RECLIMIT 10000 #define DUK_USE_REGEXP_SUPPORT #undef DUK_USE_ROM_GLOBAL_CLONE #undef DUK_USE_ROM_GLOBAL_INHERIT #undef DUK_USE_ROM_OBJECTS #define DUK_USE_ROM_PTRCOMP_FIRST 63488L #undef DUK_USE_ROM_STRINGS #define DUK_USE_SECTION_B #undef DUK_USE_SELF_TESTS #define DUK_USE_SHEBANG_COMMENTS #undef DUK_USE_SHUFFLE_TORTURE #define DUK_USE_SOURCE_NONBMP #undef DUK_USE_STRHASH16 #undef DUK_USE_STRHASH_DENSE #define DUK_USE_STRHASH_SKIP_SHIFT 5 #define DUK_USE_STRICT_DECL #undef DUK_USE_STRICT_UTF8_SOURCE #define DUK_USE_STRING_BUILTIN #undef DUK_USE_STRLEN16 #define DUK_USE_STRTAB_GROW_LIMIT 17 #define DUK_USE_STRTAB_MAXSIZE 268435456L #define DUK_USE_STRTAB_MINSIZE 1024 #undef DUK_USE_STRTAB_PTRCOMP #define DUK_USE_STRTAB_RESIZE_CHECK_MASK 255 #define DUK_USE_STRTAB_SHRINK_LIMIT 6 #undef DUK_USE_STRTAB_TORTURE #undef DUK_USE_SYMBOL_BUILTIN #define DUK_USE_TAILCALL #define DUK_USE_TARGET_INFO "unknown" #define DUK_USE_TRACEBACKS #define DUK_USE_TRACEBACK_DEPTH 10 #define DUK_USE_USER_DECLARE() /* no user declarations */ #undef DUK_USE_VALSTACK_UNSAFE #define DUK_USE_VERBOSE_ERRORS #define DUK_USE_VERBOSE_EXECUTOR_ERRORS #define DUK_USE_VOLUNTARY_GC #define DUK_USE_ZERO_BUFFER_DATA /* * 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_S) || 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)) #elif defined(DUK_USE_DATE_TZO_WINDOWS_NO_DST) #define DUK_USE_DATE_GET_LOCAL_TZOFFSET(d) duk_bi_date_get_local_tzoffset_windows_no_dst((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 legacy feature options (DUK_OPT_xxx) */ #if defined(DUK_OPT_ASSERTIONS) #error unsupported legacy feature option DUK_OPT_ASSERTIONS used #endif #if defined(DUK_OPT_BUFFEROBJECT_SUPPORT) #error unsupported legacy feature option DUK_OPT_BUFFEROBJECT_SUPPORT used #endif #if defined(DUK_OPT_BUFLEN16) #error unsupported legacy feature option DUK_OPT_BUFLEN16 used #endif #if defined(DUK_OPT_DATAPTR16) #error unsupported legacy feature option DUK_OPT_DATAPTR16 used #endif #if defined(DUK_OPT_DATAPTR_DEC16) #error unsupported legacy feature option DUK_OPT_DATAPTR_DEC16 used #endif #if defined(DUK_OPT_DATAPTR_ENC16) #error unsupported legacy feature option DUK_OPT_DATAPTR_ENC16 used #endif #if defined(DUK_OPT_DDDPRINT) #error unsupported legacy feature option DUK_OPT_DDDPRINT used #endif #if defined(DUK_OPT_DDPRINT) #error unsupported legacy feature option DUK_OPT_DDPRINT used #endif #if defined(DUK_OPT_DEBUG) #error unsupported legacy feature option DUK_OPT_DEBUG used #endif #if defined(DUK_OPT_DEBUGGER_DUMPHEAP) #error unsupported legacy feature option DUK_OPT_DEBUGGER_DUMPHEAP used #endif #if defined(DUK_OPT_DEBUGGER_FWD_LOGGING) #error unsupported legacy feature option DUK_OPT_DEBUGGER_FWD_LOGGING used #endif #if defined(DUK_OPT_DEBUGGER_FWD_PRINTALERT) #error unsupported legacy feature option DUK_OPT_DEBUGGER_FWD_PRINTALERT used #endif #if defined(DUK_OPT_DEBUGGER_SUPPORT) #error unsupported legacy feature option DUK_OPT_DEBUGGER_SUPPORT used #endif #if defined(DUK_OPT_DEBUGGER_TRANSPORT_TORTURE) #error unsupported legacy feature option DUK_OPT_DEBUGGER_TRANSPORT_TORTURE used #endif #if defined(DUK_OPT_DEBUG_BUFSIZE) #error unsupported legacy feature option DUK_OPT_DEBUG_BUFSIZE used #endif #if defined(DUK_OPT_DECLARE) #error unsupported legacy feature option DUK_OPT_DECLARE used #endif #if defined(DUK_OPT_DEEP_C_STACK) #error unsupported legacy feature option DUK_OPT_DEEP_C_STACK used #endif #if defined(DUK_OPT_DLL_BUILD) #error unsupported legacy feature option DUK_OPT_DLL_BUILD used #endif #if defined(DUK_OPT_DPRINT) #error unsupported legacy feature option DUK_OPT_DPRINT used #endif #if defined(DUK_OPT_DPRINT_COLORS) #error unsupported legacy feature option DUK_OPT_DPRINT_COLORS used #endif #if defined(DUK_OPT_DPRINT_RDTSC) #error unsupported legacy feature option DUK_OPT_DPRINT_RDTSC used #endif #if defined(DUK_OPT_EXEC_TIMEOUT_CHECK) #error unsupported legacy feature option DUK_OPT_EXEC_TIMEOUT_CHECK used #endif #if defined(DUK_OPT_EXTERNAL_STRINGS) #error unsupported legacy feature option DUK_OPT_EXTERNAL_STRINGS used #endif #if defined(DUK_OPT_EXTSTR_FREE) #error unsupported legacy feature option DUK_OPT_EXTSTR_FREE used #endif #if defined(DUK_OPT_EXTSTR_INTERN_CHECK) #error unsupported legacy feature option DUK_OPT_EXTSTR_INTERN_CHECK used #endif #if defined(DUK_OPT_FASTINT) #error unsupported legacy feature option DUK_OPT_FASTINT used #endif #if defined(DUK_OPT_FORCE_ALIGN) #error unsupported legacy feature option DUK_OPT_FORCE_ALIGN used #endif #if defined(DUK_OPT_FORCE_BYTEORDER) #error unsupported legacy feature option DUK_OPT_FORCE_BYTEORDER used #endif #if defined(DUK_OPT_FUNCPTR16) #error unsupported legacy feature option DUK_OPT_FUNCPTR16 used #endif #if defined(DUK_OPT_FUNCPTR_DEC16) #error unsupported legacy feature option DUK_OPT_FUNCPTR_DEC16 used #endif #if defined(DUK_OPT_FUNCPTR_ENC16) #error unsupported legacy feature option DUK_OPT_FUNCPTR_ENC16 used #endif #if defined(DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY) #error unsupported legacy feature option DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY used #endif #if defined(DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY) #error unsupported legacy feature option DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY used #endif #if defined(DUK_OPT_GC_TORTURE) #error unsupported legacy feature option DUK_OPT_GC_TORTURE used #endif #if defined(DUK_OPT_HAVE_CUSTOM_H) #error unsupported legacy feature option DUK_OPT_HAVE_CUSTOM_H used #endif #if defined(DUK_OPT_HEAPPTR16) #error unsupported legacy feature option DUK_OPT_HEAPPTR16 used #endif #if defined(DUK_OPT_HEAPPTR_DEC16) #error unsupported legacy feature option DUK_OPT_HEAPPTR_DEC16 used #endif #if defined(DUK_OPT_HEAPPTR_ENC16) #error unsupported legacy feature option DUK_OPT_HEAPPTR_ENC16 used #endif #if defined(DUK_OPT_INTERRUPT_COUNTER) #error unsupported legacy feature option DUK_OPT_INTERRUPT_COUNTER used #endif #if defined(DUK_OPT_JSON_STRINGIFY_FASTPATH) #error unsupported legacy feature option DUK_OPT_JSON_STRINGIFY_FASTPATH used #endif #if defined(DUK_OPT_LIGHTFUNC_BUILTINS) #error unsupported legacy feature option DUK_OPT_LIGHTFUNC_BUILTINS used #endif #if defined(DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY) #error unsupported legacy feature option DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY used #endif #if defined(DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY) #error unsupported legacy feature option DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY used #endif #if defined(DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT) #error unsupported legacy feature option DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT used #endif #if defined(DUK_OPT_NO_AUGMENT_ERRORS) #error unsupported legacy feature option DUK_OPT_NO_AUGMENT_ERRORS used #endif #if defined(DUK_OPT_NO_BROWSER_LIKE) #error unsupported legacy feature option DUK_OPT_NO_BROWSER_LIKE used #endif #if defined(DUK_OPT_NO_BUFFEROBJECT_SUPPORT) #error unsupported legacy feature option DUK_OPT_NO_BUFFEROBJECT_SUPPORT used #endif #if defined(DUK_OPT_NO_BYTECODE_DUMP_SUPPORT) #error unsupported legacy feature option DUK_OPT_NO_BYTECODE_DUMP_SUPPORT used #endif #if defined(DUK_OPT_NO_COMMONJS_MODULES) #error unsupported legacy feature option DUK_OPT_NO_COMMONJS_MODULES used #endif #if defined(DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY) #error unsupported legacy feature option DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY used #endif #if defined(DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF) #error unsupported legacy feature option DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF used #endif #if defined(DUK_OPT_NO_ES6_PROXY) #error unsupported legacy feature option DUK_OPT_NO_ES6_PROXY used #endif #if defined(DUK_OPT_NO_FILE_IO) #error unsupported legacy feature option DUK_OPT_NO_FILE_IO used #endif #if defined(DUK_OPT_NO_FUNC_STMT) #error unsupported legacy feature option DUK_OPT_NO_FUNC_STMT used #endif #if defined(DUK_OPT_NO_JC) #error unsupported legacy feature option DUK_OPT_NO_JC used #endif #if defined(DUK_OPT_NO_JSONC) #error unsupported legacy feature option DUK_OPT_NO_JSONC used #endif #if defined(DUK_OPT_NO_JSONX) #error unsupported legacy feature option DUK_OPT_NO_JSONX used #endif #if defined(DUK_OPT_NO_JX) #error unsupported legacy feature option DUK_OPT_NO_JX used #endif #if defined(DUK_OPT_NO_MARK_AND_SWEEP) #error unsupported legacy feature option DUK_OPT_NO_MARK_AND_SWEEP used #endif #if defined(DUK_OPT_NO_MS_STRINGTABLE_RESIZE) #error unsupported legacy feature option DUK_OPT_NO_MS_STRINGTABLE_RESIZE used #endif #if defined(DUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT) #error unsupported legacy feature option DUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT used #endif #if defined(DUK_OPT_NO_NONSTD_ARRAY_CONCAT_TRAILER) #error unsupported legacy feature option DUK_OPT_NO_NONSTD_ARRAY_CONCAT_TRAILER used #endif #if defined(DUK_OPT_NO_NONSTD_ARRAY_MAP_TRAILER) #error unsupported legacy feature option DUK_OPT_NO_NONSTD_ARRAY_MAP_TRAILER used #endif #if defined(DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT) #error unsupported legacy feature option DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT used #endif #if defined(DUK_OPT_NO_NONSTD_FUNC_STMT) #error unsupported legacy feature option DUK_OPT_NO_NONSTD_FUNC_STMT used #endif #if defined(DUK_OPT_NO_NONSTD_JSON_ESC_U2028_U2029) #error unsupported legacy feature option DUK_OPT_NO_NONSTD_JSON_ESC_U2028_U2029 used #endif #if defined(DUK_OPT_NO_NONSTD_STRING_FROMCHARCODE_32BIT) #error unsupported legacy feature option DUK_OPT_NO_NONSTD_STRING_FROMCHARCODE_32BIT used #endif #if defined(DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY) #error unsupported legacy feature option DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY used #endif #if defined(DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF) #error unsupported legacy feature option DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF used #endif #if defined(DUK_OPT_NO_OCTAL_SUPPORT) #error unsupported legacy feature option DUK_OPT_NO_OCTAL_SUPPORT used #endif #if defined(DUK_OPT_NO_PACKED_TVAL) #error unsupported legacy feature option DUK_OPT_NO_PACKED_TVAL used #endif #if defined(DUK_OPT_NO_PC2LINE) #error unsupported legacy feature option DUK_OPT_NO_PC2LINE used #endif #if defined(DUK_OPT_NO_REFERENCE_COUNTING) #error unsupported legacy feature option DUK_OPT_NO_REFERENCE_COUNTING used #endif #if defined(DUK_OPT_NO_REGEXP_SUPPORT) #error unsupported legacy feature option DUK_OPT_NO_REGEXP_SUPPORT used #endif #if defined(DUK_OPT_NO_SECTION_B) #error unsupported legacy feature option DUK_OPT_NO_SECTION_B used #endif #if defined(DUK_OPT_NO_SOURCE_NONBMP) #error unsupported legacy feature option DUK_OPT_NO_SOURCE_NONBMP used #endif #if defined(DUK_OPT_NO_STRICT_DECL) #error unsupported legacy feature option DUK_OPT_NO_STRICT_DECL used #endif #if defined(DUK_OPT_NO_TRACEBACKS) #error unsupported legacy feature option DUK_OPT_NO_TRACEBACKS used #endif #if defined(DUK_OPT_NO_VERBOSE_ERRORS) #error unsupported legacy feature option DUK_OPT_NO_VERBOSE_ERRORS used #endif #if defined(DUK_OPT_NO_VOLUNTARY_GC) #error unsupported legacy feature option DUK_OPT_NO_VOLUNTARY_GC used #endif #if defined(DUK_OPT_NO_ZERO_BUFFER_DATA) #error unsupported legacy feature option DUK_OPT_NO_ZERO_BUFFER_DATA used #endif #if defined(DUK_OPT_OBJSIZES16) #error unsupported legacy feature option DUK_OPT_OBJSIZES16 used #endif #if defined(DUK_OPT_PANIC_HANDLER) #error unsupported legacy feature option DUK_OPT_PANIC_HANDLER used #endif #if defined(DUK_OPT_REFCOUNT16) #error unsupported legacy feature option DUK_OPT_REFCOUNT16 used #endif #if defined(DUK_OPT_SEGFAULT_ON_PANIC) #error unsupported legacy feature option DUK_OPT_SEGFAULT_ON_PANIC used #endif #if defined(DUK_OPT_SELF_TESTS) #error unsupported legacy feature option DUK_OPT_SELF_TESTS used #endif #if defined(DUK_OPT_SETJMP) #error unsupported legacy feature option DUK_OPT_SETJMP used #endif #if defined(DUK_OPT_SHUFFLE_TORTURE) #error unsupported legacy feature option DUK_OPT_SHUFFLE_TORTURE used #endif #if defined(DUK_OPT_SIGSETJMP) #error unsupported legacy feature option DUK_OPT_SIGSETJMP used #endif #if defined(DUK_OPT_STRHASH16) #error unsupported legacy feature option DUK_OPT_STRHASH16 used #endif #if defined(DUK_OPT_STRICT_UTF8_SOURCE) #error unsupported legacy feature option DUK_OPT_STRICT_UTF8_SOURCE used #endif #if defined(DUK_OPT_STRLEN16) #error unsupported legacy feature option DUK_OPT_STRLEN16 used #endif #if defined(DUK_OPT_STRTAB_CHAIN) #error unsupported legacy feature option DUK_OPT_STRTAB_CHAIN used #endif #if defined(DUK_OPT_STRTAB_CHAIN_SIZE) #error unsupported legacy feature option DUK_OPT_STRTAB_CHAIN_SIZE used #endif #if defined(DUK_OPT_TARGET_INFO) #error unsupported legacy feature option DUK_OPT_TARGET_INFO used #endif #if defined(DUK_OPT_TRACEBACK_DEPTH) #error unsupported legacy feature option DUK_OPT_TRACEBACK_DEPTH used #endif #if defined(DUK_OPT_UNDERSCORE_SETJMP) #error unsupported legacy feature option DUK_OPT_UNDERSCORE_SETJMP used #endif #if defined(DUK_OPT_USER_INITJS) #error unsupported legacy feature option DUK_OPT_USER_INITJS used #endif /* * 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_BROWSER_LIKE) #error unsupported config option used (option has been removed): DUK_USE_BROWSER_LIKE #endif #if defined(DUK_USE_BUILTIN_INITJS) #error unsupported config option used (option has been removed): DUK_USE_BUILTIN_INITJS #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_DDDPRINT) #error unsupported config option used (option has been removed): DUK_USE_DDDPRINT #endif #if defined(DUK_USE_DDPRINT) #error unsupported config option used (option has been removed): DUK_USE_DDPRINT #endif #if defined(DUK_USE_DEBUGGER_FWD_LOGGING) #error unsupported config option used (option has been removed): DUK_USE_DEBUGGER_FWD_LOGGING #endif #if defined(DUK_USE_DEBUGGER_FWD_PRINTALERT) #error unsupported config option used (option has been removed): DUK_USE_DEBUGGER_FWD_PRINTALERT #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) #error unsupported config option used (option has been removed): DUK_USE_DPRINT #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_DPRINT_COLORS) #error unsupported config option used (option has been removed): DUK_USE_DPRINT_COLORS #endif #if defined(DUK_USE_DPRINT_RDTSC) #error unsupported config option used (option has been removed): DUK_USE_DPRINT_RDTSC #endif #if defined(DUK_USE_ES6_REGEXP_BRACES) #error unsupported config option used (option has been removed): DUK_USE_ES6_REGEXP_BRACES #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_FASTINT) && !defined(DUK_USE_64BIT_OPS) #error config option DUK_USE_FASTINT requires option DUK_USE_64BIT_OPS (which is missing) #endif #if defined(DUK_USE_FILE_IO) #error unsupported config option used (option has been removed): DUK_USE_FILE_IO #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_MARKANDSWEEP_FINALIZER_TORTURE) #error unsupported config option used (option has been removed): DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE #endif #if defined(DUK_USE_MARK_AND_SWEEP) #error unsupported config option used (option has been removed): DUK_USE_MARK_AND_SWEEP #endif #if defined(DUK_USE_MATH_FMAX) #error unsupported config option used (option has been removed): DUK_USE_MATH_FMAX #endif #if defined(DUK_USE_MATH_FMIN) #error unsupported config option used (option has been removed): DUK_USE_MATH_FMIN #endif #if defined(DUK_USE_MATH_ROUND) #error unsupported config option used (option has been removed): DUK_USE_MATH_ROUND #endif #if defined(DUK_USE_MS_STRINGTABLE_RESIZE) #error unsupported config option used (option has been removed): DUK_USE_MS_STRINGTABLE_RESIZE #endif #if defined(DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE) #error unsupported config option used (option has been removed): DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE #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_OCTAL_SUPPORT) #error unsupported config option used (option has been removed): DUK_USE_OCTAL_SUPPORT #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_PANIC_ABORT) #error unsupported config option used (option has been removed): DUK_USE_PANIC_ABORT #endif #if defined(DUK_USE_PANIC_EXIT) #error unsupported config option used (option has been removed): DUK_USE_PANIC_EXIT #endif #if defined(DUK_USE_PANIC_HANDLER) #error unsupported config option used (option has been removed): DUK_USE_PANIC_HANDLER #endif #if defined(DUK_USE_PANIC_SEGFAULT) #error unsupported config option used (option has been removed): DUK_USE_PANIC_SEGFAULT #endif #if defined(DUK_USE_POW_NETBSD_WORKAROUND) #error unsupported config option used (option has been removed): DUK_USE_POW_NETBSD_WORKAROUND #endif #if defined(DUK_USE_RDTSC) #error unsupported config option used (option has been removed): DUK_USE_RDTSC #endif #if defined(DUK_USE_REFZERO_FINALIZER_TORTURE) #error unsupported config option used (option has been removed): DUK_USE_REFZERO_FINALIZER_TORTURE #endif #if defined(DUK_USE_ROM_GLOBAL_CLONE) && !defined(DUK_USE_ROM_STRINGS) #error config option DUK_USE_ROM_GLOBAL_CLONE requires option DUK_USE_ROM_STRINGS (which is missing) #endif #if defined(DUK_USE_ROM_GLOBAL_CLONE) && !defined(DUK_USE_ROM_OBJECTS) #error config option DUK_USE_ROM_GLOBAL_CLONE requires option DUK_USE_ROM_OBJECTS (which is missing) #endif #if defined(DUK_USE_ROM_GLOBAL_CLONE) && defined(DUK_USE_ROM_GLOBAL_INHERIT) #error config option DUK_USE_ROM_GLOBAL_CLONE conflicts with option DUK_USE_ROM_GLOBAL_INHERIT (which is also defined) #endif #if defined(DUK_USE_ROM_GLOBAL_INHERIT) && !defined(DUK_USE_ROM_STRINGS) #error config option DUK_USE_ROM_GLOBAL_INHERIT requires option DUK_USE_ROM_STRINGS (which is missing) #endif #if defined(DUK_USE_ROM_GLOBAL_INHERIT) && !defined(DUK_USE_ROM_OBJECTS) #error config option DUK_USE_ROM_GLOBAL_INHERIT requires option DUK_USE_ROM_OBJECTS (which is missing) #endif #if defined(DUK_USE_ROM_GLOBAL_INHERIT) && defined(DUK_USE_ROM_GLOBAL_CLONE) #error config option DUK_USE_ROM_GLOBAL_INHERIT conflicts with option DUK_USE_ROM_GLOBAL_CLONE (which is also defined) #endif #if defined(DUK_USE_ROM_OBJECTS) && !defined(DUK_USE_ROM_STRINGS) #error config option DUK_USE_ROM_OBJECTS requires option DUK_USE_ROM_STRINGS (which is missing) #endif #if defined(DUK_USE_ROM_STRINGS) && !defined(DUK_USE_ROM_OBJECTS) #error config option DUK_USE_ROM_STRINGS requires option DUK_USE_ROM_OBJECTS (which is missing) #endif #if defined(DUK_USE_SETJMP) #error unsupported config option used (option has been removed): DUK_USE_SETJMP #endif #if defined(DUK_USE_SIGSETJMP) #error unsupported config option used (option has been removed): DUK_USE_SIGSETJMP #endif #if defined(DUK_USE_STRTAB_CHAIN) #error unsupported config option used (option has been removed): DUK_USE_STRTAB_CHAIN #endif #if defined(DUK_USE_STRTAB_CHAIN_SIZE) #error unsupported config option used (option has been removed): DUK_USE_STRTAB_CHAIN_SIZE #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_STRTAB_PROBE) #error unsupported config option used (option has been removed): DUK_USE_STRTAB_PROBE #endif #if defined(DUK_USE_STRTAB_PTRCOMP) && !defined(DUK_USE_HEAPPTR16) #error config option DUK_USE_STRTAB_PTRCOMP requires option DUK_USE_HEAPPTR16 (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_UNDERSCORE_SETJMP) #error unsupported config option used (option has been removed): DUK_USE_UNDERSCORE_SETJMP #endif #if defined(DUK_USE_USER_INITJS) #error unsupported config option used (option has been removed): DUK_USE_USER_INITJS #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 */