duktape 0.11.0.0 → 1.0.2.0

data/ext/duktape/duktape.h

@@ -1,13 +1,13 @@
 /*
- *  Duktape public API for Duktape 0.11.0.
+ *  Duktape public API for Duktape 1.0.2.
  *  See the API reference for documentation on call semantics.
  *  The exposed API is inside the DUK_API_PUBLIC_H_INCLUDED
  *  include guard.  Other parts of the header are Duktape
  *  internal and related to platform/compiler/feature detection.
  *
- *  Git commit 621b545c474dd7a3def7aefed0557b1a825a4578 (v0.10.0-827-g621b545).
+ *  Git commit a476318bf025137c2847c808a8334d8b7db985f2 (v1.0.2).
  *
- *  See Duktape AUTHORS.txt and LICENSE.txt for copyright and
+ *  See Duktape AUTHORS.rst and LICENSE.txt for copyright and
  *  licensing information.
  */
 
@@ -19,7 +19,7 @@
  *  
  *  (http://opensource.org/licenses/MIT)
  *  
- *  Copyright (c) 2013-2014 by Duktape authors (see AUTHORS.txt)
+ *  Copyright (c) 2013-2014 by Duktape authors (see AUTHORS.rst)
  *  
  *  Permission is hereby granted, free of charge, to any person obtaining a copy
  *  of this software and associated documentation files (the "Software"), to deal
@@ -41,7 +41,7 @@
  *  
  */
 
-/* AUTHORS.txt */
+/* AUTHORS.rst */
 /*
  *  ===============
  *  Duktape authors
@@ -88,11 +88,14 @@
  *  * Andreas \u00d6man
  *  * Doug Sanden
  *  * Remo Eichenberger (https://github.com/remoe)
+ *  * David Demelier
  */
 
 #ifndef DUKTAPE_H_INCLUDED
 #define DUKTAPE_H_INCLUDED
 
+#define DUK_SINGLE_FILE
+
 /*
  *  Determine platform features, select feature selection defines
  *  (e.g. _XOPEN_SOURCE), include system headers, and define DUK_USE_XXX
@@ -230,7 +233,7 @@ static __inline__ unsigned long long duk_rdtsc(void) {
 #endif
 
 /* MIPS */
-/* FIXME: 32-bit vs. 64-bit MIPS */
+/* XXX: 32-bit vs. 64-bit MIPS */
 #if defined(__mips__) || defined(mips) || defined(_MIPS_ISA) || \
     defined(_R3000) || defined(_R4000) || defined(_R5900) || \
     defined(_MIPS_ISA_MIPS1) || defined(_MIPS_ISA_MIPS2) || \
@@ -272,12 +275,17 @@ static __inline__ unsigned long long duk_rdtsc(void) {
 #define DUK_F_BSD
 #endif
 
-/* Generic Unix */
+/* Generic Unix (includes Cygwin) */
 #if defined(__unix) || defined(__unix__) || defined(unix) || \
     defined(DUK_F_LINUX) || defined(DUK_F_BSD)
 #define DUK_F_UNIX
 #endif
 
+/* Cygwin */
+#if defined(__CYGWIN__)
+#define DUK_F_CYGWIN
+#endif
+
 /* Windows (32-bit or above) */
 #if defined(_WIN32) || defined(WIN32) || defined(_WIN64) || defined(WIN64) || \
     defined(__WIN32__) || defined(__TOS_WIN__) || defined(__WINDOWS__)
@@ -328,6 +336,13 @@ static __inline__ unsigned long long duk_rdtsc(void) {
 /* Clang */
 #if defined(__clang__)
 #define DUK_F_CLANG
+/* It seems clang also defines __GNUC__, so undo the GCC detection. */
+#if defined(DUK_F_GCC)
+#undef DUK_F_GCC
+#endif
+#if defined(DUK_F_GCC_VERSION)
+#undef DUK_F_GCC_VERSION
+#endif
 #endif
 
 /* MSVC */
@@ -337,7 +352,14 @@ static __inline__ unsigned long long duk_rdtsc(void) {
  * BOOST_MSVC_FULL_VER in http://www.boost.org/doc/libs/1_52_0/boost/config/compiler/visualc.hpp
  */
 #define DUK_F_MSVC
+#if defined(_MSC_FULL_VER)
+#if (_MSC_FULL_VER > 100000000)
+#define DUK_F_MSVC_FULL_VER _MSC_FULL_VER
+#else
+#define DUK_F_MSCV_FULL_VER (_MSC_FULL_VER * 10)
 #endif
+#endif
+#endif  /* _MSC_VER */
 
 /* MinGW */
 #if defined(__MINGW32__) || defined(__MINGW64__)
@@ -393,7 +415,7 @@ static __inline__ unsigned long long duk_rdtsc(void) {
  *  #ifdefs, but it would then be more difficult to make fixes which
  *  affect only a specific platform.
  *
- *  FIXME: add a way to provide custom functions to provide the critical
+ *  XXX: add a way to provide custom functions to provide the critical
  *  primitives; this would be convenient when porting to unknown platforms
  *  (rather than muck with Duktape internals).
  */
@@ -563,6 +585,17 @@ static __inline__ unsigned long long duk_rdtsc(void) {
 #include <sys/param.h>
 #include <sys/time.h>
 #include <time.h>
+#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 <limits.h>
+#include <sys/param.h>
+#include <sys/time.h>
+#include <time.h>
 #else
 /* Other UNIX, hopefully others */
 #define DUK_USE_DATE_NOW_GETTIMEOFDAY
@@ -631,7 +664,7 @@ static __inline__ unsigned long long duk_rdtsc(void) {
  *  being able to compare DUK_SIZE_MAX against a limit.
  */
 
-/* FIXME: add feature options to force basic types from outside? */
+/* XXX: add feature options to force basic types from outside? */
 
 #if !defined(INT_MAX)
 #error INT_MAX not defined
@@ -1978,6 +2011,94 @@ typedef FILE duk_file;
 #define DUK_UNLIKELY(x)  (x)
 #endif
 
+/*
+ *  Symbol visibility macros
+ */
+
+/* XXX: user override for these? user override for just using the default visibility macros? */
+/* XXX: separate macros for function and data may be necessary at some point. */
+
+#if defined(DUK_F_GCC_VERSION)
+#if (DUK_F_GCC_VERSION >= 40000)
+/* Might work on earlier versions too but limit to GCC 4+. */
+#define DUK_F_GCC_SYMBOL_VISIBILITY
+#endif
+#endif
+#if defined(DUK_F_CLANG) && !defined(DUK_F_GCC_SYMBOL_VISIBILITY)
+#define DUK_F_GCC_SYMBOL_VISIBILITY
+#endif
+#if defined(DUK_OPT_DLL_BUILD) && defined(_WIN32) && (defined(_MSC_VER) || defined(__GNUC__))
+/* __declspec(dllexport) and __declspec(dllimport) only for Windows DLL build.
+ * MSVC: any minimum version?
+ * MinGW: no minimum version, even gcc-2.95.3 supported dllimport/dllexport.
+*/
+#define DUK_F_MSVC_DLL_SYMBOL_VISIBILITY
+#endif
+
+#if defined(DUK_F_GCC_SYMBOL_VISIBILITY)
+/* GCC 4+ visibility attributes. */
+#define DUK_EXTERNAL_DECL  __attribute__ ((visibility("default"))) extern
+#define DUK_EXTERNAL       __attribute__ ((visibility("default")))
+#if defined(DUK_SINGLE_FILE)
+#define DUK_INTERNAL_DECL  static
+#define DUK_INTERNAL       static
+#else
+#define DUK_INTERNAL_DECL  __attribute__ ((visibility("hidden"))) extern
+#define DUK_INTERNAL       __attribute__ ((visibility("hidden")))
+#endif
+#elif defined(DUK_F_MSVC_DLL_SYMBOL_VISIBILITY)
+/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're
+ * compiling Duktape or the application.
+ */
+#if defined(DUK_COMPILING_DUKTAPE)
+#define DUK_EXTERNAL_DECL  extern __declspec(dllexport)
+#define DUK_EXTERNAL       __declspec(dllexport)
+#else
+#define DUK_EXTERNAL_DECL  extern __declspec(dllimport)
+#define DUK_EXTERNAL       should_not_happen
+#endif
+#if defined(DUK_SINGLE_FILE)
+#define DUK_INTERNAL_DECL  static
+#define DUK_INTERNAL       static
+#else
+#define DUK_INTERNAL_DECL  extern
+#define DUK_INTERNAL       /*empty*/
+#endif
+#else
+/* Default visibility. */
+#define DUK_EXTERNAL_DECL  extern
+#define DUK_EXTERNAL       /*empty*/
+#if defined(DUK_SINGLE_FILE)
+#define DUK_INTERNAL_DECL  static
+#define DUK_INTERNAL       static
+#else  /* DUK_SINGLE_FILE */
+#define DUK_INTERNAL_DECL  extern
+#define DUK_INTERNAL       /*empty*/
+#endif
+#endif
+
+/* For now, these are shared. */
+#define DUK_LOCAL_DECL     static
+#define DUK_LOCAL          static
+
+/* In C++ one cannot declare and define "static" variables separately (GH-63).
+ * As a quick workaround, use "extern" instead: it makes the symbol table ugly
+ * but allows compilation.  A better fix is to avoid the need to forward declare
+ * internal symbols, but it requires changes to combine_src.py.
+ *
+ * XXX: better fix is needed.
+ */
+#if defined(DUK_F_CPP)
+#undef DUK_INTERNAL_DECL
+#undef DUK_INTERNAL
+#undef DUK_LOCAL_DECL
+#undef DUK_LOCAL
+#define DUK_INTERNAL_DECL  extern
+#define DUK_INTERNAL       /*empty*/
+#define DUK_LOCAL_DECL     extern
+#define DUK_LOCAL          /*empty*/
+#endif
+
 /*
  *  __FILE__, __LINE__, __func__ are wrapped.  Especially __func__ is a
  *  problem because it is not available even in some compilers which try
@@ -2018,7 +2139,53 @@ typedef FILE duk_file;
 #define DUK_USE_ARCH_STRING "unknown"
 #endif
 
-/* 
+/*
+ *  OS string, human readable value exposed in Duktape.env
+ */
+
+#if defined(DUK_F_LINUX)
+#define DUK_USE_OS_STRING "linux"
+#elif defined(DUK_F_FREEBSD)
+#define DUK_USE_OS_STRING "freebsd"
+#elif defined(DUK_F_OPENBSD)
+#define DUK_USE_OS_STRING "openbsd"
+#elif defined(DUK_F_NETBSD)
+#define DUK_USE_OS_STRING "netbsd"
+#elif defined(DUK_F_BSD)
+#define DUK_USE_OS_STRING "bsd"
+#elif defined(DUK_F_UNIX)
+#define DUK_USE_OS_STRING "unix"
+#elif defined(DUK_F_WINDOWS)
+#define DUK_USE_OS_STRING "windows"
+#elif defined(DUK_F_TOS)
+#define DUK_USE_OS_STRING "tos"
+#elif defined(DUK_F_AMIGAOS)
+#define DUK_USE_OS_STRING "amigaos"
+#elif defined(DUK_F_QNX)
+#define DUK_USE_OS_STRING "qnx"
+#else
+#define DUK_USE_OS_STRING "unknown"
+#endif
+
+/*
+ *  Compiler string, human readable value exposed in Duktape.env
+ */
+
+#if defined(DUK_F_GCC)
+#define DUK_USE_COMPILER_STRING "gcc"
+#elif defined(DUK_F_CLANG)
+#define DUK_USE_COMPILER_STRING "clang"
+#elif defined(DUK_F_MSVC)
+#define DUK_USE_COMPILER_STRING "msvc"
+#elif defined(DUK_F_MINGW)
+#define DUK_USE_COMPILER_STRING "mingw"
+#elif defined(DUK_F_VBCC)
+#define DUK_USE_COMPILER_STRING "vbcc"
+#else
+#define DUK_USE_COMPILER_STRING "unknown"
+#endif
+
+/*
  *  Tagged type representation (duk_tval)
  */
 
@@ -2112,10 +2279,15 @@ typedef FILE duk_file;
  *  Execution and debugger options
  */
 
+/* Executor interrupt disabled for 1.0 release: there is no API to use it */
+#if 0
 #define DUK_USE_INTERRUPT_COUNTER
 #if defined(DUK_OPT_NO_INTERRUPT_COUNTER)
 #undef DUK_USE_INTERRUPT_COUNTER
 #endif
+#endif
+
+#undef DUK_USE_INTERRUPT_COUNTER
 
 /* For opcodes with indirect indices, check final index against stack size.
  * This should not be necessary because the compiler is trusted, and we don't
@@ -2228,7 +2400,7 @@ typedef FILE duk_file;
 /* Treat function statements (function declarations outside top level of
  * Program or FunctionBody) same as normal function declarations.  This is
  * also V8 behavior.  See test-dev-func-decl-outside-top.js.
- */ 
+ */
 #define DUK_USE_NONSTD_FUNC_STMT
 #if defined(DUK_OPT_NO_NONSTD_FUNC_STMT)
 #undef DUK_USE_NONSTD_FUNC_STMT
@@ -2242,6 +2414,22 @@ typedef FILE duk_file;
 #undef DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT
 #endif
 
+/* Array.prototype.concat() non-standard but real world compatible behavior
+ * for non-existent trailing elements.
+ */
+#define DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER
+#if defined(DUK_OPT_NO_NONSTD_ARRAY_CONCAT_TRAILER)
+#undef DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER
+#endif
+
+/* Array.prototype.map() non-standard but real world compatible behavior
+ * for non-existent trailing elements.
+ */
+#define DUK_USE_NONSTD_ARRAY_MAP_TRAILER
+#if defined(DUK_OPT_NO_NONSTD_ARRAY_MAP_TRAILER)
+#undef DUK_USE_NONSTD_ARRAY_MAP_TRAILER
+#endif
+
 /* Non-standard 'caller' property for function instances, see
  * test-bi-function-nonstd-caller-prop.js.
  */
@@ -2435,16 +2623,21 @@ typedef FILE duk_file;
 #undef DUK_USE_ZERO_BUFFER_DATA
 #endif
 
+#undef DUK_USE_VARIADIC_MACROS
 #if defined(DUK_F_C99) || (defined(DUK_F_CPP11) && defined(__GNUC__))
 #define DUK_USE_VARIADIC_MACROS
-#else
-#undef DUK_USE_VARIADIC_MACROS
+#endif
+#if defined(_MSC_VER) && !defined(DUK_USE_VARIADIC_MACROS)
+#if (_MSC_VER >= 1400)
+/* VS2005+ should have variadic macros even when they're not C99. */
+#define DUK_USE_VARIADIC_MACROS
+#endif
 #endif
 
 /*
  *  Variable size array initialization.
  *
- *  Variable size array at the end of a structure is nonportable. 
+ *  Variable size array at the end of a structure is nonportable.
  *  There are three alternatives:
  *
  *    1) C99 (flexible array member): char buf[]
@@ -2558,16 +2751,16 @@ typedef duk_codepoint_t (*duk_map_char_function) (void *udata, duk_codepoint_t c
 typedef duk_ret_t (*duk_safe_call_function) (duk_context *ctx);
 
 struct duk_memory_functions {
-	duk_alloc_function alloc;
-	duk_realloc_function realloc;
-	duk_free_function free;
+	duk_alloc_function alloc_func;
+	duk_realloc_function realloc_func;
+	duk_free_function free_func;
 	void *udata;
 };
 
 struct duk_function_list_entry {
 	const char *key;
 	duk_c_function value;
-	duk_int_t nargs;
+	duk_idx_t nargs;
 };
 
 struct duk_number_list_entry {
@@ -2585,13 +2778,13 @@ struct duk_number_list_entry {
  * have 99 for patch level (e.g. 0.10.99 would be a development version
  * after 0.10.0 but before the next official release).
  */
-#define DUK_VERSION                       1100L
+#define DUK_VERSION                       10002L
 
 /* Used to represent invalid index; if caller uses this without checking,
  * this index will map to a non-existent stack entry.  Also used in some
  * API calls as a marker to denote "no value".
  */
-#define DUK_INVALID_INDEX                 INT_MIN 
+#define DUK_INVALID_INDEX                 DUK_IDX_MIN
 
 /* Indicates that a native function does not have a fixed number of args,
  * and the argument stack should not be capped/extended at all.
@@ -2653,6 +2846,9 @@ struct duk_number_list_entry {
 /* Flags for duk_push_thread_raw() */
 #define DUK_THREAD_NEW_GLOBAL_ENV         (1 << 0)    /* create a new global environment */
 
+/* Flags for duk_push_string_file_raw() */
+#define DUK_STRING_PUSH_SAFE              (1 << 0)    /* no error if file does not exist */
+
 /* Duktape specific error codes */
 #define DUK_ERR_UNIMPLEMENTED_ERROR       50   /* UnimplementedError */
 #define DUK_ERR_UNSUPPORTED_ERROR         51   /* UnsupportedError */
@@ -2692,12 +2888,12 @@ struct duk_number_list_entry {
 #define DUK_EXEC_ERROR                    1
 
 /* Log levels */
-#define  DUK_LOG_TRACE                    0
-#define  DUK_LOG_DEBUG                    1
-#define  DUK_LOG_INFO                     2
-#define  DUK_LOG_WARN                     3
-#define  DUK_LOG_ERROR                    4
-#define  DUK_LOG_FATAL                    5
+#define DUK_LOG_TRACE                     0
+#define DUK_LOG_DEBUG                     1
+#define DUK_LOG_INFO                      2
+#define DUK_LOG_WARN                      3
+#define DUK_LOG_ERROR                     4
+#define DUK_LOG_FATAL                     5
 
 /*
  *  If no variadic macros, __FILE__ and __LINE__ are passed through globals
@@ -2705,20 +2901,21 @@ struct duk_number_list_entry {
  */
 
 #ifndef DUK_API_VARIADIC_MACROS
-extern const char *duk_api_global_filename;
-extern duk_int_t duk_api_global_line;
+DUK_EXTERNAL_DECL const char *duk_api_global_filename;
+DUK_EXTERNAL_DECL duk_int_t duk_api_global_line;
 #endif
 
 /*
  *  Context management
  */
 
+DUK_EXTERNAL_DECL
 duk_context *duk_create_heap(duk_alloc_function alloc_func,
                              duk_realloc_function realloc_func,
                              duk_free_function free_func,
                              void *alloc_udata,
                              duk_fatal_function fatal_handler);
-void duk_destroy_heap(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_destroy_heap(duk_context *ctx);
 
 #define duk_create_heap_default() \
 	duk_create_heap(NULL, NULL, NULL, NULL, NULL)
@@ -2729,56 +2926,59 @@ void duk_destroy_heap(duk_context *ctx);
  *  Raw functions have no side effects (cannot trigger GC).
  */
 
-void *duk_alloc_raw(duk_context *ctx, duk_size_t size);
-void duk_free_raw(duk_context *ctx, void *ptr);
-void *duk_realloc_raw(duk_context *ctx, void *ptr, duk_size_t size);
-void *duk_alloc(duk_context *ctx, duk_size_t size);
-void duk_free(duk_context *ctx, void *ptr);
-void *duk_realloc(duk_context *ctx, void *ptr, duk_size_t size);
-void duk_get_memory_functions(duk_context *ctx, duk_memory_functions *out_funcs);
-void duk_gc(duk_context *ctx, duk_uint_t flags);
+DUK_EXTERNAL_DECL void *duk_alloc_raw(duk_context *ctx, duk_size_t size);
+DUK_EXTERNAL_DECL void duk_free_raw(duk_context *ctx, void *ptr);
+DUK_EXTERNAL_DECL void *duk_realloc_raw(duk_context *ctx, void *ptr, duk_size_t size);
+DUK_EXTERNAL_DECL void *duk_alloc(duk_context *ctx, duk_size_t size);
+DUK_EXTERNAL_DECL void duk_free(duk_context *ctx, void *ptr);
+DUK_EXTERNAL_DECL void *duk_realloc(duk_context *ctx, void *ptr, duk_size_t size);
+DUK_EXTERNAL_DECL void duk_get_memory_functions(duk_context *ctx, duk_memory_functions *out_funcs);
+DUK_EXTERNAL_DECL void duk_gc(duk_context *ctx, duk_uint_t flags);
 
 /*
  *  Error handling
  */
 
-DUK_API_NORETURN(void duk_throw(duk_context *ctx));
+DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_throw(duk_context *ctx));
 
-DUK_API_NORETURN(void duk_error_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, ...));
+DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_error_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, ...));
 #ifdef DUK_API_VARIADIC_MACROS
 #define duk_error(ctx,err_code,...)  \
 	duk_error_raw((ctx), (duk_errcode_t) (err_code), __FILE__, (duk_int_t) __LINE__, __VA_ARGS__)
 #else
-DUK_API_NORETURN(void duk_error_stash(duk_context *ctx, duk_errcode_t err_code, const char *fmt, ...));
+DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_error_stash(duk_context *ctx, duk_errcode_t err_code, const char *fmt, ...));
+/* One problem with this macro is that expressions like the following fail
+ * to compile: "(void) duk_error(...)".  But because duk_error() is noreturn,
+ * they make little sense anyway.
+ */
 #define duk_error  \
 	duk_api_global_filename = __FILE__, \
 	duk_api_global_line = (duk_int_t) __LINE__, \
 	duk_error_stash  /* arguments follow */
 #endif
 
-DUK_API_NORETURN(void duk_fatal(duk_context *ctx, duk_errcode_t err_code, const char *err_msg));
+DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_fatal(duk_context *ctx, duk_errcode_t err_code, const char *err_msg));
 
 /*
  *  Other state related functions
  */
 
-duk_bool_t duk_is_strict_call(duk_context *ctx);
-duk_bool_t duk_is_constructor_call(duk_context *ctx);
-duk_int_t duk_get_magic(duk_context *ctx);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_strict_call(duk_context *ctx);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_constructor_call(duk_context *ctx);
 
 /*
  *  Stack management
  */
 
-duk_idx_t duk_normalize_index(duk_context *ctx, duk_idx_t index);
-duk_idx_t duk_require_normalize_index(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_is_valid_index(duk_context *ctx, duk_idx_t index);
-void duk_require_valid_index(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_idx_t duk_normalize_index(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_idx_t duk_require_normalize_index(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_valid_index(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL void duk_require_valid_index(duk_context *ctx, duk_idx_t index);
 
-duk_idx_t duk_get_top(duk_context *ctx);
-void duk_set_top(duk_context *ctx, duk_idx_t index);
-duk_idx_t duk_get_top_index(duk_context *ctx);
-duk_idx_t duk_require_top_index(duk_context *ctx);
+DUK_EXTERNAL_DECL duk_idx_t duk_get_top(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_set_top(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_idx_t duk_get_top_index(duk_context *ctx);
+DUK_EXTERNAL_DECL duk_idx_t duk_require_top_index(duk_context *ctx);
 
 /* Although extra/top could be an unsigned type here, using a signed type
  * makes the API more robust to calling code calculation errors or corner
@@ -2787,25 +2987,29 @@ duk_idx_t duk_require_top_index(duk_context *ctx);
  * to a large unsigned number.  (This principle is used elsewhere in the
  * API too.)
  */
-duk_bool_t duk_check_stack(duk_context *ctx, duk_idx_t extra);
-void duk_require_stack(duk_context *ctx, duk_idx_t extra);
-duk_bool_t duk_check_stack_top(duk_context *ctx, duk_idx_t top);
-void duk_require_stack_top(duk_context *ctx, duk_idx_t top);
+DUK_EXTERNAL_DECL duk_bool_t duk_check_stack(duk_context *ctx, duk_idx_t extra);
+DUK_EXTERNAL_DECL void duk_require_stack(duk_context *ctx, duk_idx_t extra);
+DUK_EXTERNAL_DECL duk_bool_t duk_check_stack_top(duk_context *ctx, duk_idx_t top);
+DUK_EXTERNAL_DECL void duk_require_stack_top(duk_context *ctx, duk_idx_t top);
 
 /*
  *  Stack manipulation (other than push/pop)
  */
 
-void duk_swap(duk_context *ctx, duk_idx_t index1, duk_idx_t index2);
-void duk_swap_top(duk_context *ctx, duk_idx_t index);
-void duk_dup(duk_context *ctx, duk_idx_t from_index);
-void duk_dup_top(duk_context *ctx);
-void duk_insert(duk_context *ctx, duk_idx_t to_index);
-void duk_replace(duk_context *ctx, duk_idx_t to_index);
-void duk_copy(duk_context *ctx, duk_idx_t from_index, duk_idx_t to_index);
-void duk_remove(duk_context *ctx, duk_idx_t index);
-/* FIXME: undocumented */
-void duk_xmove(duk_context *from_ctx, duk_context *to_ctx, duk_idx_t count);
+DUK_EXTERNAL_DECL void duk_swap(duk_context *ctx, duk_idx_t index1, duk_idx_t index2);
+DUK_EXTERNAL_DECL void duk_swap_top(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL void duk_dup(duk_context *ctx, duk_idx_t from_index);
+DUK_EXTERNAL_DECL void duk_dup_top(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_insert(duk_context *ctx, duk_idx_t to_index);
+DUK_EXTERNAL_DECL void duk_replace(duk_context *ctx, duk_idx_t to_index);
+DUK_EXTERNAL_DECL void duk_copy(duk_context *ctx, duk_idx_t from_index, duk_idx_t to_index);
+DUK_EXTERNAL_DECL void duk_remove(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL void duk_xcopymove_raw(duk_context *to_ctx, duk_context *from_ctx, duk_idx_t count, duk_bool_t is_copy);
+
+#define duk_xmove_top(to_ctx,from_ctx,count) \
+	duk_xcopymove_raw((to_ctx), (from_ctx), (count), 0 /*is_copy*/)
+#define duk_xcopy_top(to_ctx,from_ctx,count) \
+	duk_xcopymove_raw((to_ctx), (from_ctx), (count), 1 /*is_copy*/)
 
 /*
  *  Push operations
@@ -2816,34 +3020,37 @@ void duk_xmove(duk_context *from_ctx, duk_context *to_ctx, duk_idx_t count);
  *  Note: duk_dup() is technically a push.
  */
 
-void duk_push_undefined(duk_context *ctx);
-void duk_push_null(duk_context *ctx);
-void duk_push_boolean(duk_context *ctx, duk_bool_t val);
-void duk_push_true(duk_context *ctx);
-void duk_push_false(duk_context *ctx);
-void duk_push_number(duk_context *ctx, duk_double_t val);
-void duk_push_nan(duk_context *ctx);
-void duk_push_int(duk_context *ctx, duk_int_t val);
-void duk_push_uint(duk_context *ctx, duk_uint_t val);
-const char *duk_push_string(duk_context *ctx, const char *str);
-const char *duk_push_string_file(duk_context *ctx, const char *path);
-const char *duk_push_lstring(duk_context *ctx, const char *str, duk_size_t len);
-void duk_push_pointer(duk_context *ctx, void *p);
-const char *duk_push_sprintf(duk_context *ctx, const char *fmt, ...);
-const char *duk_push_vsprintf(duk_context *ctx, const char *fmt, va_list ap);
-
-void duk_push_this(duk_context *ctx);
-void duk_push_current_function(duk_context *ctx);
-void duk_push_current_thread(duk_context *ctx);
-void duk_push_global_object(duk_context *ctx);
-void duk_push_heap_stash(duk_context *ctx);
-void duk_push_global_stash(duk_context *ctx);
-void duk_push_thread_stash(duk_context *ctx, duk_context *target_ctx);
-
-duk_idx_t duk_push_object(duk_context *ctx);
-duk_idx_t duk_push_array(duk_context *ctx);
-duk_idx_t duk_push_c_function(duk_context *ctx, duk_c_function func, duk_idx_t nargs);
-duk_idx_t duk_push_thread_raw(duk_context *ctx, duk_uint_t flags);
+DUK_EXTERNAL_DECL void duk_push_undefined(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_push_null(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_push_boolean(duk_context *ctx, duk_bool_t val);
+DUK_EXTERNAL_DECL void duk_push_true(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_push_false(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_push_number(duk_context *ctx, duk_double_t val);
+DUK_EXTERNAL_DECL void duk_push_nan(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_push_int(duk_context *ctx, duk_int_t val);
+DUK_EXTERNAL_DECL void duk_push_uint(duk_context *ctx, duk_uint_t val);
+DUK_EXTERNAL_DECL const char *duk_push_string(duk_context *ctx, const char *str);
+DUK_EXTERNAL_DECL const char *duk_push_lstring(duk_context *ctx, const char *str, duk_size_t len);
+DUK_EXTERNAL_DECL void duk_push_pointer(duk_context *ctx, void *p);
+DUK_EXTERNAL_DECL const char *duk_push_sprintf(duk_context *ctx, const char *fmt, ...);
+DUK_EXTERNAL_DECL const char *duk_push_vsprintf(duk_context *ctx, const char *fmt, va_list ap);
+
+DUK_EXTERNAL_DECL const char *duk_push_string_file_raw(duk_context *ctx, const char *path, duk_uint_t flags);
+#define duk_push_string_file(ctx,path) \
+	duk_push_string_file_raw((ctx), (path), 0)
+
+DUK_EXTERNAL_DECL void duk_push_this(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_push_current_function(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_push_current_thread(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_push_global_object(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_push_heap_stash(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_push_global_stash(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_push_thread_stash(duk_context *ctx, duk_context *target_ctx);
+
+DUK_EXTERNAL_DECL duk_idx_t duk_push_object(duk_context *ctx);
+DUK_EXTERNAL_DECL duk_idx_t duk_push_array(duk_context *ctx);
+DUK_EXTERNAL_DECL duk_idx_t duk_push_c_function(duk_context *ctx, duk_c_function func, duk_idx_t nargs);
+DUK_EXTERNAL_DECL duk_idx_t duk_push_thread_raw(duk_context *ctx, duk_uint_t flags);
 
 #define duk_push_thread(ctx) \
 	duk_push_thread_raw((ctx), 0 /*flags*/)
@@ -2851,30 +3058,30 @@ duk_idx_t duk_push_thread_raw(duk_context *ctx, duk_uint_t flags);
 #define duk_push_thread_new_globalenv(ctx) \
 	duk_push_thread_raw((ctx), DUK_THREAD_NEW_GLOBAL_ENV /*flags*/)
 
-duk_idx_t duk_push_error_object_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, ...);
+DUK_EXTERNAL_DECL duk_idx_t duk_push_error_object_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, ...);
 #ifdef DUK_API_VARIADIC_MACROS
 #define duk_push_error_object(ctx,err_code,...)  \
 	duk_push_error_object_raw((ctx),(err_code),__FILE__,__LINE__,__VA_ARGS__)
 #else
-duk_idx_t duk_push_error_object_stash(duk_context *ctx, duk_errcode_t err_code, const char *fmt, ...);
+DUK_EXTERNAL_DECL duk_idx_t duk_push_error_object_stash(duk_context *ctx, duk_errcode_t err_code, const char *fmt, ...);
 #define duk_push_error_object  \
 	duk_api_global_filename = __FILE__, \
 	duk_api_global_line = __LINE__, \
 	duk_push_error_object_stash  /* arguments follow */
 #endif
 
-void *duk_push_buffer(duk_context *ctx, duk_size_t size, duk_bool_t dynamic);
-void *duk_push_fixed_buffer(duk_context *ctx, duk_size_t size);
-void *duk_push_dynamic_buffer(duk_context *ctx, duk_size_t size);
+DUK_EXTERNAL_DECL void *duk_push_buffer(duk_context *ctx, duk_size_t size, duk_bool_t dynamic);
+DUK_EXTERNAL_DECL void *duk_push_fixed_buffer(duk_context *ctx, duk_size_t size);
+DUK_EXTERNAL_DECL void *duk_push_dynamic_buffer(duk_context *ctx, duk_size_t size);
 
 /*
  *  Pop operations
  */
 
-void duk_pop(duk_context *ctx);
-void duk_pop_n(duk_context *ctx, duk_idx_t count);
-void duk_pop_2(duk_context *ctx);
-void duk_pop_3(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_pop(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_pop_n(duk_context *ctx, duk_idx_t count);
+DUK_EXTERNAL_DECL void duk_pop_2(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_pop_3(duk_context *ctx);
 
 /*
  *  Type checks
@@ -2883,35 +3090,34 @@ void duk_pop_3(duk_context *ctx);
  *  is not needed; duk_is_valid_index() gives the same information.
  */
 
-/* FIXME: a duk_small_int_t suffices to represent type and type mask (at least now). */
-duk_int_t duk_get_type(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_check_type(duk_context *ctx, duk_idx_t index, duk_int_t type);
-duk_uint_t duk_get_type_mask(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_check_type_mask(duk_context *ctx, duk_idx_t index, duk_uint_t mask);
-
-duk_bool_t duk_is_undefined(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_is_null(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_is_null_or_undefined(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_is_boolean(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_is_number(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_is_nan(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_is_string(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_is_object(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_is_buffer(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_is_pointer(duk_context *ctx, duk_idx_t index);
-
-duk_bool_t duk_is_array(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_is_function(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_is_c_function(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_is_ecmascript_function(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_is_bound_function(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_is_thread(duk_context *ctx, duk_idx_t index);
-
-duk_bool_t duk_is_callable(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_is_dynamic(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_is_fixed(duk_context *ctx, duk_idx_t index);
-
-duk_bool_t duk_is_primitive(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_int_t duk_get_type(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_check_type(duk_context *ctx, duk_idx_t index, duk_int_t type);
+DUK_EXTERNAL_DECL duk_uint_t duk_get_type_mask(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_check_type_mask(duk_context *ctx, duk_idx_t index, duk_uint_t mask);
+
+DUK_EXTERNAL_DECL duk_bool_t duk_is_undefined(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_null(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_null_or_undefined(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_boolean(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_number(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_nan(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_string(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_object(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_buffer(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_pointer(duk_context *ctx, duk_idx_t index);
+
+DUK_EXTERNAL_DECL duk_bool_t duk_is_array(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_function(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_c_function(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_ecmascript_function(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_bound_function(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_thread(duk_context *ctx, duk_idx_t index);
+
+DUK_EXTERNAL_DECL duk_bool_t duk_is_callable(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_dynamic_buffer(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_is_fixed_buffer(duk_context *ctx, duk_idx_t index);
+
+DUK_EXTERNAL_DECL duk_bool_t duk_is_primitive(duk_context *ctx, duk_idx_t index);
 #define duk_is_object_coercible(ctx,index) \
 	duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_BOOLEAN | \
 	                                    DUK_TYPE_MASK_NUMBER | \
@@ -2928,17 +3134,17 @@ duk_bool_t duk_is_primitive(duk_context *ctx, duk_idx_t index);
  *  are not included.
  */
 
-duk_bool_t duk_get_boolean(duk_context *ctx, duk_idx_t index);
-duk_double_t duk_get_number(duk_context *ctx, duk_idx_t index);
-duk_int_t duk_get_int(duk_context *ctx, duk_idx_t index);
-duk_uint_t duk_get_uint(duk_context *ctx, duk_idx_t index);
-const char *duk_get_string(duk_context *ctx, duk_idx_t index);
-const char *duk_get_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len);
-void *duk_get_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);
-void *duk_get_pointer(duk_context *ctx, duk_idx_t index);
-duk_c_function duk_get_c_function(duk_context *ctx, duk_idx_t index);
-duk_context *duk_get_context(duk_context *ctx, duk_idx_t index);
-duk_size_t duk_get_length(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_get_boolean(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_double_t duk_get_number(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_int_t duk_get_int(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_uint_t duk_get_uint(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL const char *duk_get_string(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL const char *duk_get_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len);
+DUK_EXTERNAL_DECL void *duk_get_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);
+DUK_EXTERNAL_DECL void *duk_get_pointer(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_c_function duk_get_c_function(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_context *duk_get_context(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_size_t duk_get_length(duk_context *ctx, duk_idx_t index);
 
 /*
  *  Require operations: no coercion, throw error if index or type
@@ -2948,18 +3154,18 @@ duk_size_t duk_get_length(duk_context *ctx, duk_idx_t index);
 #define duk_require_type_mask(ctx,index,mask) \
 	((void) duk_check_type_mask((ctx), (index), (mask) | DUK_TYPE_MASK_THROW))
 
-void duk_require_undefined(duk_context *ctx, duk_idx_t index);
-void duk_require_null(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_require_boolean(duk_context *ctx, duk_idx_t index);
-duk_double_t duk_require_number(duk_context *ctx, duk_idx_t index);
-duk_int_t duk_require_int(duk_context *ctx, duk_idx_t index);
-duk_uint_t duk_require_uint(duk_context *ctx, duk_idx_t index);
-const char *duk_require_string(duk_context *ctx, duk_idx_t index);
-const char *duk_require_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len);
-void *duk_require_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);
-void *duk_require_pointer(duk_context *ctx, duk_idx_t index);
-duk_c_function duk_require_c_function(duk_context *ctx, duk_idx_t index);
-duk_context *duk_require_context(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL void duk_require_undefined(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL void duk_require_null(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_require_boolean(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_double_t duk_require_number(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_int_t duk_require_int(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_uint_t duk_require_uint(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL const char *duk_require_string(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL const char *duk_require_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len);
+DUK_EXTERNAL_DECL void *duk_require_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);
+DUK_EXTERNAL_DECL void *duk_require_pointer(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_c_function duk_require_c_function(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_context *duk_require_context(duk_context *ctx, duk_idx_t index);
 
 #define duk_require_object_coercible(ctx,index) \
 	((void) duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_BOOLEAN | \
@@ -2977,27 +3183,27 @@ duk_context *duk_require_context(duk_context *ctx, duk_idx_t index);
  *  or an internal error (e.g. from out of memory).
  */
 
-void duk_to_undefined(duk_context *ctx, duk_idx_t index);
-void duk_to_null(duk_context *ctx, duk_idx_t index);
-duk_bool_t duk_to_boolean(duk_context *ctx, duk_idx_t index);
-duk_double_t duk_to_number(duk_context *ctx, duk_idx_t index);
-duk_int_t duk_to_int(duk_context *ctx, duk_idx_t index);
-duk_uint_t duk_to_uint(duk_context *ctx, duk_idx_t index);
-duk_int32_t duk_to_int32(duk_context *ctx, duk_idx_t index);
-duk_uint32_t duk_to_uint32(duk_context *ctx, duk_idx_t index);
-duk_uint16_t duk_to_uint16(duk_context *ctx, duk_idx_t index);
-const char *duk_to_string(duk_context *ctx, duk_idx_t index);
-const char *duk_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len);
-void *duk_to_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);
-void *duk_to_fixed_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);
-void *duk_to_dynamic_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);
-void *duk_to_pointer(duk_context *ctx, duk_idx_t index);
-void duk_to_object(duk_context *ctx, duk_idx_t index);
-void duk_to_defaultvalue(duk_context *ctx, duk_idx_t index, duk_int_t hint);  /* FIXME: small int? */
-void duk_to_primitive(duk_context *ctx, duk_idx_t index, duk_int_t hint);  /* FIXME: small int? */
+DUK_EXTERNAL_DECL void duk_to_undefined(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL void duk_to_null(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_bool_t duk_to_boolean(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_double_t duk_to_number(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_int_t duk_to_int(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_uint_t duk_to_uint(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_int32_t duk_to_int32(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_uint32_t duk_to_uint32(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_uint16_t duk_to_uint16(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL const char *duk_to_string(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL const char *duk_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len);
+DUK_EXTERNAL_DECL void *duk_to_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);
+DUK_EXTERNAL_DECL void *duk_to_fixed_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);
+DUK_EXTERNAL_DECL void *duk_to_dynamic_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);
+DUK_EXTERNAL_DECL void *duk_to_pointer(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL void duk_to_object(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL void duk_to_defaultvalue(duk_context *ctx, duk_idx_t index, duk_int_t hint);
+DUK_EXTERNAL_DECL void duk_to_primitive(duk_context *ctx, duk_idx_t index, duk_int_t hint);
 
 /* safe variants of a few coercion operations */
-const char *duk_safe_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len);
+DUK_EXTERNAL_DECL const char *duk_safe_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len);
 #define duk_safe_to_string(ctx,index) \
 	duk_safe_to_lstring((ctx), (index), NULL)
 
@@ -3005,18 +3211,18 @@ const char *duk_safe_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *o
  *  Misc conversion
  */
 
-const char *duk_base64_encode(duk_context *ctx, duk_idx_t index);
-void duk_base64_decode(duk_context *ctx, duk_idx_t index);
-const char *duk_hex_encode(duk_context *ctx, duk_idx_t index);
-void duk_hex_decode(duk_context *ctx, duk_idx_t index);
-const char *duk_json_encode(duk_context *ctx, duk_idx_t index);
-void duk_json_decode(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL const char *duk_base64_encode(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL void duk_base64_decode(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL const char *duk_hex_encode(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL void duk_hex_decode(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL const char *duk_json_encode(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL void duk_json_decode(duk_context *ctx, duk_idx_t index);
 
 /*
  *  Buffer
  */
 
-void *duk_resize_buffer(duk_context *ctx, duk_idx_t index, duk_size_t new_size);
+DUK_EXTERNAL_DECL void *duk_resize_buffer(duk_context *ctx, duk_idx_t index, duk_size_t new_size);
 
 /*
  *  Property access
@@ -3026,77 +3232,108 @@ void *duk_resize_buffer(duk_context *ctx, duk_idx_t index, duk_size_t new_size);
  *  index as a property name (e.g. 123 is equivalent to the key "123").
  */
 
-duk_bool_t duk_get_prop(duk_context *ctx, duk_idx_t obj_index);
-duk_bool_t duk_get_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key);
-duk_bool_t duk_get_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index);
-duk_bool_t duk_put_prop(duk_context *ctx, duk_idx_t obj_index);
-duk_bool_t duk_put_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key);
-duk_bool_t duk_put_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index);
-duk_bool_t duk_del_prop(duk_context *ctx, duk_idx_t obj_index);
-duk_bool_t duk_del_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key);
-duk_bool_t duk_del_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index);
-duk_bool_t duk_has_prop(duk_context *ctx, duk_idx_t obj_index);
-duk_bool_t duk_has_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key);
-duk_bool_t duk_has_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index);
+DUK_EXTERNAL_DECL duk_bool_t duk_get_prop(duk_context *ctx, duk_idx_t obj_index);
+DUK_EXTERNAL_DECL duk_bool_t duk_get_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key);
+DUK_EXTERNAL_DECL duk_bool_t duk_get_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index);
+DUK_EXTERNAL_DECL duk_bool_t duk_put_prop(duk_context *ctx, duk_idx_t obj_index);
+DUK_EXTERNAL_DECL duk_bool_t duk_put_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key);
+DUK_EXTERNAL_DECL duk_bool_t duk_put_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index);
+DUK_EXTERNAL_DECL duk_bool_t duk_del_prop(duk_context *ctx, duk_idx_t obj_index);
+DUK_EXTERNAL_DECL duk_bool_t duk_del_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key);
+DUK_EXTERNAL_DECL duk_bool_t duk_del_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index);
+DUK_EXTERNAL_DECL duk_bool_t duk_has_prop(duk_context *ctx, duk_idx_t obj_index);
+DUK_EXTERNAL_DECL duk_bool_t duk_has_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key);
+DUK_EXTERNAL_DECL duk_bool_t duk_has_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index);
 
-duk_bool_t duk_get_global_string(duk_context *ctx, const char *key);
+DUK_EXTERNAL_DECL duk_bool_t duk_get_global_string(duk_context *ctx, const char *key);
+DUK_EXTERNAL_DECL duk_bool_t duk_put_global_string(duk_context *ctx, const char *key);
+
+/*
+ *  Object prototype
+ */
+
+DUK_EXTERNAL_DECL void duk_get_prototype(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL void duk_set_prototype(duk_context *ctx, duk_idx_t index);
+
+/*
+ *  Object finalizer
+ */
+
+DUK_EXTERNAL_DECL void duk_get_finalizer(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL void duk_set_finalizer(duk_context *ctx, duk_idx_t index);
+
+/*
+ *  Global object
+ */
+
+DUK_EXTERNAL_DECL void duk_set_global_object(duk_context *ctx);
+
+/*
+ *  Duktape/C function magic value
+ */
+
+DUK_EXTERNAL_DECL duk_int_t duk_get_magic(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL void duk_set_magic(duk_context *ctx, duk_idx_t index, duk_int_t magic);
+DUK_EXTERNAL_DECL duk_int_t duk_get_current_magic(duk_context *ctx);
 
 /*
  *  Module helpers: put multiple function or constant properties
  */
 
-void duk_put_function_list(duk_context *ctx, duk_idx_t obj_index, const duk_function_list_entry *funcs);
-void duk_put_number_list(duk_context *ctx, duk_idx_t obj_index, const duk_number_list_entry *numbers);
+DUK_EXTERNAL_DECL void duk_put_function_list(duk_context *ctx, duk_idx_t obj_index, const duk_function_list_entry *funcs);
+DUK_EXTERNAL_DECL void duk_put_number_list(duk_context *ctx, duk_idx_t obj_index, const duk_number_list_entry *numbers);
 
 /*
  *  Variable access
  */
 
-/* FIXME: incomplete, not usable now */
-void duk_get_var(duk_context *ctx);
-void duk_put_var(duk_context *ctx);
-duk_bool_t duk_del_var(duk_context *ctx);
-duk_bool_t duk_has_var(duk_context *ctx);
+/* XXX: These calls are incomplete and not usable now.  They are not (yet)
+ * part of the public API.
+ */
+DUK_EXTERNAL_DECL void duk_get_var(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_put_var(duk_context *ctx);
+DUK_EXTERNAL_DECL duk_bool_t duk_del_var(duk_context *ctx);
+DUK_EXTERNAL_DECL duk_bool_t duk_has_var(duk_context *ctx);
 
 /*
  *  Object operations
  */
 
-void duk_compact(duk_context *ctx, duk_idx_t obj_index);
-void duk_enum(duk_context *ctx, duk_idx_t obj_index, duk_uint_t enum_flags);
-duk_bool_t duk_next(duk_context *ctx, duk_idx_t enum_index, duk_bool_t get_value);
+DUK_EXTERNAL_DECL void duk_compact(duk_context *ctx, duk_idx_t obj_index);
+DUK_EXTERNAL_DECL void duk_enum(duk_context *ctx, duk_idx_t obj_index, duk_uint_t enum_flags);
+DUK_EXTERNAL_DECL duk_bool_t duk_next(duk_context *ctx, duk_idx_t enum_index, duk_bool_t get_value);
 
 /*
  *  String manipulation
  */
 
-void duk_concat(duk_context *ctx, duk_idx_t count);
-void duk_join(duk_context *ctx, duk_idx_t count);
-void duk_decode_string(duk_context *ctx, duk_idx_t index, duk_decode_char_function callback, void *udata);
-void duk_map_string(duk_context *ctx, duk_idx_t index, duk_map_char_function callback, void *udata);
-void duk_substring(duk_context *ctx, duk_idx_t index, duk_size_t start_char_offset, duk_size_t end_char_offset);
-void duk_trim(duk_context *ctx, duk_idx_t index);
-duk_codepoint_t duk_char_code_at(duk_context *ctx, duk_idx_t index, duk_size_t char_offset);
+DUK_EXTERNAL_DECL void duk_concat(duk_context *ctx, duk_idx_t count);
+DUK_EXTERNAL_DECL void duk_join(duk_context *ctx, duk_idx_t count);
+DUK_EXTERNAL_DECL void duk_decode_string(duk_context *ctx, duk_idx_t index, duk_decode_char_function callback, void *udata);
+DUK_EXTERNAL_DECL void duk_map_string(duk_context *ctx, duk_idx_t index, duk_map_char_function callback, void *udata);
+DUK_EXTERNAL_DECL void duk_substring(duk_context *ctx, duk_idx_t index, duk_size_t start_char_offset, duk_size_t end_char_offset);
+DUK_EXTERNAL_DECL void duk_trim(duk_context *ctx, duk_idx_t index);
+DUK_EXTERNAL_DECL duk_codepoint_t duk_char_code_at(duk_context *ctx, duk_idx_t index, duk_size_t char_offset);
 
 /*
  *  Ecmascript operators
  */
 
-duk_bool_t duk_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2);
-duk_bool_t duk_strict_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2);
+DUK_EXTERNAL_DECL duk_bool_t duk_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2);
+DUK_EXTERNAL_DECL duk_bool_t duk_strict_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2);
 
 /*
  *  Function (method) calls
  */
 
-void duk_call(duk_context *ctx, duk_idx_t nargs);
-void duk_call_method(duk_context *ctx, duk_idx_t nargs);
-void duk_call_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs);
-duk_int_t duk_pcall(duk_context *ctx, duk_idx_t nargs);
-duk_int_t duk_pcall_method(duk_context *ctx, duk_idx_t nargs);
-duk_int_t duk_pcall_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs);
-void duk_new(duk_context *ctx, duk_idx_t nargs);
-duk_int_t duk_safe_call(duk_context *ctx, duk_safe_call_function func, duk_idx_t nargs, duk_idx_t nrets);
+DUK_EXTERNAL_DECL void duk_call(duk_context *ctx, duk_idx_t nargs);
+DUK_EXTERNAL_DECL void duk_call_method(duk_context *ctx, duk_idx_t nargs);
+DUK_EXTERNAL_DECL void duk_call_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs);
+DUK_EXTERNAL_DECL duk_int_t duk_pcall(duk_context *ctx, duk_idx_t nargs);
+DUK_EXTERNAL_DECL duk_int_t duk_pcall_method(duk_context *ctx, duk_idx_t nargs);
+DUK_EXTERNAL_DECL duk_int_t duk_pcall_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs);
+DUK_EXTERNAL_DECL void duk_new(duk_context *ctx, duk_idx_t nargs);
+DUK_EXTERNAL_DECL duk_int_t duk_safe_call(duk_context *ctx, duk_safe_call_function func, duk_idx_t nargs, duk_idx_t nrets);
 
 /*
  *  Thread management
@@ -3110,8 +3347,8 @@ duk_int_t duk_safe_call(duk_context *ctx, duk_safe_call_function func, duk_idx_t
  *  Compilation and evaluation
  */
 
-duk_int_t duk_eval_raw(duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags);
-duk_int_t duk_compile_raw(duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags);
+DUK_EXTERNAL_DECL duk_int_t duk_eval_raw(duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags);
+DUK_EXTERNAL_DECL duk_int_t duk_compile_raw(duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags);
 
 /* plain */
 #define duk_eval(ctx)  \
@@ -3200,32 +3437,32 @@ duk_int_t duk_compile_raw(duk_context *ctx, const char *src_buffer, duk_size_t s
 
 /* file */
 #define duk_eval_file(ctx,path)  \
-	((void) duk_push_string_file((ctx), (path)), \
+	((void) duk_push_string_file_raw((ctx), (path), 0), \
 	 (void) duk_push_string((ctx), (path)), \
 	 (void) duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL))
 
 #define duk_eval_file_noresult(ctx,path)  \
-	((void) duk_push_string_file((ctx), (path)), \
+	((void) duk_push_string_file_raw((ctx), (path), 0), \
 	 (void) duk_push_string((ctx), (path)), \
 	 (void) duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL | DUK_COMPILE_NORESULT))
 
 #define duk_peval_file(ctx,path)  \
-	((void) duk_push_string_file((ctx), (path)), \
+	((void) duk_push_string_file_raw((ctx), (path), DUK_STRING_PUSH_SAFE), \
 	 (void) duk_push_string((ctx), (path)), \
 	 duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL | DUK_COMPILE_SAFE))
 
 #define duk_peval_file_noresult(ctx,path)  \
-	((void) duk_push_string_file((ctx), (path)), \
+	((void) duk_push_string_file_raw((ctx), (path), DUK_STRING_PUSH_SAFE), \
 	 (void) duk_push_string((ctx), (path)), \
 	 duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NORESULT))
 
 #define duk_compile_file(ctx,flags,path)  \
-	((void) duk_push_string_file((ctx), (path)), \
+	((void) duk_push_string_file_raw((ctx), (path), 0), \
 	 (void) duk_push_string((ctx), (path)), \
 	 (void) duk_compile_raw((ctx), NULL, 0, (flags)))
 
 #define duk_pcompile_file(ctx,flags,path)  \
-	((void) duk_push_string_file((ctx), (path)), \
+	((void) duk_push_string_file_raw((ctx), (path), DUK_STRING_PUSH_SAFE), \
 	 (void) duk_push_string((ctx), (path)), \
 	 duk_compile_raw((ctx), NULL, 0, (flags) | DUK_COMPILE_SAFE))
 
@@ -3233,32 +3470,29 @@ duk_int_t duk_compile_raw(duk_context *ctx, const char *src_buffer, duk_size_t s
  *  Logging
  */
 
-/* FIXME: here a small integer type would be proper */
-void duk_log(duk_context *ctx, duk_int_t level, const char *fmt, ...);
+DUK_EXTERNAL_DECL void duk_log(duk_context *ctx, duk_int_t level, const char *fmt, ...);
 
 /*
  *  Debugging
  */
 
-void duk_push_context_dump(duk_context *ctx);
+DUK_EXTERNAL_DECL void duk_push_context_dump(duk_context *ctx);
 
 #if defined(DUK_USE_FILE_IO)
 /* internal use */
 #define duk_dump_context_filehandle(ctx,fh) \
-	do { \
-		duk_push_context_dump((ctx)); \
-		fprintf(stdout, "%s\n", duk_safe_to_string(ctx, -1)); \
-		duk_pop(ctx); \
-	} while (0)
+	(duk_push_context_dump((ctx)), \
+	 DUK_FPRINTF((fh), "%s\n", duk_safe_to_string(ctx, -1)), \
+	 duk_pop(ctx))
 
 /* external use */
 #define duk_dump_context_stdout(ctx) \
-	duk_dump_context_filehandle(ctx,stdout)
+	duk_dump_context_filehandle((ctx), DUK_STDOUT)
 #define duk_dump_context_stderr(ctx) \
-	duk_dump_context_filehandle(ctx,stderr)
+	duk_dump_context_filehandle((ctx), DUK_STDERR)
 #else  /* DUK_USE_FILE_IO */
-#define duk_dump_context_stdout(ctx)  do {} while (0)
-#define duk_dump_context_stderr(ctx)  do {} while (0)
+#define duk_dump_context_stdout(ctx)  ((void) 0)
+#define duk_dump_context_stderr(ctx)  ((void) 0)
 #endif  /* DUK_USE_FILE_IO */
 
 /*
@@ -3391,7 +3625,7 @@ void duk_push_context_dump(duk_context *ctx);
  *  Indexes of various types (8-bit, 16-bit, 32-bit) in memory relative to
  *  the logical (big endian) order:
  *
- *  byte order      duk_uint8_t    duk_uint16_t     duk_uint32_t    
+ *  byte order      duk_uint8_t    duk_uint16_t     duk_uint32_t
  *    BE             01234567         0123               01
  *    LE             76543210         3210               10
  *    ME (ARM)       32107654         1032               01