hs-duktape 0.1.3 → 0.1.4
raw patch · 4 files changed
+518/−424 lines, 4 files
Files
- duktape/src/duktape.c too large to diff
- duktape/src/duktape.h +513/−419
- hs-duktape.cabal +4/−4
- test-suite/Scripting/DuktapeSpec.hs +1/−1
duktape/src/duktape.c view
file too large to diff
duktape/src/duktape.h view
@@ -1,13 +1,13 @@ /*- * Duktape public API for Duktape 1.5.1.+ * Duktape public API for Duktape 2.0.1. * * 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 2cc76e9ff1f64869e1146ad7317d8cbe33bbd27e (v1.5.1).- * Git branch HEAD.+ * Git commit 3f5e91704aff97c754f6ef5d44aedc5e529d1b16 (v2.0.1).+ * Git branch v2.0-maintenance. * * See Duktape AUTHORS.rst and LICENSE.txt for copyright and * licensing information.@@ -21,7 +21,7 @@ * * (http://opensource.org/licenses/MIT) * - * Copyright (c) 2013-2016 by Duktape authors (see AUTHORS.rst)+ * Copyright (c) 2013-2017 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@@ -75,6 +75,18 @@ * * Ren\u00e9 Hollander <rene@rene8888.at> * * Julien Hamaide (https://github.com/crazyjul) * * Sebastian G\u00f6tte (https://github.com/jaseg)+ * * Tomasz Magulski (https://github.com/magul)+ * * \D. Bohdan (https://github.com/dbohdan)+ * * Ond\u0159ej Jirman (https://github.com/megous)+ * * Sa\u00fal Ibarra Corretg\u00e9 <saghul@gmail.com>+ * * Jeremy HU <huxingyi@msn.com>+ * * Ole Andr\u00e9 Vadla Ravn\u00e5s (https://github.com/oleavr)+ * * Harold Brenes (https://github.com/harold-b)+ * * Oliver Crow (https://github.com/ocrow)+ * * Jakub Ch\u0142api\u0144ski (https://github.com/jchlapinski)+ * * Brett Vickers (https://github.com/beevik)+ * * Dominik Okwieka (https://github.com/okitec)+ * * Remko Tron\u00e7on (https://el-tramo.be) * * Other contributions * ===================@@ -112,13 +124,13 @@ * * Michael Drake (https://github.com/tlsa) * * https://github.com/chris-y * * Laurent Zubiaur (https://github.com/lzubiaur)- * * Ole Andr\u00e9 Vadla Ravn\u00e5s (https://github.com/oleavr)+ * * Neil Kolban (https://github.com/nkolban) * * If you are accidentally missing from this list, send me an e-mail * (``sami.vaarala@iki.fi``) and I'll fix the omission. */ -#ifndef DUKTAPE_H_INCLUDED+#if !defined(DUKTAPE_H_INCLUDED) #define DUKTAPE_H_INCLUDED #define DUK_SINGLE_FILE@@ -133,14 +145,14 @@ * BEGIN PUBLIC API */ -#ifndef DUK_API_PUBLIC_H_INCLUDED+#if !defined(DUK_API_PUBLIC_H_INCLUDED) #define DUK_API_PUBLIC_H_INCLUDED /* * Avoid C++ name mangling */ -#ifdef __cplusplus+#if defined(__cplusplus) extern "C" { #endif @@ -149,7 +161,7 @@ */ #undef DUK_API_VARIADIC_MACROS-#ifdef DUK_USE_VARIADIC_MACROS+#if defined(DUK_USE_VARIADIC_MACROS) #define DUK_API_VARIADIC_MACROS #endif @@ -163,33 +175,45 @@ * in Duktape web documentation. */ +struct duk_thread_state; struct duk_memory_functions; struct duk_function_list_entry; struct duk_number_list_entry;+struct duk_time_components; /* duk_context is now defined in duk_config.h because it may also be * referenced there by prototypes. */+typedef struct duk_thread_state duk_thread_state; typedef struct duk_memory_functions duk_memory_functions; typedef struct duk_function_list_entry duk_function_list_entry; typedef struct duk_number_list_entry duk_number_list_entry;+typedef struct duk_time_components duk_time_components; typedef duk_ret_t (*duk_c_function)(duk_context *ctx); typedef void *(*duk_alloc_function) (void *udata, duk_size_t size); typedef void *(*duk_realloc_function) (void *udata, void *ptr, duk_size_t size); typedef void (*duk_free_function) (void *udata, void *ptr);-typedef void (*duk_fatal_function) (duk_context *ctx, duk_errcode_t code, const char *msg);+typedef void (*duk_fatal_function) (void *udata, const char *msg); typedef void (*duk_decode_char_function) (void *udata, duk_codepoint_t codepoint); typedef duk_codepoint_t (*duk_map_char_function) (void *udata, duk_codepoint_t codepoint);-typedef duk_ret_t (*duk_safe_call_function) (duk_context *ctx);+typedef duk_ret_t (*duk_safe_call_function) (duk_context *ctx, void *udata); typedef duk_size_t (*duk_debug_read_function) (void *udata, char *buffer, duk_size_t length); typedef duk_size_t (*duk_debug_write_function) (void *udata, const char *buffer, duk_size_t length); typedef duk_size_t (*duk_debug_peek_function) (void *udata); typedef void (*duk_debug_read_flush_function) (void *udata); typedef void (*duk_debug_write_flush_function) (void *udata); typedef duk_idx_t (*duk_debug_request_function) (duk_context *ctx, void *udata, duk_idx_t nvalues);-typedef void (*duk_debug_detached_function) (void *udata);+typedef void (*duk_debug_detached_function) (duk_context *ctx, void *udata); +struct duk_thread_state {+ /* XXX: Enough space to hold internal suspend/resume structure.+ * This is rather awkward and to be fixed when the internal+ * structure is visible for the public API header.+ */+ char data[128];+};+ struct duk_memory_functions { duk_alloc_function alloc_func; duk_realloc_function realloc_func;@@ -208,29 +232,40 @@ duk_double_t value; }; +struct duk_time_components {+ duk_double_t year; /* year, e.g. 2016, Ecmascript year range */+ duk_double_t month; /* month: 1-12 */+ duk_double_t day; /* day: 1-31 */+ duk_double_t hours; /* hour: 0-59 */+ duk_double_t minutes; /* minute: 0-59 */+ duk_double_t seconds; /* second: 0-59 (in POSIX time no leap second) */+ duk_double_t milliseconds; /* may contain sub-millisecond fractions */+ duk_double_t weekday; /* weekday: 0-6, 0=Sunday, 1=Monday, ..., 6=Saturday */+};+ /* * Constants */ /* Duktape version, (major * 10000) + (minor * 100) + patch. Allows C code- * to #ifdef against Duktape API version. The same value is also available- * to Ecmascript code in Duktape.version. Unofficial development snapshots- * 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).+ * to #if (DUK_VERSION >= NNN) against Duktape API version. The same value+ * is also available to Ecmascript code in Duktape.version. Unofficial+ * development snapshots 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 10501L+#define DUK_VERSION 20001L /* Git commit, describe, and branch for Duktape build. Useful for * non-official snapshot builds so that application code can easily log * which Duktape snapshot was used. Not available in the Ecmascript * environment. */-#define DUK_GIT_COMMIT "2cc76e9ff1f64869e1146ad7317d8cbe33bbd27e"-#define DUK_GIT_DESCRIBE "v1.5.1"-#define DUK_GIT_BRANCH "HEAD"+#define DUK_GIT_COMMIT "3f5e91704aff97c754f6ef5d44aedc5e529d1b16"+#define DUK_GIT_DESCRIBE "v2.0.1"+#define DUK_GIT_BRANCH "v2.0-maintenance" /* Duktape debug protocol version used by this build. */-#define DUK_DEBUG_PROTOCOL_VERSION 1+#define DUK_DEBUG_PROTOCOL_VERSION 2 /* 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@@ -274,6 +309,7 @@ #define DUK_TYPE_MASK_POINTER (1 << DUK_TYPE_POINTER) #define DUK_TYPE_MASK_LIGHTFUNC (1 << DUK_TYPE_LIGHTFUNC) #define DUK_TYPE_MASK_THROW (1 << 10) /* internal flag value: throw if mask doesn't match */+#define DUK_TYPE_MASK_PROMOTE (1 << 11) /* internal flag value: promote to object if mask matches */ /* Coercion hints */ #define DUK_HINT_NONE 0 /* prefer number, unless input is a Date, in which@@ -284,16 +320,16 @@ /* Enumeration flags for duk_enum() */ #define DUK_ENUM_INCLUDE_NONENUMERABLE (1 << 0) /* enumerate non-numerable properties in addition to enumerable */-#define DUK_ENUM_INCLUDE_INTERNAL (1 << 1) /* enumerate internal properties (regardless of enumerability) */-#define DUK_ENUM_OWN_PROPERTIES_ONLY (1 << 2) /* don't walk prototype chain, only check own properties */-#define DUK_ENUM_ARRAY_INDICES_ONLY (1 << 3) /* only enumerate array indices */-#define DUK_ENUM_SORT_ARRAY_INDICES (1 << 4) /* sort array indices, use with DUK_ENUM_ARRAY_INDICES_ONLY */-#define DUK_ENUM_NO_PROXY_BEHAVIOR (1 << 5) /* enumerate a proxy object itself without invoking proxy behavior */+#define DUK_ENUM_INCLUDE_HIDDEN (1 << 1) /* enumerate hidden symbols too (in Duktape 1.x called internal properties) */+#define DUK_ENUM_INCLUDE_SYMBOLS (1 << 2) /* enumerate symbols */+#define DUK_ENUM_EXCLUDE_STRINGS (1 << 3) /* exclude strings */+#define DUK_ENUM_OWN_PROPERTIES_ONLY (1 << 4) /* don't walk prototype chain, only check own properties */+#define DUK_ENUM_ARRAY_INDICES_ONLY (1 << 5) /* only enumerate array indices */+#define DUK_ENUM_SORT_ARRAY_INDICES (1 << 6) /* sort array indices (applied to full enumeration result, including inherited array indices) */+#define DUK_ENUM_NO_PROXY_BEHAVIOR (1 << 7) /* enumerate a proxy object itself without invoking proxy behavior */ /* Compilation flags for duk_compile() and duk_eval() */-/* DUK_COMPILE_xxx bits 0-2 are reserved for an internal 'nargs' argument- * (the nargs value passed is direct stack arguments + 1 to account for an- * internal extra argument).+/* DUK_COMPILE_xxx bits 0-2 are reserved for an internal 'nargs' argument. */ #define DUK_COMPILE_EVAL (1 << 3) /* compile eval code (instead of global code) */ #define DUK_COMPILE_FUNCTION (1 << 4) /* compile function code (instead of global code) */@@ -325,36 +361,20 @@ /* 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 */+/* Flags for duk_gc() */+#define DUK_GC_COMPACT (1 << 0) /* compact heap objects */ -/* Duktape specific error codes (must be 8 bits at most, see duk_error.h) */+/* Error codes (must be 8 bits at most, see duk_error.h) */ #define DUK_ERR_NONE 0 /* no error (e.g. from duk_get_error_code()) */-#define DUK_ERR_UNIMPLEMENTED_ERROR 50 /* UnimplementedError */ /* XXX: replace with TypeError? */-#define DUK_ERR_UNSUPPORTED_ERROR 51 /* UnsupportedError */ /* XXX: replace with TypeError? */-#define DUK_ERR_INTERNAL_ERROR 52 /* InternalError */ /* XXX: replace with plain Error? */-#define DUK_ERR_ALLOC_ERROR 53 /* AllocError */ /* XXX: replace with RangeError? */-#define DUK_ERR_ASSERTION_ERROR 54 /* AssertionError */ /* XXX: to be removed? */-#define DUK_ERR_API_ERROR 55 /* APIError */ /* XXX: replace with TypeError? */-#define DUK_ERR_UNCAUGHT_ERROR 56 /* UncaughtError */ /* XXX: to be removed? */--/* Ecmascript E5 specification error codes */-#define DUK_ERR_ERROR 100 /* Error */-#define DUK_ERR_EVAL_ERROR 101 /* EvalError */-#define DUK_ERR_RANGE_ERROR 102 /* RangeError */-#define DUK_ERR_REFERENCE_ERROR 103 /* ReferenceError */-#define DUK_ERR_SYNTAX_ERROR 104 /* SyntaxError */-#define DUK_ERR_TYPE_ERROR 105 /* TypeError */-#define DUK_ERR_URI_ERROR 106 /* URIError */+#define DUK_ERR_ERROR 1 /* Error */+#define DUK_ERR_EVAL_ERROR 2 /* EvalError */+#define DUK_ERR_RANGE_ERROR 3 /* RangeError */+#define DUK_ERR_REFERENCE_ERROR 4 /* ReferenceError */+#define DUK_ERR_SYNTAX_ERROR 5 /* SyntaxError */+#define DUK_ERR_TYPE_ERROR 6 /* TypeError */+#define DUK_ERR_URI_ERROR 7 /* URIError */ /* Return codes for C functions (shortcut for throwing an error) */-#define DUK_RET_UNIMPLEMENTED_ERROR (-DUK_ERR_UNIMPLEMENTED_ERROR)-#define DUK_RET_UNSUPPORTED_ERROR (-DUK_ERR_UNSUPPORTED_ERROR)-#define DUK_RET_INTERNAL_ERROR (-DUK_ERR_INTERNAL_ERROR)-#define DUK_RET_ALLOC_ERROR (-DUK_ERR_ALLOC_ERROR)-#define DUK_RET_ASSERTION_ERROR (-DUK_ERR_ASSERTION_ERROR)-#define DUK_RET_API_ERROR (-DUK_ERR_API_ERROR)-#define DUK_RET_UNCAUGHT_ERROR (-DUK_ERR_UNCAUGHT_ERROR) #define DUK_RET_ERROR (-DUK_ERR_ERROR) #define DUK_RET_EVAL_ERROR (-DUK_ERR_EVAL_ERROR) #define DUK_RET_RANGE_ERROR (-DUK_ERR_RANGE_ERROR)@@ -367,20 +387,17 @@ #define DUK_EXEC_SUCCESS 0 #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+/* Debug levels for DUK_USE_DEBUG_WRITE(). */+#define DUK_LEVEL_DEBUG 0+#define DUK_LEVEL_DDEBUG 1+#define DUK_LEVEL_DDDEBUG 2 /* * If no variadic macros, __FILE__ and __LINE__ are passed through globals * which is ugly and not thread safe. */ -#ifndef DUK_API_VARIADIC_MACROS+#if !defined(DUK_API_VARIADIC_MACROS) DUK_EXTERNAL_DECL const char *duk_api_global_filename; DUK_EXTERNAL_DECL duk_int_t duk_api_global_line; #endif@@ -397,6 +414,9 @@ duk_fatal_function fatal_handler); DUK_EXTERNAL_DECL void duk_destroy_heap(duk_context *ctx); +DUK_EXTERNAL_DECL void duk_suspend(duk_context *ctx, duk_thread_state *state);+DUK_EXTERNAL_DECL void duk_resume(duk_context *ctx, const duk_thread_state *state);+ #define duk_create_heap_default() \ duk_create_heap(NULL, NULL, NULL, NULL, NULL) @@ -419,29 +439,99 @@ * Error handling */ -DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_throw(duk_context *ctx));-DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_fatal(duk_context *ctx, duk_errcode_t err_code, const char *err_msg));+DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_throw_raw(duk_context *ctx));+#define duk_throw(ctx) \+ (duk_throw_raw((ctx)), (duk_ret_t) 0)+DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_fatal_raw(duk_context *ctx, const char *err_msg));+#define duk_fatal(ctx,err_msg) \+ (duk_fatal_raw((ctx), (err_msg)), (duk_ret_t) 0) +#if defined(DUK_API_VARIADIC_MACROS) 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), (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), __VA_ARGS__)-#else-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.+ (duk_error_raw((ctx), (duk_errcode_t) (err_code), (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), __VA_ARGS__), (duk_ret_t) 0)+#define duk_generic_error(ctx,...) \+ (duk_error_raw((ctx), (duk_errcode_t) DUK_ERR_ERROR, (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), __VA_ARGS__), (duk_ret_t) 0)+#define duk_eval_error(ctx,...) \+ (duk_error_raw((ctx), (duk_errcode_t) DUK_ERR_EVAL_ERROR, (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), __VA_ARGS__), (duk_ret_t) 0)+#define duk_range_error(ctx,...) \+ (duk_error_raw((ctx), (duk_errcode_t) DUK_ERR_RANGE_ERROR, (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), __VA_ARGS__), (duk_ret_t) 0)+#define duk_reference_error(ctx,...) \+ (duk_error_raw((ctx), (duk_errcode_t) DUK_ERR_REFERENCE_ERROR, (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), __VA_ARGS__), (duk_ret_t) 0)+#define duk_syntax_error(ctx,...) \+ (duk_error_raw((ctx), (duk_errcode_t) DUK_ERR_SYNTAX_ERROR, (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), __VA_ARGS__), (duk_ret_t) 0)+#define duk_type_error(ctx,...) \+ (duk_error_raw((ctx), (duk_errcode_t) DUK_ERR_TYPE_ERROR, (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), __VA_ARGS__), (duk_ret_t) 0)+#define duk_uri_error(ctx,...) \+ (duk_error_raw((ctx), (duk_errcode_t) DUK_ERR_URI_ERROR, (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), __VA_ARGS__), (duk_ret_t) 0)+#else /* DUK_API_VARIADIC_MACROS */+/* For legacy compilers without variadic macros a macro hack is used to allow+ * variable arguments. While the macro allows "return duk_error(...)", it+ * will fail with e.g. "(void) duk_error(...)". The calls are noreturn but+ * with a return value to allow the "return duk_error(...)" idiom. This may+ * cause some compiler warnings, but without noreturn the generated code is+ * often worse. The same approach as with variadic macros (using+ * "(duk_error(...), 0)") won't work due to the macro hack structure. */+DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_error_stash(duk_context *ctx, duk_errcode_t err_code, const char *fmt, ...));+DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_generic_error_stash(duk_context *ctx, const char *fmt, ...));+DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_eval_error_stash(duk_context *ctx, const char *fmt, ...));+DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_range_error_stash(duk_context *ctx, const char *fmt, ...));+DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_reference_error_stash(duk_context *ctx, const char *fmt, ...));+DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_syntax_error_stash(duk_context *ctx, const char *fmt, ...));+DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_type_error_stash(duk_context *ctx, const char *fmt, ...));+DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_uri_error_stash(duk_context *ctx, const char *fmt, ...)); #define duk_error \ (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \ duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \ duk_error_stash) /* last value is func pointer, arguments follow in parens */-#endif+#define duk_generic_error \+ (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \+ duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \+ duk_generic_error_stash)+#define duk_eval_error \+ (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \+ duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \+ duk_eval_error_stash)+#define duk_range_error \+ (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \+ duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \+ duk_range_error_stash)+#define duk_reference_error \+ (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \+ duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \+ duk_reference_error_stash)+#define duk_syntax_error \+ (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \+ duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \+ duk_syntax_error_stash)+#define duk_type_error \+ (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \+ duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \+ duk_type_error_stash)+#define duk_uri_error \+ (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \+ duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \+ duk_uri_error_stash)+#endif /* DUK_API_VARIADIC_MACROS */ DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_error_va_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, va_list ap)); #define duk_error_va(ctx,err_code,fmt,ap) \- duk_error_va_raw((ctx), (duk_errcode_t) (err_code), (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), (fmt), (ap))+ (duk_error_va_raw((ctx), (duk_errcode_t) (err_code), (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), (fmt), (ap)), (duk_ret_t) 0)+#define duk_generic_error_va(ctx,fmt,ap) \+ (duk_error_va_raw((ctx), (duk_errcode_t) DUK_ERR_ERROR, (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), (fmt), (ap)), (duk_ret_t) 0)+#define duk_eval_error_va(ctx,fmt,ap) \+ (duk_error_va_raw((ctx), (duk_errcode_t) DUK_ERR_EVAL_ERROR, (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), (fmt), (ap)), (duk_ret_t) 0)+#define duk_range_error_va(ctx,fmt,ap) \+ (duk_error_va_raw((ctx), (duk_errcode_t) DUK_ERR_RANGE_ERROR, (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), (fmt), (ap)), (duk_ret_t) 0)+#define duk_reference_error_va(ctx,fmt,ap) \+ (duk_error_va_raw((ctx), (duk_errcode_t) DUK_ERR_REFERENCE_ERROR, (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), (fmt), (ap)), (duk_ret_t) 0)+#define duk_syntax_error_va(ctx,fmt,ap) \+ (duk_error_va_raw((ctx), (duk_errcode_t) DUK_ERR_SYNTAX_ERROR, (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), (fmt), (ap)), (duk_ret_t) 0)+#define duk_type_error_va(ctx,fmt,ap) \+ (duk_error_va_raw((ctx), (duk_errcode_t) DUK_ERR_TYPE_ERROR, (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), (fmt), (ap)), (duk_ret_t) 0)+#define duk_uri_error_va(ctx,fmt,ap) \+ (duk_error_va_raw((ctx), (duk_errcode_t) DUK_ERR_URI_ERROR, (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), (fmt), (ap)), (duk_ret_t) 0) /* * Other state related functions@@ -454,13 +544,13 @@ * Stack management */ -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_EXTERNAL_DECL duk_idx_t duk_normalize_index(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_idx_t duk_require_normalize_index(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_is_valid_index(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL void duk_require_valid_index(duk_context *ctx, duk_idx_t idx); 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 void duk_set_top(duk_context *ctx, duk_idx_t idx); 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); @@ -480,14 +570,14 @@ * Stack manipulation (other than push/pop) */ -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_swap(duk_context *ctx, duk_idx_t idx1, duk_idx_t idx2);+DUK_EXTERNAL_DECL void duk_swap_top(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL void duk_dup(duk_context *ctx, duk_idx_t from_idx); 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_insert(duk_context *ctx, duk_idx_t to_idx);+DUK_EXTERNAL_DECL void duk_replace(duk_context *ctx, duk_idx_t to_idx);+DUK_EXTERNAL_DECL void duk_copy(duk_context *ctx, duk_idx_t from_idx, duk_idx_t to_idx);+DUK_EXTERNAL_DECL void duk_remove(duk_context *ctx, duk_idx_t idx); 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) \@@ -519,10 +609,6 @@ 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);@@ -532,6 +618,7 @@ 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_bare_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_c_lightfunc(duk_context *ctx, duk_c_function func, duk_idx_t nargs, duk_idx_t length, duk_int_t magic);@@ -545,7 +632,7 @@ 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+#if defined(DUK_API_VARIADIC_MACROS) #define duk_push_error_object(ctx,err_code,...) \ duk_push_error_object_raw((ctx), (err_code), (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), __VA_ARGS__) #else@@ -577,19 +664,18 @@ ((void) duk_push_buffer_raw((ctx), 0, DUK_BUF_FLAG_DYNAMIC | DUK_BUF_FLAG_EXTERNAL)) #define DUK_BUFOBJ_CREATE_ARRBUF (1 << 4) /* internal flag: create backing ArrayBuffer; keep in one byte */-#define DUK_BUFOBJ_DUKTAPE_BUFFER 0-#define DUK_BUFOBJ_NODEJS_BUFFER 1-#define DUK_BUFOBJ_ARRAYBUFFER 2-#define DUK_BUFOBJ_DATAVIEW (3 | DUK_BUFOBJ_CREATE_ARRBUF)-#define DUK_BUFOBJ_INT8ARRAY (4 | DUK_BUFOBJ_CREATE_ARRBUF)-#define DUK_BUFOBJ_UINT8ARRAY (5 | DUK_BUFOBJ_CREATE_ARRBUF)-#define DUK_BUFOBJ_UINT8CLAMPEDARRAY (6 | DUK_BUFOBJ_CREATE_ARRBUF)-#define DUK_BUFOBJ_INT16ARRAY (7 | DUK_BUFOBJ_CREATE_ARRBUF)-#define DUK_BUFOBJ_UINT16ARRAY (8 | DUK_BUFOBJ_CREATE_ARRBUF)-#define DUK_BUFOBJ_INT32ARRAY (9 | DUK_BUFOBJ_CREATE_ARRBUF)-#define DUK_BUFOBJ_UINT32ARRAY (10 | DUK_BUFOBJ_CREATE_ARRBUF)-#define DUK_BUFOBJ_FLOAT32ARRAY (11 | DUK_BUFOBJ_CREATE_ARRBUF)-#define DUK_BUFOBJ_FLOAT64ARRAY (12 | DUK_BUFOBJ_CREATE_ARRBUF)+#define DUK_BUFOBJ_ARRAYBUFFER 0+#define DUK_BUFOBJ_NODEJS_BUFFER (1 | DUK_BUFOBJ_CREATE_ARRBUF)+#define DUK_BUFOBJ_DATAVIEW (2 | DUK_BUFOBJ_CREATE_ARRBUF)+#define DUK_BUFOBJ_INT8ARRAY (3 | DUK_BUFOBJ_CREATE_ARRBUF)+#define DUK_BUFOBJ_UINT8ARRAY (4 | DUK_BUFOBJ_CREATE_ARRBUF)+#define DUK_BUFOBJ_UINT8CLAMPEDARRAY (5 | DUK_BUFOBJ_CREATE_ARRBUF)+#define DUK_BUFOBJ_INT16ARRAY (6 | DUK_BUFOBJ_CREATE_ARRBUF)+#define DUK_BUFOBJ_UINT16ARRAY (7 | DUK_BUFOBJ_CREATE_ARRBUF)+#define DUK_BUFOBJ_INT32ARRAY (8 | DUK_BUFOBJ_CREATE_ARRBUF)+#define DUK_BUFOBJ_UINT32ARRAY (9 | DUK_BUFOBJ_CREATE_ARRBUF)+#define DUK_BUFOBJ_FLOAT32ARRAY (10 | DUK_BUFOBJ_CREATE_ARRBUF)+#define DUK_BUFOBJ_FLOAT64ARRAY (11 | DUK_BUFOBJ_CREATE_ARRBUF) DUK_EXTERNAL_DECL void duk_push_buffer_object(duk_context *ctx, duk_idx_t idx_buffer, duk_size_t byte_offset, duk_size_t byte_length, duk_uint_t flags); @@ -611,71 +697,78 @@ * is not needed; duk_is_valid_index() gives the same information. */ -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_int_t duk_get_type(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_check_type(duk_context *ctx, duk_idx_t idx, duk_int_t type);+DUK_EXTERNAL_DECL duk_uint_t duk_get_type_mask(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_check_type_mask(duk_context *ctx, duk_idx_t idx, 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_lightfunc(duk_context *ctx, duk_idx_t index);+DUK_EXTERNAL_DECL duk_bool_t duk_is_undefined(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_is_null(duk_context *ctx, duk_idx_t idx);+#define duk_is_null_or_undefined(ctx, idx) \+ ((duk_get_type_mask((ctx), (idx)) & (DUK_TYPE_MASK_NULL | DUK_TYPE_MASK_UNDEFINED)) ? 1 : 0) -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_boolean(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_is_number(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_is_nan(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_is_string(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_is_object(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_is_buffer(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_is_buffer_data(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_is_pointer(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_is_lightfunc(duk_context *ctx, duk_idx_t idx); -#define duk_is_callable(ctx,index) \- duk_is_function((ctx), (index))-DUK_EXTERNAL_DECL duk_bool_t duk_is_dynamic_buffer(duk_context *ctx, duk_idx_t index);-DUK_EXTERNAL_DECL duk_bool_t duk_is_fixed_buffer(duk_context *ctx, duk_idx_t index);-DUK_EXTERNAL_DECL duk_bool_t duk_is_external_buffer(duk_context *ctx, duk_idx_t index);+DUK_EXTERNAL_DECL duk_bool_t duk_is_symbol(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_is_array(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_is_function(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_is_c_function(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_is_ecmascript_function(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_is_bound_function(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_is_thread(duk_context *ctx, duk_idx_t idx); -#define duk_is_primitive(ctx,index) \- duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_UNDEFINED | \- DUK_TYPE_MASK_NULL | \- DUK_TYPE_MASK_BOOLEAN | \- DUK_TYPE_MASK_NUMBER | \- DUK_TYPE_MASK_STRING | \- DUK_TYPE_MASK_BUFFER | \- DUK_TYPE_MASK_POINTER | \- DUK_TYPE_MASK_LIGHTFUNC)+#define duk_is_callable(ctx,idx) \+ duk_is_function((ctx), (idx))+DUK_EXTERNAL_DECL duk_bool_t duk_is_dynamic_buffer(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_is_fixed_buffer(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_is_external_buffer(duk_context *ctx, duk_idx_t idx); -#define duk_is_object_coercible(ctx,index) \- duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_BOOLEAN | \- DUK_TYPE_MASK_NUMBER | \- DUK_TYPE_MASK_STRING | \- DUK_TYPE_MASK_OBJECT | \- DUK_TYPE_MASK_BUFFER | \- DUK_TYPE_MASK_POINTER | \- DUK_TYPE_MASK_LIGHTFUNC)+/* Buffers and lightfuncs are not considered primitive because they mimic+ * objects and e.g. duk_to_primitive() will coerce them instead of returning+ * them as is. Symbols are represented as strings internally.+ */+#define duk_is_primitive(ctx,idx) \+ duk_check_type_mask((ctx), (idx), DUK_TYPE_MASK_UNDEFINED | \+ DUK_TYPE_MASK_NULL | \+ DUK_TYPE_MASK_BOOLEAN | \+ DUK_TYPE_MASK_NUMBER | \+ DUK_TYPE_MASK_STRING | \+ DUK_TYPE_MASK_POINTER) -DUK_EXTERNAL_DECL duk_errcode_t duk_get_error_code(duk_context *ctx, duk_idx_t index);-#define duk_is_error(ctx,index) \- (duk_get_error_code((ctx), (index)) != 0)-#define duk_is_eval_error(ctx,index) \- (duk_get_error_code((ctx), (index)) == DUK_ERR_EVAL_ERROR)-#define duk_is_range_error(ctx,index) \- (duk_get_error_code((ctx), (index)) == DUK_ERR_RANGE_ERROR)-#define duk_is_reference_error(ctx,index) \- (duk_get_error_code((ctx), (index)) == DUK_ERR_REFERENCE_ERROR)-#define duk_is_syntax_error(ctx,index) \- (duk_get_error_code((ctx), (index)) == DUK_ERR_SYNTAX_ERROR)-#define duk_is_type_error(ctx,index) \- (duk_get_error_code((ctx), (index)) == DUK_ERR_TYPE_ERROR)-#define duk_is_uri_error(ctx,index) \- (duk_get_error_code((ctx), (index)) == DUK_ERR_URI_ERROR)+/* Symbols are object coercible, covered by DUK_TYPE_MASK_STRING. */+#define duk_is_object_coercible(ctx,idx) \+ duk_check_type_mask((ctx), (idx), DUK_TYPE_MASK_BOOLEAN | \+ DUK_TYPE_MASK_NUMBER | \+ DUK_TYPE_MASK_STRING | \+ DUK_TYPE_MASK_OBJECT | \+ DUK_TYPE_MASK_BUFFER | \+ DUK_TYPE_MASK_POINTER | \+ DUK_TYPE_MASK_LIGHTFUNC) +DUK_EXTERNAL_DECL duk_errcode_t duk_get_error_code(duk_context *ctx, duk_idx_t idx);+#define duk_is_error(ctx,idx) \+ (duk_get_error_code((ctx), (idx)) != 0)+#define duk_is_eval_error(ctx,idx) \+ (duk_get_error_code((ctx), (idx)) == DUK_ERR_EVAL_ERROR)+#define duk_is_range_error(ctx,idx) \+ (duk_get_error_code((ctx), (idx)) == DUK_ERR_RANGE_ERROR)+#define duk_is_reference_error(ctx,idx) \+ (duk_get_error_code((ctx), (idx)) == DUK_ERR_REFERENCE_ERROR)+#define duk_is_syntax_error(ctx,idx) \+ (duk_get_error_code((ctx), (idx)) == DUK_ERR_SYNTAX_ERROR)+#define duk_is_type_error(ctx,idx) \+ (duk_get_error_code((ctx), (idx)) == DUK_ERR_TYPE_ERROR)+#define duk_is_uri_error(ctx,idx) \+ (duk_get_error_code((ctx), (idx)) == DUK_ERR_URI_ERROR)+ /* * Get operations: no coercion, returns default value for invalid * indices and invalid value types.@@ -684,48 +777,50 @@ * are not included. */ -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_buffer_data(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);-DUK_EXTERNAL_DECL void *duk_get_pointer(duk_context *ctx, duk_idx_t index);-DUK_EXTERNAL_DECL duk_c_function duk_get_c_function(duk_context *ctx, duk_idx_t index);-DUK_EXTERNAL_DECL duk_context *duk_get_context(duk_context *ctx, duk_idx_t index);-DUK_EXTERNAL_DECL void *duk_get_heapptr(duk_context *ctx, duk_idx_t index);-DUK_EXTERNAL_DECL 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 idx);+DUK_EXTERNAL_DECL duk_double_t duk_get_number(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_int_t duk_get_int(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_uint_t duk_get_uint(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL const char *duk_get_string(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL const char *duk_get_lstring(duk_context *ctx, duk_idx_t idx, duk_size_t *out_len);+DUK_EXTERNAL_DECL void *duk_get_buffer(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size);+DUK_EXTERNAL_DECL void *duk_get_buffer_data(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size);+DUK_EXTERNAL_DECL void *duk_get_pointer(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_c_function duk_get_c_function(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_context *duk_get_context(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL void *duk_get_heapptr(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_size_t duk_get_length(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL void duk_set_length(duk_context *ctx, duk_idx_t idx, duk_size_t len); /* * Require operations: no coercion, throw error if index or type * is incorrect. No defaulting. */ -#define duk_require_type_mask(ctx,index,mask) \- ((void) duk_check_type_mask((ctx), (index), (mask) | DUK_TYPE_MASK_THROW))+#define duk_require_type_mask(ctx,idx,mask) \+ ((void) duk_check_type_mask((ctx), (idx), (mask) | DUK_TYPE_MASK_THROW)) -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_buffer_data(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);-DUK_EXTERNAL_DECL void *duk_require_pointer(duk_context *ctx, duk_idx_t index);-DUK_EXTERNAL_DECL duk_c_function duk_require_c_function(duk_context *ctx, duk_idx_t index);-DUK_EXTERNAL_DECL duk_context *duk_require_context(duk_context *ctx, duk_idx_t index);-DUK_EXTERNAL_DECL void duk_require_function(duk_context *ctx, duk_idx_t index);-#define duk_require_callable(ctx,index) \- duk_require_function((ctx), (index))-DUK_EXTERNAL_DECL void *duk_require_heapptr(duk_context *ctx, duk_idx_t index);+DUK_EXTERNAL_DECL void duk_require_undefined(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL void duk_require_null(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_require_boolean(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_double_t duk_require_number(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_int_t duk_require_int(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_uint_t duk_require_uint(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL const char *duk_require_string(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL const char *duk_require_lstring(duk_context *ctx, duk_idx_t idx, duk_size_t *out_len);+DUK_EXTERNAL_DECL void *duk_require_buffer(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size);+DUK_EXTERNAL_DECL void *duk_require_buffer_data(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size);+DUK_EXTERNAL_DECL void *duk_require_pointer(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_c_function duk_require_c_function(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_context *duk_require_context(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL void duk_require_function(duk_context *ctx, duk_idx_t idx);+#define duk_require_callable(ctx,idx) \+ duk_require_function((ctx), (idx))+DUK_EXTERNAL_DECL void *duk_require_heapptr(duk_context *ctx, duk_idx_t idx); -#define duk_require_object_coercible(ctx,index) \- ((void) duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_BOOLEAN | \+/* Symbols are object coercible and covered by DUK_TYPE_MASK_STRING. */+#define duk_require_object_coercible(ctx,idx) \+ ((void) duk_check_type_mask((ctx), (idx), DUK_TYPE_MASK_BOOLEAN | \ DUK_TYPE_MASK_NUMBER | \ DUK_TYPE_MASK_STRING | \ DUK_TYPE_MASK_OBJECT | \@@ -741,57 +836,58 @@ * or an internal error (e.g. from out of memory). */ -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_raw(duk_context *ctx, duk_idx_t index, duk_size_t *out_size, duk_uint_t flags);-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);+DUK_EXTERNAL_DECL void duk_to_undefined(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL void duk_to_null(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_bool_t duk_to_boolean(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_double_t duk_to_number(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_int_t duk_to_int(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_uint_t duk_to_uint(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_int32_t duk_to_int32(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_uint32_t duk_to_uint32(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_uint16_t duk_to_uint16(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL const char *duk_to_string(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL const char *duk_to_lstring(duk_context *ctx, duk_idx_t idx, duk_size_t *out_len);+DUK_EXTERNAL_DECL void *duk_to_buffer_raw(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size, duk_uint_t flags);+DUK_EXTERNAL_DECL void *duk_to_pointer(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL void duk_to_object(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL void duk_to_primitive(duk_context *ctx, duk_idx_t idx, duk_int_t hint); #define DUK_BUF_MODE_FIXED 0 /* internal: request fixed buffer result */ #define DUK_BUF_MODE_DYNAMIC 1 /* internal: request dynamic buffer result */ #define DUK_BUF_MODE_DONTCARE 2 /* internal: don't care about fixed/dynamic nature */ -#define duk_to_buffer(ctx,index,out_size) \- duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_DONTCARE)-#define duk_to_fixed_buffer(ctx,index,out_size) \- duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_FIXED)-#define duk_to_dynamic_buffer(ctx,index,out_size) \- duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_DYNAMIC)+#define duk_to_buffer(ctx,idx,out_size) \+ duk_to_buffer_raw((ctx), (idx), (out_size), DUK_BUF_MODE_DONTCARE)+#define duk_to_fixed_buffer(ctx,idx,out_size) \+ duk_to_buffer_raw((ctx), (idx), (out_size), DUK_BUF_MODE_FIXED)+#define duk_to_dynamic_buffer(ctx,idx,out_size) \+ duk_to_buffer_raw((ctx), (idx), (out_size), DUK_BUF_MODE_DYNAMIC) /* safe variants of a few coercion operations */-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)+DUK_EXTERNAL_DECL const char *duk_safe_to_lstring(duk_context *ctx, duk_idx_t idx, duk_size_t *out_len);+#define duk_safe_to_string(ctx,idx) \+ duk_safe_to_lstring((ctx), (idx), NULL) /* * Misc conversion */ -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);+DUK_EXTERNAL_DECL const char *duk_base64_encode(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL void duk_base64_decode(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL const char *duk_hex_encode(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL void duk_hex_decode(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL const char *duk_json_encode(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL void duk_json_decode(duk_context *ctx, duk_idx_t idx); +DUK_EXTERNAL_DECL const char *duk_buffer_to_string(duk_context *ctx, duk_idx_t idx);+ /* * Buffer */ -DUK_EXTERNAL_DECL void *duk_resize_buffer(duk_context *ctx, duk_idx_t index, duk_size_t new_size);-DUK_EXTERNAL_DECL void *duk_steal_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);-DUK_EXTERNAL_DECL void duk_config_buffer(duk_context *ctx, duk_idx_t index, void *ptr, duk_size_t len);+DUK_EXTERNAL_DECL void *duk_resize_buffer(duk_context *ctx, duk_idx_t idx, duk_size_t new_size);+DUK_EXTERNAL_DECL void *duk_steal_buffer(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size);+DUK_EXTERNAL_DECL void duk_config_buffer(duk_context *ctx, duk_idx_t idx, void *ptr, duk_size_t len); /* * Property access@@ -801,36 +897,51 @@ * index as a property name (e.g. 123 is equivalent to the key "123"). */ -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_EXTERNAL_DECL void duk_def_prop(duk_context *ctx, duk_idx_t obj_index, duk_uint_t flags);+DUK_EXTERNAL_DECL duk_bool_t duk_get_prop(duk_context *ctx, duk_idx_t obj_idx);+DUK_EXTERNAL_DECL duk_bool_t duk_get_prop_string(duk_context *ctx, duk_idx_t obj_idx, const char *key);+DUK_EXTERNAL_DECL duk_bool_t duk_get_prop_lstring(duk_context *ctx, duk_idx_t obj_idx, const char *key, duk_size_t key_len);+DUK_EXTERNAL_DECL duk_bool_t duk_get_prop_index(duk_context *ctx, duk_idx_t obj_idx, duk_uarridx_t arr_idx);+DUK_EXTERNAL_DECL duk_bool_t duk_put_prop(duk_context *ctx, duk_idx_t obj_idx);+DUK_EXTERNAL_DECL duk_bool_t duk_put_prop_string(duk_context *ctx, duk_idx_t obj_idx, const char *key);+DUK_EXTERNAL_DECL duk_bool_t duk_put_prop_lstring(duk_context *ctx, duk_idx_t obj_idx, const char *key, duk_size_t key_len);+DUK_EXTERNAL_DECL duk_bool_t duk_put_prop_index(duk_context *ctx, duk_idx_t obj_idx, duk_uarridx_t arr_idx);+DUK_EXTERNAL_DECL duk_bool_t duk_del_prop(duk_context *ctx, duk_idx_t obj_idx);+DUK_EXTERNAL_DECL duk_bool_t duk_del_prop_string(duk_context *ctx, duk_idx_t obj_idx, const char *key);+DUK_EXTERNAL_DECL duk_bool_t duk_del_prop_lstring(duk_context *ctx, duk_idx_t obj_idx, const char *key, duk_size_t key_len);+DUK_EXTERNAL_DECL duk_bool_t duk_del_prop_index(duk_context *ctx, duk_idx_t obj_idx, duk_uarridx_t arr_idx);+DUK_EXTERNAL_DECL duk_bool_t duk_has_prop(duk_context *ctx, duk_idx_t obj_idx);+DUK_EXTERNAL_DECL duk_bool_t duk_has_prop_string(duk_context *ctx, duk_idx_t obj_idx, const char *key);+DUK_EXTERNAL_DECL duk_bool_t duk_has_prop_lstring(duk_context *ctx, duk_idx_t obj_idx, const char *key, duk_size_t key_len);+DUK_EXTERNAL_DECL duk_bool_t duk_has_prop_index(duk_context *ctx, duk_idx_t obj_idx, duk_uarridx_t arr_idx); +DUK_EXTERNAL_DECL void duk_get_prop_desc(duk_context *ctx, duk_idx_t obj_idx, duk_uint_t flags);+DUK_EXTERNAL_DECL void duk_def_prop(duk_context *ctx, duk_idx_t obj_idx, duk_uint_t flags);+ DUK_EXTERNAL_DECL duk_bool_t duk_get_global_string(duk_context *ctx, const char *key);+DUK_EXTERNAL_DECL duk_bool_t duk_get_global_lstring(duk_context *ctx, const char *key, duk_size_t key_len); DUK_EXTERNAL_DECL duk_bool_t duk_put_global_string(duk_context *ctx, const char *key);+DUK_EXTERNAL_DECL duk_bool_t duk_put_global_lstring(duk_context *ctx, const char *key, duk_size_t key_len); /*+ * Inspection+ */++DUK_EXTERNAL_DECL void duk_inspect_value(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL void duk_inspect_callstack_entry(duk_context *ctx, duk_int_t level);++/* * 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);+DUK_EXTERNAL_DECL void duk_get_prototype(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL void duk_set_prototype(duk_context *ctx, duk_idx_t idx); /* * 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);+DUK_EXTERNAL_DECL void duk_get_finalizer(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL void duk_set_finalizer(duk_context *ctx, duk_idx_t idx); /* * Global object@@ -842,36 +953,24 @@ * 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_magic(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL void duk_set_magic(duk_context *ctx, duk_idx_t idx, 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 */ -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- */--/* 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);+DUK_EXTERNAL_DECL void duk_put_function_list(duk_context *ctx, duk_idx_t obj_idx, const duk_function_list_entry *funcs);+DUK_EXTERNAL_DECL void duk_put_number_list(duk_context *ctx, duk_idx_t obj_idx, const duk_number_list_entry *numbers); /* * Object operations */ -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);+DUK_EXTERNAL_DECL void duk_compact(duk_context *ctx, duk_idx_t obj_idx);+DUK_EXTERNAL_DECL void duk_enum(duk_context *ctx, duk_idx_t obj_idx, duk_uint_t enum_flags);+DUK_EXTERNAL_DECL duk_bool_t duk_next(duk_context *ctx, duk_idx_t enum_idx, duk_bool_t get_value); /* * String manipulation@@ -879,19 +978,20 @@ 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);+DUK_EXTERNAL_DECL void duk_decode_string(duk_context *ctx, duk_idx_t idx, duk_decode_char_function callback, void *udata);+DUK_EXTERNAL_DECL void duk_map_string(duk_context *ctx, duk_idx_t idx, duk_map_char_function callback, void *udata);+DUK_EXTERNAL_DECL void duk_substring(duk_context *ctx, duk_idx_t idx, duk_size_t start_char_offset, duk_size_t end_char_offset);+DUK_EXTERNAL_DECL void duk_trim(duk_context *ctx, duk_idx_t idx);+DUK_EXTERNAL_DECL duk_codepoint_t duk_char_code_at(duk_context *ctx, duk_idx_t idx, duk_size_t char_offset); /* * Ecmascript operators */ -DUK_EXTERNAL_DECL duk_bool_t duk_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2);-DUK_EXTERNAL_DECL duk_bool_t duk_strict_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2);-DUK_EXTERNAL_DECL duk_bool_t duk_instanceof(duk_context *ctx, duk_idx_t index1, duk_idx_t index2);+DUK_EXTERNAL_DECL duk_bool_t duk_equals(duk_context *ctx, duk_idx_t idx1, duk_idx_t idx2);+DUK_EXTERNAL_DECL duk_bool_t duk_strict_equals(duk_context *ctx, duk_idx_t idx1, duk_idx_t idx2);+DUK_EXTERNAL_DECL duk_bool_t duk_samevalue(duk_context *ctx, duk_idx_t idx1, duk_idx_t idx2);+DUK_EXTERNAL_DECL duk_bool_t duk_instanceof(duk_context *ctx, duk_idx_t idx1, duk_idx_t idx2); /* * Function (method) calls@@ -899,13 +999,13 @@ 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 void duk_call_prop(duk_context *ctx, duk_idx_t obj_idx, 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 duk_int_t duk_pcall_prop(duk_context *ctx, duk_idx_t obj_idx, duk_idx_t nargs); DUK_EXTERNAL_DECL void duk_new(duk_context *ctx, duk_idx_t nargs); DUK_EXTERNAL_DECL duk_int_t duk_pnew(duk_context *ctx, duk_idx_t nargs);-DUK_EXTERNAL_DECL duk_int_t duk_safe_call(duk_context *ctx, duk_safe_call_function func, duk_idx_t nargs, duk_idx_t nrets);+DUK_EXTERNAL_DECL duk_int_t duk_safe_call(duk_context *ctx, duk_safe_call_function func, void *udata, duk_idx_t nargs, duk_idx_t nrets); /* * Thread management@@ -924,103 +1024,72 @@ /* plain */ #define duk_eval(ctx) \- ((void) duk_eval_raw((ctx), NULL, 0, 2 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOFILENAME))+ ((void) duk_eval_raw((ctx), NULL, 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOFILENAME)) #define duk_eval_noresult(ctx) \- ((void) duk_eval_raw((ctx), NULL, 0, 2 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))+ ((void) duk_eval_raw((ctx), NULL, 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME)) #define duk_peval(ctx) \- (duk_eval_raw((ctx), NULL, 0, 2 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOFILENAME))+ (duk_eval_raw((ctx), NULL, 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOFILENAME)) #define duk_peval_noresult(ctx) \- (duk_eval_raw((ctx), NULL, 0, 2 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))+ (duk_eval_raw((ctx), NULL, 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME)) #define duk_compile(ctx,flags) \- ((void) duk_compile_raw((ctx), NULL, 0, 3 /*args*/ | (flags)))+ ((void) duk_compile_raw((ctx), NULL, 0, 2 /*args*/ | (flags))) #define duk_pcompile(ctx,flags) \- (duk_compile_raw((ctx), NULL, 0, 3 /*args*/ | (flags) | DUK_COMPILE_SAFE))+ (duk_compile_raw((ctx), NULL, 0, 2 /*args*/ | (flags) | DUK_COMPILE_SAFE)) /* string */ #define duk_eval_string(ctx,src) \- ((void) duk_eval_raw((ctx), (src), 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))+ ((void) duk_eval_raw((ctx), (src), 0, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME)) #define duk_eval_string_noresult(ctx,src) \- ((void) duk_eval_raw((ctx), (src), 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))+ ((void) duk_eval_raw((ctx), (src), 0, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME)) #define duk_peval_string(ctx,src) \- (duk_eval_raw((ctx), (src), 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))+ (duk_eval_raw((ctx), (src), 0, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME)) #define duk_peval_string_noresult(ctx,src) \- (duk_eval_raw((ctx), (src), 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))+ (duk_eval_raw((ctx), (src), 0, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME)) #define duk_compile_string(ctx,flags,src) \- ((void) duk_compile_raw((ctx), (src), 0, 1 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))+ ((void) duk_compile_raw((ctx), (src), 0, 0 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME)) #define duk_compile_string_filename(ctx,flags,src) \- ((void) duk_compile_raw((ctx), (src), 0, 2 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN))+ ((void) duk_compile_raw((ctx), (src), 0, 1 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN)) #define duk_pcompile_string(ctx,flags,src) \- (duk_compile_raw((ctx), (src), 0, 1 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))+ (duk_compile_raw((ctx), (src), 0, 0 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME)) #define duk_pcompile_string_filename(ctx,flags,src) \- (duk_compile_raw((ctx), (src), 0, 2 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN))+ (duk_compile_raw((ctx), (src), 0, 1 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN)) /* lstring */ #define duk_eval_lstring(ctx,buf,len) \- ((void) duk_eval_raw((ctx), buf, len, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NOFILENAME))+ ((void) duk_eval_raw((ctx), buf, len, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NOFILENAME)) #define duk_eval_lstring_noresult(ctx,buf,len) \- ((void) duk_eval_raw((ctx), buf, len, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))+ ((void) duk_eval_raw((ctx), buf, len, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME)) #define duk_peval_lstring(ctx,buf,len) \- (duk_eval_raw((ctx), buf, len, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_SAFE | DUK_COMPILE_NOFILENAME))+ (duk_eval_raw((ctx), buf, len, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_SAFE | DUK_COMPILE_NOFILENAME)) #define duk_peval_lstring_noresult(ctx,buf,len) \- (duk_eval_raw((ctx), buf, len, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))+ (duk_eval_raw((ctx), buf, len, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME)) #define duk_compile_lstring(ctx,flags,buf,len) \- ((void) duk_compile_raw((ctx), buf, len, 1 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NOFILENAME))+ ((void) duk_compile_raw((ctx), buf, len, 0 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NOFILENAME)) #define duk_compile_lstring_filename(ctx,flags,buf,len) \- ((void) duk_compile_raw((ctx), buf, len, 2 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE))+ ((void) duk_compile_raw((ctx), buf, len, 1 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE)) #define duk_pcompile_lstring(ctx,flags,buf,len) \- (duk_compile_raw((ctx), buf, len, 1 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NOFILENAME))+ (duk_compile_raw((ctx), buf, len, 0 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NOFILENAME)) #define duk_pcompile_lstring_filename(ctx,flags,buf,len) \- (duk_compile_raw((ctx), buf, len, 2 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE))--/* file */-#define duk_eval_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, 3 /*args*/ | DUK_COMPILE_EVAL))--#define duk_eval_file_noresult(ctx,path) \- ((void) duk_push_string_file_raw((ctx), (path), 0), \- (void) duk_push_string((ctx), (path)), \- (void) duk_eval_raw((ctx), NULL, 0, 3 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NORESULT))--#define duk_peval_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, 3 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE))--#define duk_peval_file_noresult(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, 3 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NORESULT))--#define duk_compile_file(ctx,flags,path) \- ((void) duk_push_string_file_raw((ctx), (path), 0), \- (void) duk_push_string((ctx), (path)), \- (void) duk_compile_raw((ctx), NULL, 0, 3 /*args*/ | (flags)))--#define duk_pcompile_file(ctx,flags,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, 3 /*args*/ | (flags) | DUK_COMPILE_SAFE))+ (duk_compile_raw((ctx), buf, len, 1 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE)) /* * Bytecode load/dump@@ -1030,58 +1099,38 @@ DUK_EXTERNAL_DECL void duk_load_function(duk_context *ctx); /*- * Logging- */--DUK_EXTERNAL_DECL void duk_log(duk_context *ctx, duk_int_t level, const char *fmt, ...);-DUK_EXTERNAL_DECL void duk_log_va(duk_context *ctx, duk_int_t level, const char *fmt, va_list ap);--/* * Debugging */ 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) \- (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), DUK_STDOUT)-#define duk_dump_context_stderr(ctx) \- duk_dump_context_filehandle((ctx), DUK_STDERR)-#else /* DUK_USE_FILE_IO */-#define duk_dump_context_stdout(ctx) ((void) 0)-#define duk_dump_context_stderr(ctx) ((void) 0)-#endif /* DUK_USE_FILE_IO */- /* * Debugger (debug protocol) */ -#define duk_debugger_attach(ctx,read_cb,write_cb,peek_cb,read_flush_cb,write_flush_cb,detached_cb,udata) \- duk_debugger_attach_custom((ctx), (read_cb), (write_cb), (peek_cb), (read_flush_cb), (write_flush_cb), \- NULL, (detached_cb), (udata))--DUK_EXTERNAL_DECL void duk_debugger_attach_custom(duk_context *ctx,- duk_debug_read_function read_cb,- duk_debug_write_function write_cb,- duk_debug_peek_function peek_cb,- duk_debug_read_flush_function read_flush_cb,- duk_debug_write_flush_function write_flush_cb,- duk_debug_request_function request_cb,- duk_debug_detached_function detached_cb,- void *udata);+DUK_EXTERNAL_DECL void duk_debugger_attach(duk_context *ctx,+ duk_debug_read_function read_cb,+ duk_debug_write_function write_cb,+ duk_debug_peek_function peek_cb,+ duk_debug_read_flush_function read_flush_cb,+ duk_debug_write_flush_function write_flush_cb,+ duk_debug_request_function request_cb,+ duk_debug_detached_function detached_cb,+ void *udata); DUK_EXTERNAL_DECL void duk_debugger_detach(duk_context *ctx); DUK_EXTERNAL_DECL void duk_debugger_cooperate(duk_context *ctx); DUK_EXTERNAL_DECL duk_bool_t duk_debugger_notify(duk_context *ctx, duk_idx_t nvalues); DUK_EXTERNAL_DECL void duk_debugger_pause(duk_context *ctx); /*+ * Time handling+ */++DUK_EXTERNAL_DECL duk_double_t duk_get_now(duk_context *ctx);+DUK_EXTERNAL_DECL void duk_time_to_components(duk_context *ctx, duk_double_t timeval, duk_time_components *comp);+DUK_EXTERNAL_DECL duk_double_t duk_components_to_time(duk_context *ctx, duk_time_components *comp);++/* * Date provider related constants * * NOTE: These are "semi public" - you should only use these if you write@@ -1117,7 +1166,7 @@ * depend on the specific ordering, so change with care. 16 bits are not * enough for all parts (year, specifically). *- * (Must be in-sync with genbuiltins.py.)+ * Must be in-sync with genbuiltins.py. */ #define DUK_DATE_IDX_YEAR 0 /* year */ #define DUK_DATE_IDX_MONTH 1 /* month: 0 to 11 */@@ -1129,7 +1178,7 @@ #define DUK_DATE_IDX_WEEKDAY 7 /* weekday: 0 to 6, 0=sunday, 1=monday, etc */ #define DUK_DATE_IDX_NUM_PARTS 8 -/* Internal API call flags, used for various functions in this file.+/* Internal API call flags, used for various functions in duk_bi_date.c. * Certain flags are used by only certain functions, but since the flags * don't overlap, a single flags value can be passed around to multiple * functions.@@ -1137,7 +1186,7 @@ * The unused top bits of the flags field are also used to pass values * to helpers (duk__get_part_helper() and duk__set_part_helper()). *- * (Must be in-sync with genbuiltins.py.)+ * Must be in-sync with genbuiltins.py. */ /* NOTE: when writing a Date provider you only need a few specific@@ -1174,7 +1223,7 @@ * C++ name mangling */ -#ifdef __cplusplus+#if defined(__cplusplus) /* end 'extern "C"' wrapper */ } #endif@@ -1235,7 +1284,7 @@ * duk_tval values. See: misc/clang_aliasing.c. */ -#ifndef DUK_DBLUNION_H_INCLUDED+#if !defined(DUK_DBLUNION_H_INCLUDED) #define DUK_DBLUNION_H_INCLUDED /*@@ -1263,7 +1312,7 @@ */ #if defined(DUK_USE_DOUBLE_LE)-#ifdef DUK_USE_64BIT_OPS+#if defined(DUK_USE_64BIT_OPS) #define DUK_DBL_IDX_ULL0 0 #endif #define DUK_DBL_IDX_UI0 1@@ -1283,7 +1332,7 @@ #define DUK_DBL_IDX_VP0 DUK_DBL_IDX_UI0 /* packed tval */ #define DUK_DBL_IDX_VP1 DUK_DBL_IDX_UI1 /* packed tval */ #elif defined(DUK_USE_DOUBLE_BE)-#ifdef DUK_USE_64BIT_OPS+#if defined(DUK_USE_64BIT_OPS) #define DUK_DBL_IDX_ULL0 0 #endif #define DUK_DBL_IDX_UI0 0@@ -1303,7 +1352,7 @@ #define DUK_DBL_IDX_VP0 DUK_DBL_IDX_UI0 /* packed tval */ #define DUK_DBL_IDX_VP1 DUK_DBL_IDX_UI1 /* packed tval */ #elif defined(DUK_USE_DOUBLE_ME)-#ifdef DUK_USE_64BIT_OPS+#if defined(DUK_USE_64BIT_OPS) #define DUK_DBL_IDX_ULL0 0 /* not directly applicable, byte order differs from a double */ #endif #define DUK_DBL_IDX_UI0 0@@ -1339,8 +1388,8 @@ (u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) (v); \ } while (0) -#ifdef DUK_USE_64BIT_OPS-#ifdef DUK_USE_DOUBLE_ME+#if defined(DUK_USE_64BIT_OPS)+#if defined(DUK_USE_DOUBLE_ME) #define DUK_DBLUNION_SET_HIGH32_ZERO_LOW32(u,v) do { \ (u)->ull[DUK_DBL_IDX_ULL0] = (duk_uint64_t) (v); \ } while (0)@@ -1364,8 +1413,8 @@ #define DUK_DBLUNION_GET_HIGH32(u) ((u)->ui[DUK_DBL_IDX_UI0]) #define DUK_DBLUNION_GET_LOW32(u) ((u)->ui[DUK_DBL_IDX_UI1]) -#ifdef DUK_USE_64BIT_OPS-#ifdef DUK_USE_DOUBLE_ME+#if defined(DUK_USE_64BIT_OPS)+#if defined(DUK_USE_DOUBLE_ME) #define DUK_DBLUNION_SET_UINT64(u,v) do { \ (u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) ((v) >> 32); \ (u)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (v); \@@ -1405,70 +1454,98 @@ * feature that while doubles have a mixed byte order (32107654), unsigned * long long values has a little endian byte order (76543210). When writing * a logical double value through a ULL pointer, the 32-bit words need to be- * swapped; hence the #ifdefs below for ULL writes with DUK_USE_DOUBLE_ME.+ * swapped; hence the #if defined()s below for ULL writes with DUK_USE_DOUBLE_ME. * This is not full ARM support but suffices for some environments. */ -#ifdef DUK_USE_64BIT_OPS-#ifdef DUK_USE_DOUBLE_ME+#if defined(DUK_USE_64BIT_OPS)+#if defined(DUK_USE_DOUBLE_ME)+/* Macros for 64-bit ops + mixed endian doubles. */ #define DUK__DBLUNION_SET_NAN_FULL(u) do { \ (u)->ull[DUK_DBL_IDX_ULL0] = 0x000000007ff80000ULL; \ } while (0)+#define DUK__DBLUNION_IS_NAN_FULL(u) \+ ((((u)->ull[DUK_DBL_IDX_ULL0] & 0x000000007ff00000ULL) == 0x000000007ff00000ULL) && \+ ((((u)->ull[DUK_DBL_IDX_ULL0]) & 0xffffffff000fffffULL) != 0))+#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0x000000007ff80000ULL)+#define DUK__DBLUNION_IS_ANYINF(u) \+ (((u)->ull[DUK_DBL_IDX_ULL0] & 0xffffffff7fffffffULL) == 0x000000007ff00000ULL)+#define DUK__DBLUNION_IS_POSINF(u) \+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0x000000007ff00000ULL)+#define DUK__DBLUNION_IS_NEGINF(u) \+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0x00000000fff00000ULL)+#define DUK__DBLUNION_IS_ANYZERO(u) \+ (((u)->ull[DUK_DBL_IDX_ULL0] & 0xffffffff7fffffffULL) == 0x0000000000000000ULL)+#define DUK__DBLUNION_IS_POSZERO(u) \+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0x0000000000000000ULL)+#define DUK__DBLUNION_IS_NEGZERO(u) \+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0x0000000080000000ULL) #else+/* Macros for 64-bit ops + big/little endian doubles. */ #define DUK__DBLUNION_SET_NAN_FULL(u) do { \ (u)->ull[DUK_DBL_IDX_ULL0] = 0x7ff8000000000000ULL; \ } while (0)+#define DUK__DBLUNION_IS_NAN_FULL(u) \+ ((((u)->ull[DUK_DBL_IDX_ULL0] & 0x7ff0000000000000ULL) == 0x7ff0000000000000UL) && \+ ((((u)->ull[DUK_DBL_IDX_ULL0]) & 0x000fffffffffffffULL) != 0))+#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0x7ff8000000000000ULL)+#define DUK__DBLUNION_IS_ANYINF(u) \+ (((u)->ull[DUK_DBL_IDX_ULL0] & 0x7fffffffffffffffULL) == 0x7ff0000000000000ULL)+#define DUK__DBLUNION_IS_POSINF(u) \+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0x7ff0000000000000ULL)+#define DUK__DBLUNION_IS_NEGINF(u) \+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0xfff0000000000000ULL)+#define DUK__DBLUNION_IS_ANYZERO(u) \+ (((u)->ull[DUK_DBL_IDX_ULL0] & 0x7fffffffffffffffULL) == 0x0000000000000000ULL)+#define DUK__DBLUNION_IS_POSZERO(u) \+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0x0000000000000000ULL)+#define DUK__DBLUNION_IS_NEGZERO(u) \+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0x8000000000000000ULL) #endif #else /* DUK_USE_64BIT_OPS */+/* Macros for no 64-bit ops, any endianness. */ #define DUK__DBLUNION_SET_NAN_FULL(u) do { \ (u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) 0x7ff80000UL; \ (u)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) 0x00000000UL; \ } while (0)-#endif /* DUK_USE_64BIT_OPS */--#define DUK__DBLUNION_SET_NAN_NOTFULL(u) do { \- (u)->us[DUK_DBL_IDX_US0] = 0x7ff8UL; \- } while (0)--#ifdef DUK_USE_64BIT_OPS-#ifdef DUK_USE_DOUBLE_ME #define DUK__DBLUNION_IS_NAN_FULL(u) \- /* E == 0x7ff, F != 0 => NaN */ \- ((((u)->us[DUK_DBL_IDX_US0] & 0x7ff0UL) == 0x7ff0UL) && \- ((((u)->ull[DUK_DBL_IDX_ULL0]) & 0xffffffff000fffffULL) != 0))-#else-#define DUK__DBLUNION_IS_NAN_FULL(u) \- /* E == 0x7ff, F != 0 => NaN */ \- ((((u)->us[DUK_DBL_IDX_US0] & 0x7ff0UL) == 0x7ff0UL) && \- ((((u)->ull[DUK_DBL_IDX_ULL0]) & 0x000fffffffffffffULL) != 0))-#endif-#else /* DUK_USE_64BIT_OPS */-#define DUK__DBLUNION_IS_NAN_FULL(u) \- /* E == 0x7ff, F != 0 => NaN */ \ ((((u)->ui[DUK_DBL_IDX_UI0] & 0x7ff00000UL) == 0x7ff00000UL) && \ (((u)->ui[DUK_DBL_IDX_UI0] & 0x000fffffUL) != 0 || \ (u)->ui[DUK_DBL_IDX_UI1] != 0))+#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \+ (((u)->ui[DUK_DBL_IDX_UI0] == 0x7ff80000UL) && \+ ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))+#define DUK__DBLUNION_IS_ANYINF(u) \+ ((((u)->ui[DUK_DBL_IDX_UI0] & 0x7fffffffUL) == 0x7ff00000UL) && \+ ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))+#define DUK__DBLUNION_IS_POSINF(u) \+ (((u)->ui[DUK_DBL_IDX_UI0] == 0x7ff00000UL) && \+ ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))+#define DUK__DBLUNION_IS_NEGINF(u) \+ (((u)->ui[DUK_DBL_IDX_UI0] == 0xfff00000UL) && \+ ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))+#define DUK__DBLUNION_IS_ANYZERO(u) \+ ((((u)->ui[DUK_DBL_IDX_UI0] & 0x7fffffffUL) == 0x00000000UL) && \+ ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))+#define DUK__DBLUNION_IS_POSZERO(u) \+ (((u)->ui[DUK_DBL_IDX_UI0] == 0x00000000UL) && \+ ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))+#define DUK__DBLUNION_IS_NEGZERO(u) \+ (((u)->ui[DUK_DBL_IDX_UI0] == 0x80000000UL) && \+ ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL)) #endif /* DUK_USE_64BIT_OPS */ +#define DUK__DBLUNION_SET_NAN_NOTFULL(u) do { \+ (u)->us[DUK_DBL_IDX_US0] = 0x7ff8UL; \+ } while (0)+ #define DUK__DBLUNION_IS_NAN_NOTFULL(u) \ /* E == 0x7ff, topmost four bits of F != 0 => assume NaN */ \ ((((u)->us[DUK_DBL_IDX_US0] & 0x7ff0UL) == 0x7ff0UL) && \ (((u)->us[DUK_DBL_IDX_US0] & 0x000fUL) != 0x0000UL)) -#ifdef DUK_USE_64BIT_OPS-#ifdef DUK_USE_DOUBLE_ME-#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \- ((u)->ull[DUK_DBL_IDX_ULL0] == 0x000000007ff80000ULL)-#else-#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \- ((u)->ull[DUK_DBL_IDX_ULL0] == 0x7ff8000000000000ULL)-#endif-#else /* DUK_USE_64BIT_OPS */-#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \- (((u)->ui[DUK_DBL_IDX_UI0] == 0x7ff80000UL) && \- ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))-#endif /* DUK_USE_64BIT_OPS */- #define DUK__DBLUNION_IS_NORMALIZED_NAN_NOTFULL(u) \ /* E == 0x7ff, F == 8 => normalized NaN */ \ ((u)->us[DUK_DBL_IDX_US0] == 0x7ff8UL)@@ -1508,8 +1585,8 @@ DUK_DBLUNION_IS_NORMALIZED_NAN((u))) /* or is a normalized NaN */ #else /* DUK_USE_PACKED_TVAL */ #define DUK_DBLUNION_NORMALIZE_NAN_CHECK(u) /* nop: no need to normalize */-#define DUK_DBLUNION_IS_NAN(u) (DUK_ISNAN((u)->d))-#define DUK_DBLUNION_IS_NORMALIZED_NAN(u) (DUK_ISNAN((u)->d))+#define DUK_DBLUNION_IS_NAN(u) DUK__DBLUNION_IS_NAN_FULL((u)) /* (DUK_ISNAN((u)->d)) */+#define DUK_DBLUNION_IS_NORMALIZED_NAN(u) DUK__DBLUNION_IS_NAN_FULL((u)) /* (DUK_ISNAN((u)->d)) */ #define DUK_DBLUNION_IS_NORMALIZED(u) 1 /* all doubles are considered normalized */ #define DUK_DBLUNION_SET_NAN(u) do { \ /* in non-packed representation we don't care about which NaN is used */ \@@ -1517,6 +1594,14 @@ } while (0) #endif /* DUK_USE_PACKED_TVAL */ +#define DUK_DBLUNION_IS_ANYINF(u) DUK__DBLUNION_IS_ANYINF((u))+#define DUK_DBLUNION_IS_POSINF(u) DUK__DBLUNION_IS_POSINF((u))+#define DUK_DBLUNION_IS_NEGINF(u) DUK__DBLUNION_IS_NEGINF((u))++#define DUK_DBLUNION_IS_ANYZERO(u) DUK__DBLUNION_IS_ANYZERO((u))+#define DUK_DBLUNION_IS_POSZERO(u) DUK__DBLUNION_IS_POSZERO((u))+#define DUK_DBLUNION_IS_NEGZERO(u) DUK__DBLUNION_IS_NEGZERO((u))+ /* XXX: native 64-bit byteswaps when available */ /* 64-bit byteswap, same operation independent of target endianness. */@@ -1561,6 +1646,15 @@ /* Reverse operation is the same. */ #define DUK_DBLUNION_DOUBLE_NTOH(u) DUK_DBLUNION_DOUBLE_HTON((u))++/* Some sign bit helpers. */+#if defined(DUK_USE_64BIT_OPS)+#define DUK_DBLUNION_HAS_SIGNBIT(u) (((u)->ull[DUK_DBL_IDX_ULL0] & 0x8000000000000000ULL) != 0)+#define DUK_DBLUNION_GET_SIGNBIT(u) (((u)->ull[DUK_DBL_IDX_ULL0] >> 63U))+#else+#define DUK_DBLUNION_HAS_SIGNBIT(u) (((u)->ui[DUK_DBL_IDX_UI0] & 0x80000000UL) != 0)+#define DUK_DBLUNION_GET_SIGNBIT(u) (((u)->ui[DUK_DBL_IDX_UI0] >> 31U))+#endif #endif /* DUK_DBLUNION_H_INCLUDED */
hs-duktape.cabal view
@@ -1,10 +1,10 @@ name: hs-duktape-version: 0.1.3+version: 0.1.4 synopsis: Haskell bindings for a very compact embedded ECMAScript (JavaScript) engine. category: Web homepage: https://github.com/myfreeweb/hs-duktape author: Greg V-copyright: 2015-2016 Greg V <greg@unrelenting.technology>, 2013-2016 Duktape authors+copyright: 2015-2017 Greg V <greg@unrelenting.technology> / 2013-2017 Duktape authors (for Duktape) maintainer: greg@unrelenting.technology license: MIT license-file: LICENSE@@ -15,7 +15,7 @@ duktape/src/duktape.c duktape/src/duktape.h tested-with:- GHC == 8.0.1+ GHC == 8.0.2 source-repository head type: git@@ -40,7 +40,7 @@ c-sources: duktape/src/duktape.c includes: duktape.h install-includes: duktape.h- cc-options: -Wall -pedantic -std=c99 -fstrict-aliasing -fomit-frame-pointer+ cc-options: -Wall -Wno-discarded-qualifiers -std=c99 -fstrict-aliasing -fomit-frame-pointer test-suite tests build-depends:
test-suite/Scripting/DuktapeSpec.hs view
@@ -17,7 +17,7 @@ r0 ← evalDuktape (fromJust ctx) "" r0 `shouldBe` Right Nothing rE ← evalDuktape (fromJust ctx) "print('hello"- rE `shouldBe` Left "SyntaxError: eof or line terminator in string literal (line 1)"+ rE `shouldBe` Left "SyntaxError: unterminated string (line 1)" rT ← evalDuktape (fromJust ctx) "1 == 1" rT `shouldBe` (Right $ Just $ Bool True) rF ← evalDuktape (fromJust ctx) "1 == 2"