duktape 1.6.1.0 → 2.0.1.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (8) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +4 -0
  3. data/ext/duktape/duk_config.h +166 -1094
  4. data/ext/duktape/duktape.c +24025 -19343
  5. data/ext/duktape/duktape.h +509 -428
  6. data/ext/duktape/duktape_ext.c +50 -47
  7. data/lib/duktape/version.rb +1 -1
  8. metadata +3 -3
data/ext/duktape/duktape.h CHANGED
@@ -1,13 +1,13 @@
1
1
  /*
2
- * Duktape public API for Duktape 1.6.1.
2
+ * Duktape public API for Duktape 2.0.1.
3
3
  *
4
4
  * See the API reference for documentation on call semantics.
5
5
  * The exposed API is inside the DUK_API_PUBLIC_H_INCLUDED
6
6
  * include guard. Other parts of the header are Duktape
7
7
  * internal and related to platform/compiler/feature detection.
8
8
  *
9
- * Git commit 34ac011501ccaa8b74684a6c45ed4eaca9e83517 (v1.6.1).
10
- * Git branch v1.6-maintenance.
9
+ * Git commit 3f5e91704aff97c754f6ef5d44aedc5e529d1b16 (v2.0.1).
10
+ * Git branch v2.0-maintenance.
11
11
  *
12
12
  * See Duktape AUTHORS.rst and LICENSE.txt for copyright and
13
13
  * licensing information.
@@ -21,7 +21,7 @@
21
21
  *
22
22
  * (http://opensource.org/licenses/MIT)
23
23
  *
24
- * Copyright (c) 2013-2016 by Duktape authors (see AUTHORS.rst)
24
+ * Copyright (c) 2013-2017 by Duktape authors (see AUTHORS.rst)
25
25
  *
26
26
  * Permission is hereby granted, free of charge, to any person obtaining a copy
27
27
  * of this software and associated documentation files (the "Software"), to deal
@@ -75,6 +75,18 @@
75
75
  * * Ren\u00e9 Hollander <rene@rene8888.at>
76
76
  * * Julien Hamaide (https://github.com/crazyjul)
77
77
  * * Sebastian G\u00f6tte (https://github.com/jaseg)
78
+ * * Tomasz Magulski (https://github.com/magul)
79
+ * * \D. Bohdan (https://github.com/dbohdan)
80
+ * * Ond\u0159ej Jirman (https://github.com/megous)
81
+ * * Sa\u00fal Ibarra Corretg\u00e9 <saghul@gmail.com>
82
+ * * Jeremy HU <huxingyi@msn.com>
83
+ * * Ole Andr\u00e9 Vadla Ravn\u00e5s (https://github.com/oleavr)
84
+ * * Harold Brenes (https://github.com/harold-b)
85
+ * * Oliver Crow (https://github.com/ocrow)
86
+ * * Jakub Ch\u0142api\u0144ski (https://github.com/jchlapinski)
87
+ * * Brett Vickers (https://github.com/beevik)
88
+ * * Dominik Okwieka (https://github.com/okitec)
89
+ * * Remko Tron\u00e7on (https://el-tramo.be)
78
90
  *
79
91
  * Other contributions
80
92
  * ===================
@@ -112,13 +124,13 @@
112
124
  * * Michael Drake (https://github.com/tlsa)
113
125
  * * https://github.com/chris-y
114
126
  * * Laurent Zubiaur (https://github.com/lzubiaur)
115
- * * Ole Andr\u00e9 Vadla Ravn\u00e5s (https://github.com/oleavr)
127
+ * * Neil Kolban (https://github.com/nkolban)
116
128
  *
117
129
  * If you are accidentally missing from this list, send me an e-mail
118
130
  * (``sami.vaarala@iki.fi``) and I'll fix the omission.
119
131
  */
120
132
 
121
- #ifndef DUKTAPE_H_INCLUDED
133
+ #if !defined(DUKTAPE_H_INCLUDED)
122
134
  #define DUKTAPE_H_INCLUDED
123
135
 
124
136
  #define DUK_SINGLE_FILE
@@ -133,14 +145,14 @@
133
145
  * BEGIN PUBLIC API
134
146
  */
135
147
 
136
- #ifndef DUK_API_PUBLIC_H_INCLUDED
148
+ #if !defined(DUK_API_PUBLIC_H_INCLUDED)
137
149
  #define DUK_API_PUBLIC_H_INCLUDED
138
150
 
139
151
  /*
140
152
  * Avoid C++ name mangling
141
153
  */
142
154
 
143
- #ifdef __cplusplus
155
+ #if defined(__cplusplus)
144
156
  extern "C" {
145
157
  #endif
146
158
 
@@ -149,7 +161,7 @@ extern "C" {
149
161
  */
150
162
 
151
163
  #undef DUK_API_VARIADIC_MACROS
152
- #ifdef DUK_USE_VARIADIC_MACROS
164
+ #if defined(DUK_USE_VARIADIC_MACROS)
153
165
  #define DUK_API_VARIADIC_MACROS
154
166
  #endif
155
167
 
@@ -167,6 +179,7 @@ struct duk_thread_state;
167
179
  struct duk_memory_functions;
168
180
  struct duk_function_list_entry;
169
181
  struct duk_number_list_entry;
182
+ struct duk_time_components;
170
183
 
171
184
  /* duk_context is now defined in duk_config.h because it may also be
172
185
  * referenced there by prototypes.
@@ -175,22 +188,23 @@ typedef struct duk_thread_state duk_thread_state;
175
188
  typedef struct duk_memory_functions duk_memory_functions;
176
189
  typedef struct duk_function_list_entry duk_function_list_entry;
177
190
  typedef struct duk_number_list_entry duk_number_list_entry;
191
+ typedef struct duk_time_components duk_time_components;
178
192
 
179
193
  typedef duk_ret_t (*duk_c_function)(duk_context *ctx);
180
194
  typedef void *(*duk_alloc_function) (void *udata, duk_size_t size);
181
195
  typedef void *(*duk_realloc_function) (void *udata, void *ptr, duk_size_t size);
182
196
  typedef void (*duk_free_function) (void *udata, void *ptr);
183
- typedef void (*duk_fatal_function) (duk_context *ctx, duk_errcode_t code, const char *msg);
197
+ typedef void (*duk_fatal_function) (void *udata, const char *msg);
184
198
  typedef void (*duk_decode_char_function) (void *udata, duk_codepoint_t codepoint);
185
199
  typedef duk_codepoint_t (*duk_map_char_function) (void *udata, duk_codepoint_t codepoint);
186
- typedef duk_ret_t (*duk_safe_call_function) (duk_context *ctx);
200
+ typedef duk_ret_t (*duk_safe_call_function) (duk_context *ctx, void *udata);
187
201
  typedef duk_size_t (*duk_debug_read_function) (void *udata, char *buffer, duk_size_t length);
188
202
  typedef duk_size_t (*duk_debug_write_function) (void *udata, const char *buffer, duk_size_t length);
189
203
  typedef duk_size_t (*duk_debug_peek_function) (void *udata);
190
204
  typedef void (*duk_debug_read_flush_function) (void *udata);
191
205
  typedef void (*duk_debug_write_flush_function) (void *udata);
192
206
  typedef duk_idx_t (*duk_debug_request_function) (duk_context *ctx, void *udata, duk_idx_t nvalues);
193
- typedef void (*duk_debug_detached_function) (void *udata);
207
+ typedef void (*duk_debug_detached_function) (duk_context *ctx, void *udata);
194
208
 
195
209
  struct duk_thread_state {
196
210
  /* XXX: Enough space to hold internal suspend/resume structure.
@@ -218,29 +232,40 @@ struct duk_number_list_entry {
218
232
  duk_double_t value;
219
233
  };
220
234
 
235
+ struct duk_time_components {
236
+ duk_double_t year; /* year, e.g. 2016, Ecmascript year range */
237
+ duk_double_t month; /* month: 1-12 */
238
+ duk_double_t day; /* day: 1-31 */
239
+ duk_double_t hours; /* hour: 0-59 */
240
+ duk_double_t minutes; /* minute: 0-59 */
241
+ duk_double_t seconds; /* second: 0-59 (in POSIX time no leap second) */
242
+ duk_double_t milliseconds; /* may contain sub-millisecond fractions */
243
+ duk_double_t weekday; /* weekday: 0-6, 0=Sunday, 1=Monday, ..., 6=Saturday */
244
+ };
245
+
221
246
  /*
222
247
  * Constants
223
248
  */
224
249
 
225
250
  /* Duktape version, (major * 10000) + (minor * 100) + patch. Allows C code
226
- * to #ifdef against Duktape API version. The same value is also available
227
- * to Ecmascript code in Duktape.version. Unofficial development snapshots
228
- * have 99 for patch level (e.g. 0.10.99 would be a development version
229
- * after 0.10.0 but before the next official release).
251
+ * to #if (DUK_VERSION >= NNN) against Duktape API version. The same value
252
+ * is also available to Ecmascript code in Duktape.version. Unofficial
253
+ * development snapshots have 99 for patch level (e.g. 0.10.99 would be a
254
+ * development version after 0.10.0 but before the next official release).
230
255
  */
231
- #define DUK_VERSION 10601L
256
+ #define DUK_VERSION 20001L
232
257
 
233
258
  /* Git commit, describe, and branch for Duktape build. Useful for
234
259
  * non-official snapshot builds so that application code can easily log
235
260
  * which Duktape snapshot was used. Not available in the Ecmascript
236
261
  * environment.
237
262
  */
238
- #define DUK_GIT_COMMIT "34ac011501ccaa8b74684a6c45ed4eaca9e83517"
239
- #define DUK_GIT_DESCRIBE "v1.6.1"
240
- #define DUK_GIT_BRANCH "v1.6-maintenance"
263
+ #define DUK_GIT_COMMIT "3f5e91704aff97c754f6ef5d44aedc5e529d1b16"
264
+ #define DUK_GIT_DESCRIBE "v2.0.1"
265
+ #define DUK_GIT_BRANCH "v2.0-maintenance"
241
266
 
242
267
  /* Duktape debug protocol version used by this build. */
243
- #define DUK_DEBUG_PROTOCOL_VERSION 1
268
+ #define DUK_DEBUG_PROTOCOL_VERSION 2
244
269
 
245
270
  /* Used to represent invalid index; if caller uses this without checking,
246
271
  * this index will map to a non-existent stack entry. Also used in some
@@ -284,6 +309,7 @@ struct duk_number_list_entry {
284
309
  #define DUK_TYPE_MASK_POINTER (1 << DUK_TYPE_POINTER)
285
310
  #define DUK_TYPE_MASK_LIGHTFUNC (1 << DUK_TYPE_LIGHTFUNC)
286
311
  #define DUK_TYPE_MASK_THROW (1 << 10) /* internal flag value: throw if mask doesn't match */
312
+ #define DUK_TYPE_MASK_PROMOTE (1 << 11) /* internal flag value: promote to object if mask matches */
287
313
 
288
314
  /* Coercion hints */
289
315
  #define DUK_HINT_NONE 0 /* prefer number, unless input is a Date, in which
@@ -294,16 +320,16 @@ struct duk_number_list_entry {
294
320
 
295
321
  /* Enumeration flags for duk_enum() */
296
322
  #define DUK_ENUM_INCLUDE_NONENUMERABLE (1 << 0) /* enumerate non-numerable properties in addition to enumerable */
297
- #define DUK_ENUM_INCLUDE_INTERNAL (1 << 1) /* enumerate internal properties (regardless of enumerability) */
298
- #define DUK_ENUM_OWN_PROPERTIES_ONLY (1 << 2) /* don't walk prototype chain, only check own properties */
299
- #define DUK_ENUM_ARRAY_INDICES_ONLY (1 << 3) /* only enumerate array indices */
300
- #define DUK_ENUM_SORT_ARRAY_INDICES (1 << 4) /* sort array indices, use with DUK_ENUM_ARRAY_INDICES_ONLY */
301
- #define DUK_ENUM_NO_PROXY_BEHAVIOR (1 << 5) /* enumerate a proxy object itself without invoking proxy behavior */
323
+ #define DUK_ENUM_INCLUDE_HIDDEN (1 << 1) /* enumerate hidden symbols too (in Duktape 1.x called internal properties) */
324
+ #define DUK_ENUM_INCLUDE_SYMBOLS (1 << 2) /* enumerate symbols */
325
+ #define DUK_ENUM_EXCLUDE_STRINGS (1 << 3) /* exclude strings */
326
+ #define DUK_ENUM_OWN_PROPERTIES_ONLY (1 << 4) /* don't walk prototype chain, only check own properties */
327
+ #define DUK_ENUM_ARRAY_INDICES_ONLY (1 << 5) /* only enumerate array indices */
328
+ #define DUK_ENUM_SORT_ARRAY_INDICES (1 << 6) /* sort array indices (applied to full enumeration result, including inherited array indices) */
329
+ #define DUK_ENUM_NO_PROXY_BEHAVIOR (1 << 7) /* enumerate a proxy object itself without invoking proxy behavior */
302
330
 
303
331
  /* Compilation flags for duk_compile() and duk_eval() */
304
- /* DUK_COMPILE_xxx bits 0-2 are reserved for an internal 'nargs' argument
305
- * (the nargs value passed is direct stack arguments + 1 to account for an
306
- * internal extra argument).
332
+ /* DUK_COMPILE_xxx bits 0-2 are reserved for an internal 'nargs' argument.
307
333
  */
308
334
  #define DUK_COMPILE_EVAL (1 << 3) /* compile eval code (instead of global code) */
309
335
  #define DUK_COMPILE_FUNCTION (1 << 4) /* compile function code (instead of global code) */
@@ -335,36 +361,20 @@ struct duk_number_list_entry {
335
361
  /* Flags for duk_push_thread_raw() */
336
362
  #define DUK_THREAD_NEW_GLOBAL_ENV (1 << 0) /* create a new global environment */
337
363
 
338
- /* Flags for duk_push_string_file_raw() */
339
- #define DUK_STRING_PUSH_SAFE (1 << 0) /* no error if file does not exist */
364
+ /* Flags for duk_gc() */
365
+ #define DUK_GC_COMPACT (1 << 0) /* compact heap objects */
340
366
 
341
- /* Duktape specific error codes (must be 8 bits at most, see duk_error.h) */
367
+ /* Error codes (must be 8 bits at most, see duk_error.h) */
342
368
  #define DUK_ERR_NONE 0 /* no error (e.g. from duk_get_error_code()) */
343
- #define DUK_ERR_UNIMPLEMENTED_ERROR 50 /* UnimplementedError */ /* XXX: replace with TypeError? */
344
- #define DUK_ERR_UNSUPPORTED_ERROR 51 /* UnsupportedError */ /* XXX: replace with TypeError? */
345
- #define DUK_ERR_INTERNAL_ERROR 52 /* InternalError */ /* XXX: replace with plain Error? */
346
- #define DUK_ERR_ALLOC_ERROR 53 /* AllocError */ /* XXX: replace with RangeError? */
347
- #define DUK_ERR_ASSERTION_ERROR 54 /* AssertionError */ /* XXX: to be removed? */
348
- #define DUK_ERR_API_ERROR 55 /* APIError */ /* XXX: replace with TypeError? */
349
- #define DUK_ERR_UNCAUGHT_ERROR 56 /* UncaughtError */ /* XXX: to be removed? */
350
-
351
- /* Ecmascript E5 specification error codes */
352
- #define DUK_ERR_ERROR 100 /* Error */
353
- #define DUK_ERR_EVAL_ERROR 101 /* EvalError */
354
- #define DUK_ERR_RANGE_ERROR 102 /* RangeError */
355
- #define DUK_ERR_REFERENCE_ERROR 103 /* ReferenceError */
356
- #define DUK_ERR_SYNTAX_ERROR 104 /* SyntaxError */
357
- #define DUK_ERR_TYPE_ERROR 105 /* TypeError */
358
- #define DUK_ERR_URI_ERROR 106 /* URIError */
369
+ #define DUK_ERR_ERROR 1 /* Error */
370
+ #define DUK_ERR_EVAL_ERROR 2 /* EvalError */
371
+ #define DUK_ERR_RANGE_ERROR 3 /* RangeError */
372
+ #define DUK_ERR_REFERENCE_ERROR 4 /* ReferenceError */
373
+ #define DUK_ERR_SYNTAX_ERROR 5 /* SyntaxError */
374
+ #define DUK_ERR_TYPE_ERROR 6 /* TypeError */
375
+ #define DUK_ERR_URI_ERROR 7 /* URIError */
359
376
 
360
377
  /* Return codes for C functions (shortcut for throwing an error) */
361
- #define DUK_RET_UNIMPLEMENTED_ERROR (-DUK_ERR_UNIMPLEMENTED_ERROR)
362
- #define DUK_RET_UNSUPPORTED_ERROR (-DUK_ERR_UNSUPPORTED_ERROR)
363
- #define DUK_RET_INTERNAL_ERROR (-DUK_ERR_INTERNAL_ERROR)
364
- #define DUK_RET_ALLOC_ERROR (-DUK_ERR_ALLOC_ERROR)
365
- #define DUK_RET_ASSERTION_ERROR (-DUK_ERR_ASSERTION_ERROR)
366
- #define DUK_RET_API_ERROR (-DUK_ERR_API_ERROR)
367
- #define DUK_RET_UNCAUGHT_ERROR (-DUK_ERR_UNCAUGHT_ERROR)
368
378
  #define DUK_RET_ERROR (-DUK_ERR_ERROR)
369
379
  #define DUK_RET_EVAL_ERROR (-DUK_ERR_EVAL_ERROR)
370
380
  #define DUK_RET_RANGE_ERROR (-DUK_ERR_RANGE_ERROR)
@@ -377,20 +387,17 @@ struct duk_number_list_entry {
377
387
  #define DUK_EXEC_SUCCESS 0
378
388
  #define DUK_EXEC_ERROR 1
379
389
 
380
- /* Log levels */
381
- #define DUK_LOG_TRACE 0
382
- #define DUK_LOG_DEBUG 1
383
- #define DUK_LOG_INFO 2
384
- #define DUK_LOG_WARN 3
385
- #define DUK_LOG_ERROR 4
386
- #define DUK_LOG_FATAL 5
390
+ /* Debug levels for DUK_USE_DEBUG_WRITE(). */
391
+ #define DUK_LEVEL_DEBUG 0
392
+ #define DUK_LEVEL_DDEBUG 1
393
+ #define DUK_LEVEL_DDDEBUG 2
387
394
 
388
395
  /*
389
396
  * If no variadic macros, __FILE__ and __LINE__ are passed through globals
390
397
  * which is ugly and not thread safe.
391
398
  */
392
399
 
393
- #ifndef DUK_API_VARIADIC_MACROS
400
+ #if !defined(DUK_API_VARIADIC_MACROS)
394
401
  DUK_EXTERNAL_DECL const char *duk_api_global_filename;
395
402
  DUK_EXTERNAL_DECL duk_int_t duk_api_global_line;
396
403
  #endif
@@ -432,29 +439,99 @@ DUK_EXTERNAL_DECL void duk_gc(duk_context *ctx, duk_uint_t flags);
432
439
  * Error handling
433
440
  */
434
441
 
435
- DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_throw(duk_context *ctx));
436
- DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_fatal(duk_context *ctx, duk_errcode_t err_code, const char *err_msg));
442
+ DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_throw_raw(duk_context *ctx));
443
+ #define duk_throw(ctx) \
444
+ (duk_throw_raw((ctx)), (duk_ret_t) 0)
445
+ DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_fatal_raw(duk_context *ctx, const char *err_msg));
446
+ #define duk_fatal(ctx,err_msg) \
447
+ (duk_fatal_raw((ctx), (err_msg)), (duk_ret_t) 0)
437
448
 
449
+ #if defined(DUK_API_VARIADIC_MACROS)
438
450
  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, ...));
439
-
440
- #ifdef DUK_API_VARIADIC_MACROS
441
451
  #define duk_error(ctx,err_code,...) \
442
- duk_error_raw((ctx), (duk_errcode_t) (err_code), (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), __VA_ARGS__)
443
- #else
444
- DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_error_stash(duk_context *ctx, duk_errcode_t err_code, const char *fmt, ...));
445
- /* One problem with this macro is that expressions like the following fail
446
- * to compile: "(void) duk_error(...)". But because duk_error() is noreturn,
447
- * they make little sense anyway.
448
- */
452
+ (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)
453
+ #define duk_generic_error(ctx,...) \
454
+ (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)
455
+ #define duk_eval_error(ctx,...) \
456
+ (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)
457
+ #define duk_range_error(ctx,...) \
458
+ (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)
459
+ #define duk_reference_error(ctx,...) \
460
+ (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)
461
+ #define duk_syntax_error(ctx,...) \
462
+ (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)
463
+ #define duk_type_error(ctx,...) \
464
+ (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)
465
+ #define duk_uri_error(ctx,...) \
466
+ (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)
467
+ #else /* DUK_API_VARIADIC_MACROS */
468
+ /* For legacy compilers without variadic macros a macro hack is used to allow
469
+ * variable arguments. While the macro allows "return duk_error(...)", it
470
+ * will fail with e.g. "(void) duk_error(...)". The calls are noreturn but
471
+ * with a return value to allow the "return duk_error(...)" idiom. This may
472
+ * cause some compiler warnings, but without noreturn the generated code is
473
+ * often worse. The same approach as with variadic macros (using
474
+ * "(duk_error(...), 0)") won't work due to the macro hack structure.
475
+ */
476
+ DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_error_stash(duk_context *ctx, duk_errcode_t err_code, const char *fmt, ...));
477
+ DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_generic_error_stash(duk_context *ctx, const char *fmt, ...));
478
+ DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_eval_error_stash(duk_context *ctx, const char *fmt, ...));
479
+ DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_range_error_stash(duk_context *ctx, const char *fmt, ...));
480
+ DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_reference_error_stash(duk_context *ctx, const char *fmt, ...));
481
+ DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_syntax_error_stash(duk_context *ctx, const char *fmt, ...));
482
+ DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_type_error_stash(duk_context *ctx, const char *fmt, ...));
483
+ DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_uri_error_stash(duk_context *ctx, const char *fmt, ...));
449
484
  #define duk_error \
450
485
  (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
451
486
  duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
452
487
  duk_error_stash) /* last value is func pointer, arguments follow in parens */
453
- #endif
488
+ #define duk_generic_error \
489
+ (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
490
+ duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
491
+ duk_generic_error_stash)
492
+ #define duk_eval_error \
493
+ (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
494
+ duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
495
+ duk_eval_error_stash)
496
+ #define duk_range_error \
497
+ (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
498
+ duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
499
+ duk_range_error_stash)
500
+ #define duk_reference_error \
501
+ (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
502
+ duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
503
+ duk_reference_error_stash)
504
+ #define duk_syntax_error \
505
+ (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
506
+ duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
507
+ duk_syntax_error_stash)
508
+ #define duk_type_error \
509
+ (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
510
+ duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
511
+ duk_type_error_stash)
512
+ #define duk_uri_error \
513
+ (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
514
+ duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
515
+ duk_uri_error_stash)
516
+ #endif /* DUK_API_VARIADIC_MACROS */
454
517
 
455
518
  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));
456
519
  #define duk_error_va(ctx,err_code,fmt,ap) \
457
- duk_error_va_raw((ctx), (duk_errcode_t) (err_code), (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), (fmt), (ap))
520
+ (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)
521
+ #define duk_generic_error_va(ctx,fmt,ap) \
522
+ (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)
523
+ #define duk_eval_error_va(ctx,fmt,ap) \
524
+ (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)
525
+ #define duk_range_error_va(ctx,fmt,ap) \
526
+ (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)
527
+ #define duk_reference_error_va(ctx,fmt,ap) \
528
+ (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)
529
+ #define duk_syntax_error_va(ctx,fmt,ap) \
530
+ (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)
531
+ #define duk_type_error_va(ctx,fmt,ap) \
532
+ (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)
533
+ #define duk_uri_error_va(ctx,fmt,ap) \
534
+ (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)
458
535
 
459
536
  /*
460
537
  * Other state related functions
@@ -467,13 +544,13 @@ DUK_EXTERNAL_DECL duk_bool_t duk_is_constructor_call(duk_context *ctx);
467
544
  * Stack management
468
545
  */
469
546
 
470
- DUK_EXTERNAL_DECL duk_idx_t duk_normalize_index(duk_context *ctx, duk_idx_t index);
471
- DUK_EXTERNAL_DECL duk_idx_t duk_require_normalize_index(duk_context *ctx, duk_idx_t index);
472
- DUK_EXTERNAL_DECL duk_bool_t duk_is_valid_index(duk_context *ctx, duk_idx_t index);
473
- DUK_EXTERNAL_DECL void duk_require_valid_index(duk_context *ctx, duk_idx_t index);
547
+ DUK_EXTERNAL_DECL duk_idx_t duk_normalize_index(duk_context *ctx, duk_idx_t idx);
548
+ DUK_EXTERNAL_DECL duk_idx_t duk_require_normalize_index(duk_context *ctx, duk_idx_t idx);
549
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_valid_index(duk_context *ctx, duk_idx_t idx);
550
+ DUK_EXTERNAL_DECL void duk_require_valid_index(duk_context *ctx, duk_idx_t idx);
474
551
 
475
552
  DUK_EXTERNAL_DECL duk_idx_t duk_get_top(duk_context *ctx);
476
- DUK_EXTERNAL_DECL void duk_set_top(duk_context *ctx, duk_idx_t index);
553
+ DUK_EXTERNAL_DECL void duk_set_top(duk_context *ctx, duk_idx_t idx);
477
554
  DUK_EXTERNAL_DECL duk_idx_t duk_get_top_index(duk_context *ctx);
478
555
  DUK_EXTERNAL_DECL duk_idx_t duk_require_top_index(duk_context *ctx);
479
556
 
@@ -493,14 +570,14 @@ DUK_EXTERNAL_DECL void duk_require_stack_top(duk_context *ctx, duk_idx_t top);
493
570
  * Stack manipulation (other than push/pop)
494
571
  */
495
572
 
496
- DUK_EXTERNAL_DECL void duk_swap(duk_context *ctx, duk_idx_t index1, duk_idx_t index2);
497
- DUK_EXTERNAL_DECL void duk_swap_top(duk_context *ctx, duk_idx_t index);
498
- DUK_EXTERNAL_DECL void duk_dup(duk_context *ctx, duk_idx_t from_index);
573
+ DUK_EXTERNAL_DECL void duk_swap(duk_context *ctx, duk_idx_t idx1, duk_idx_t idx2);
574
+ DUK_EXTERNAL_DECL void duk_swap_top(duk_context *ctx, duk_idx_t idx);
575
+ DUK_EXTERNAL_DECL void duk_dup(duk_context *ctx, duk_idx_t from_idx);
499
576
  DUK_EXTERNAL_DECL void duk_dup_top(duk_context *ctx);
500
- DUK_EXTERNAL_DECL void duk_insert(duk_context *ctx, duk_idx_t to_index);
501
- DUK_EXTERNAL_DECL void duk_replace(duk_context *ctx, duk_idx_t to_index);
502
- DUK_EXTERNAL_DECL void duk_copy(duk_context *ctx, duk_idx_t from_index, duk_idx_t to_index);
503
- DUK_EXTERNAL_DECL void duk_remove(duk_context *ctx, duk_idx_t index);
577
+ DUK_EXTERNAL_DECL void duk_insert(duk_context *ctx, duk_idx_t to_idx);
578
+ DUK_EXTERNAL_DECL void duk_replace(duk_context *ctx, duk_idx_t to_idx);
579
+ DUK_EXTERNAL_DECL void duk_copy(duk_context *ctx, duk_idx_t from_idx, duk_idx_t to_idx);
580
+ DUK_EXTERNAL_DECL void duk_remove(duk_context *ctx, duk_idx_t idx);
504
581
  DUK_EXTERNAL_DECL void duk_xcopymove_raw(duk_context *to_ctx, duk_context *from_ctx, duk_idx_t count, duk_bool_t is_copy);
505
582
 
506
583
  #define duk_xmove_top(to_ctx,from_ctx,count) \
@@ -532,10 +609,6 @@ DUK_EXTERNAL_DECL void duk_push_pointer(duk_context *ctx, void *p);
532
609
  DUK_EXTERNAL_DECL const char *duk_push_sprintf(duk_context *ctx, const char *fmt, ...);
533
610
  DUK_EXTERNAL_DECL const char *duk_push_vsprintf(duk_context *ctx, const char *fmt, va_list ap);
534
611
 
535
- DUK_EXTERNAL_DECL const char *duk_push_string_file_raw(duk_context *ctx, const char *path, duk_uint_t flags);
536
- #define duk_push_string_file(ctx,path) \
537
- duk_push_string_file_raw((ctx), (path), 0)
538
-
539
612
  DUK_EXTERNAL_DECL void duk_push_this(duk_context *ctx);
540
613
  DUK_EXTERNAL_DECL void duk_push_current_function(duk_context *ctx);
541
614
  DUK_EXTERNAL_DECL void duk_push_current_thread(duk_context *ctx);
@@ -545,6 +618,7 @@ DUK_EXTERNAL_DECL void duk_push_global_stash(duk_context *ctx);
545
618
  DUK_EXTERNAL_DECL void duk_push_thread_stash(duk_context *ctx, duk_context *target_ctx);
546
619
 
547
620
  DUK_EXTERNAL_DECL duk_idx_t duk_push_object(duk_context *ctx);
621
+ DUK_EXTERNAL_DECL duk_idx_t duk_push_bare_object(duk_context *ctx);
548
622
  DUK_EXTERNAL_DECL duk_idx_t duk_push_array(duk_context *ctx);
549
623
  DUK_EXTERNAL_DECL duk_idx_t duk_push_c_function(duk_context *ctx, duk_c_function func, duk_idx_t nargs);
550
624
  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);
@@ -558,7 +632,7 @@ DUK_EXTERNAL_DECL duk_idx_t duk_push_thread_raw(duk_context *ctx, duk_uint_t fla
558
632
 
559
633
  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, ...);
560
634
 
561
- #ifdef DUK_API_VARIADIC_MACROS
635
+ #if defined(DUK_API_VARIADIC_MACROS)
562
636
  #define duk_push_error_object(ctx,err_code,...) \
563
637
  duk_push_error_object_raw((ctx), (err_code), (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), __VA_ARGS__)
564
638
  #else
@@ -590,19 +664,18 @@ DUK_EXTERNAL_DECL void *duk_push_buffer_raw(duk_context *ctx, duk_size_t size, d
590
664
  ((void) duk_push_buffer_raw((ctx), 0, DUK_BUF_FLAG_DYNAMIC | DUK_BUF_FLAG_EXTERNAL))
591
665
 
592
666
  #define DUK_BUFOBJ_CREATE_ARRBUF (1 << 4) /* internal flag: create backing ArrayBuffer; keep in one byte */
593
- #define DUK_BUFOBJ_DUKTAPE_BUFFER 0
594
- #define DUK_BUFOBJ_NODEJS_BUFFER 1
595
- #define DUK_BUFOBJ_ARRAYBUFFER 2
596
- #define DUK_BUFOBJ_DATAVIEW (3 | DUK_BUFOBJ_CREATE_ARRBUF)
597
- #define DUK_BUFOBJ_INT8ARRAY (4 | DUK_BUFOBJ_CREATE_ARRBUF)
598
- #define DUK_BUFOBJ_UINT8ARRAY (5 | DUK_BUFOBJ_CREATE_ARRBUF)
599
- #define DUK_BUFOBJ_UINT8CLAMPEDARRAY (6 | DUK_BUFOBJ_CREATE_ARRBUF)
600
- #define DUK_BUFOBJ_INT16ARRAY (7 | DUK_BUFOBJ_CREATE_ARRBUF)
601
- #define DUK_BUFOBJ_UINT16ARRAY (8 | DUK_BUFOBJ_CREATE_ARRBUF)
602
- #define DUK_BUFOBJ_INT32ARRAY (9 | DUK_BUFOBJ_CREATE_ARRBUF)
603
- #define DUK_BUFOBJ_UINT32ARRAY (10 | DUK_BUFOBJ_CREATE_ARRBUF)
604
- #define DUK_BUFOBJ_FLOAT32ARRAY (11 | DUK_BUFOBJ_CREATE_ARRBUF)
605
- #define DUK_BUFOBJ_FLOAT64ARRAY (12 | DUK_BUFOBJ_CREATE_ARRBUF)
667
+ #define DUK_BUFOBJ_ARRAYBUFFER 0
668
+ #define DUK_BUFOBJ_NODEJS_BUFFER (1 | DUK_BUFOBJ_CREATE_ARRBUF)
669
+ #define DUK_BUFOBJ_DATAVIEW (2 | DUK_BUFOBJ_CREATE_ARRBUF)
670
+ #define DUK_BUFOBJ_INT8ARRAY (3 | DUK_BUFOBJ_CREATE_ARRBUF)
671
+ #define DUK_BUFOBJ_UINT8ARRAY (4 | DUK_BUFOBJ_CREATE_ARRBUF)
672
+ #define DUK_BUFOBJ_UINT8CLAMPEDARRAY (5 | DUK_BUFOBJ_CREATE_ARRBUF)
673
+ #define DUK_BUFOBJ_INT16ARRAY (6 | DUK_BUFOBJ_CREATE_ARRBUF)
674
+ #define DUK_BUFOBJ_UINT16ARRAY (7 | DUK_BUFOBJ_CREATE_ARRBUF)
675
+ #define DUK_BUFOBJ_INT32ARRAY (8 | DUK_BUFOBJ_CREATE_ARRBUF)
676
+ #define DUK_BUFOBJ_UINT32ARRAY (9 | DUK_BUFOBJ_CREATE_ARRBUF)
677
+ #define DUK_BUFOBJ_FLOAT32ARRAY (10 | DUK_BUFOBJ_CREATE_ARRBUF)
678
+ #define DUK_BUFOBJ_FLOAT64ARRAY (11 | DUK_BUFOBJ_CREATE_ARRBUF)
606
679
 
607
680
  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);
608
681
 
@@ -624,70 +697,77 @@ DUK_EXTERNAL_DECL void duk_pop_3(duk_context *ctx);
624
697
  * is not needed; duk_is_valid_index() gives the same information.
625
698
  */
626
699
 
627
- DUK_EXTERNAL_DECL duk_int_t duk_get_type(duk_context *ctx, duk_idx_t index);
628
- DUK_EXTERNAL_DECL duk_bool_t duk_check_type(duk_context *ctx, duk_idx_t index, duk_int_t type);
629
- DUK_EXTERNAL_DECL duk_uint_t duk_get_type_mask(duk_context *ctx, duk_idx_t index);
630
- DUK_EXTERNAL_DECL duk_bool_t duk_check_type_mask(duk_context *ctx, duk_idx_t index, duk_uint_t mask);
631
-
632
- DUK_EXTERNAL_DECL duk_bool_t duk_is_undefined(duk_context *ctx, duk_idx_t index);
633
- DUK_EXTERNAL_DECL duk_bool_t duk_is_null(duk_context *ctx, duk_idx_t index);
634
- DUK_EXTERNAL_DECL duk_bool_t duk_is_null_or_undefined(duk_context *ctx, duk_idx_t index);
635
- DUK_EXTERNAL_DECL duk_bool_t duk_is_boolean(duk_context *ctx, duk_idx_t index);
636
- DUK_EXTERNAL_DECL duk_bool_t duk_is_number(duk_context *ctx, duk_idx_t index);
637
- DUK_EXTERNAL_DECL duk_bool_t duk_is_nan(duk_context *ctx, duk_idx_t index);
638
- DUK_EXTERNAL_DECL duk_bool_t duk_is_string(duk_context *ctx, duk_idx_t index);
639
- DUK_EXTERNAL_DECL duk_bool_t duk_is_object(duk_context *ctx, duk_idx_t index);
640
- DUK_EXTERNAL_DECL duk_bool_t duk_is_buffer(duk_context *ctx, duk_idx_t index);
641
- DUK_EXTERNAL_DECL duk_bool_t duk_is_pointer(duk_context *ctx, duk_idx_t index);
642
- DUK_EXTERNAL_DECL duk_bool_t duk_is_lightfunc(duk_context *ctx, duk_idx_t index);
643
-
644
- DUK_EXTERNAL_DECL duk_bool_t duk_is_array(duk_context *ctx, duk_idx_t index);
645
- DUK_EXTERNAL_DECL duk_bool_t duk_is_function(duk_context *ctx, duk_idx_t index);
646
- DUK_EXTERNAL_DECL duk_bool_t duk_is_c_function(duk_context *ctx, duk_idx_t index);
647
- DUK_EXTERNAL_DECL duk_bool_t duk_is_ecmascript_function(duk_context *ctx, duk_idx_t index);
648
- DUK_EXTERNAL_DECL duk_bool_t duk_is_bound_function(duk_context *ctx, duk_idx_t index);
649
- DUK_EXTERNAL_DECL duk_bool_t duk_is_thread(duk_context *ctx, duk_idx_t index);
650
-
651
- #define duk_is_callable(ctx,index) \
652
- duk_is_function((ctx), (index))
653
- DUK_EXTERNAL_DECL duk_bool_t duk_is_dynamic_buffer(duk_context *ctx, duk_idx_t index);
654
- DUK_EXTERNAL_DECL duk_bool_t duk_is_fixed_buffer(duk_context *ctx, duk_idx_t index);
655
- DUK_EXTERNAL_DECL duk_bool_t duk_is_external_buffer(duk_context *ctx, duk_idx_t index);
656
-
657
- #define duk_is_primitive(ctx,index) \
658
- duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_UNDEFINED | \
659
- DUK_TYPE_MASK_NULL | \
660
- DUK_TYPE_MASK_BOOLEAN | \
661
- DUK_TYPE_MASK_NUMBER | \
662
- DUK_TYPE_MASK_STRING | \
663
- DUK_TYPE_MASK_BUFFER | \
664
- DUK_TYPE_MASK_POINTER | \
665
- DUK_TYPE_MASK_LIGHTFUNC)
666
-
667
- #define duk_is_object_coercible(ctx,index) \
668
- duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_BOOLEAN | \
669
- DUK_TYPE_MASK_NUMBER | \
670
- DUK_TYPE_MASK_STRING | \
671
- DUK_TYPE_MASK_OBJECT | \
672
- DUK_TYPE_MASK_BUFFER | \
673
- DUK_TYPE_MASK_POINTER | \
674
- DUK_TYPE_MASK_LIGHTFUNC)
675
-
676
- DUK_EXTERNAL_DECL duk_errcode_t duk_get_error_code(duk_context *ctx, duk_idx_t index);
677
- #define duk_is_error(ctx,index) \
678
- (duk_get_error_code((ctx), (index)) != 0)
679
- #define duk_is_eval_error(ctx,index) \
680
- (duk_get_error_code((ctx), (index)) == DUK_ERR_EVAL_ERROR)
681
- #define duk_is_range_error(ctx,index) \
682
- (duk_get_error_code((ctx), (index)) == DUK_ERR_RANGE_ERROR)
683
- #define duk_is_reference_error(ctx,index) \
684
- (duk_get_error_code((ctx), (index)) == DUK_ERR_REFERENCE_ERROR)
685
- #define duk_is_syntax_error(ctx,index) \
686
- (duk_get_error_code((ctx), (index)) == DUK_ERR_SYNTAX_ERROR)
687
- #define duk_is_type_error(ctx,index) \
688
- (duk_get_error_code((ctx), (index)) == DUK_ERR_TYPE_ERROR)
689
- #define duk_is_uri_error(ctx,index) \
690
- (duk_get_error_code((ctx), (index)) == DUK_ERR_URI_ERROR)
700
+ DUK_EXTERNAL_DECL duk_int_t duk_get_type(duk_context *ctx, duk_idx_t idx);
701
+ DUK_EXTERNAL_DECL duk_bool_t duk_check_type(duk_context *ctx, duk_idx_t idx, duk_int_t type);
702
+ DUK_EXTERNAL_DECL duk_uint_t duk_get_type_mask(duk_context *ctx, duk_idx_t idx);
703
+ DUK_EXTERNAL_DECL duk_bool_t duk_check_type_mask(duk_context *ctx, duk_idx_t idx, duk_uint_t mask);
704
+
705
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_undefined(duk_context *ctx, duk_idx_t idx);
706
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_null(duk_context *ctx, duk_idx_t idx);
707
+ #define duk_is_null_or_undefined(ctx, idx) \
708
+ ((duk_get_type_mask((ctx), (idx)) & (DUK_TYPE_MASK_NULL | DUK_TYPE_MASK_UNDEFINED)) ? 1 : 0)
709
+
710
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_boolean(duk_context *ctx, duk_idx_t idx);
711
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_number(duk_context *ctx, duk_idx_t idx);
712
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_nan(duk_context *ctx, duk_idx_t idx);
713
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_string(duk_context *ctx, duk_idx_t idx);
714
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_object(duk_context *ctx, duk_idx_t idx);
715
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_buffer(duk_context *ctx, duk_idx_t idx);
716
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_buffer_data(duk_context *ctx, duk_idx_t idx);
717
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_pointer(duk_context *ctx, duk_idx_t idx);
718
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_lightfunc(duk_context *ctx, duk_idx_t idx);
719
+
720
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_symbol(duk_context *ctx, duk_idx_t idx);
721
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_array(duk_context *ctx, duk_idx_t idx);
722
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_function(duk_context *ctx, duk_idx_t idx);
723
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_c_function(duk_context *ctx, duk_idx_t idx);
724
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_ecmascript_function(duk_context *ctx, duk_idx_t idx);
725
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_bound_function(duk_context *ctx, duk_idx_t idx);
726
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_thread(duk_context *ctx, duk_idx_t idx);
727
+
728
+ #define duk_is_callable(ctx,idx) \
729
+ duk_is_function((ctx), (idx))
730
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_dynamic_buffer(duk_context *ctx, duk_idx_t idx);
731
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_fixed_buffer(duk_context *ctx, duk_idx_t idx);
732
+ DUK_EXTERNAL_DECL duk_bool_t duk_is_external_buffer(duk_context *ctx, duk_idx_t idx);
733
+
734
+ /* Buffers and lightfuncs are not considered primitive because they mimic
735
+ * objects and e.g. duk_to_primitive() will coerce them instead of returning
736
+ * them as is. Symbols are represented as strings internally.
737
+ */
738
+ #define duk_is_primitive(ctx,idx) \
739
+ duk_check_type_mask((ctx), (idx), DUK_TYPE_MASK_UNDEFINED | \
740
+ DUK_TYPE_MASK_NULL | \
741
+ DUK_TYPE_MASK_BOOLEAN | \
742
+ DUK_TYPE_MASK_NUMBER | \
743
+ DUK_TYPE_MASK_STRING | \
744
+ DUK_TYPE_MASK_POINTER)
745
+
746
+ /* Symbols are object coercible, covered by DUK_TYPE_MASK_STRING. */
747
+ #define duk_is_object_coercible(ctx,idx) \
748
+ duk_check_type_mask((ctx), (idx), DUK_TYPE_MASK_BOOLEAN | \
749
+ DUK_TYPE_MASK_NUMBER | \
750
+ DUK_TYPE_MASK_STRING | \
751
+ DUK_TYPE_MASK_OBJECT | \
752
+ DUK_TYPE_MASK_BUFFER | \
753
+ DUK_TYPE_MASK_POINTER | \
754
+ DUK_TYPE_MASK_LIGHTFUNC)
755
+
756
+ DUK_EXTERNAL_DECL duk_errcode_t duk_get_error_code(duk_context *ctx, duk_idx_t idx);
757
+ #define duk_is_error(ctx,idx) \
758
+ (duk_get_error_code((ctx), (idx)) != 0)
759
+ #define duk_is_eval_error(ctx,idx) \
760
+ (duk_get_error_code((ctx), (idx)) == DUK_ERR_EVAL_ERROR)
761
+ #define duk_is_range_error(ctx,idx) \
762
+ (duk_get_error_code((ctx), (idx)) == DUK_ERR_RANGE_ERROR)
763
+ #define duk_is_reference_error(ctx,idx) \
764
+ (duk_get_error_code((ctx), (idx)) == DUK_ERR_REFERENCE_ERROR)
765
+ #define duk_is_syntax_error(ctx,idx) \
766
+ (duk_get_error_code((ctx), (idx)) == DUK_ERR_SYNTAX_ERROR)
767
+ #define duk_is_type_error(ctx,idx) \
768
+ (duk_get_error_code((ctx), (idx)) == DUK_ERR_TYPE_ERROR)
769
+ #define duk_is_uri_error(ctx,idx) \
770
+ (duk_get_error_code((ctx), (idx)) == DUK_ERR_URI_ERROR)
691
771
 
692
772
  /*
693
773
  * Get operations: no coercion, returns default value for invalid
@@ -697,48 +777,50 @@ DUK_EXTERNAL_DECL duk_errcode_t duk_get_error_code(duk_context *ctx, duk_idx_t i
697
777
  * are not included.
698
778
  */
699
779
 
700
- DUK_EXTERNAL_DECL duk_bool_t duk_get_boolean(duk_context *ctx, duk_idx_t index);
701
- DUK_EXTERNAL_DECL duk_double_t duk_get_number(duk_context *ctx, duk_idx_t index);
702
- DUK_EXTERNAL_DECL duk_int_t duk_get_int(duk_context *ctx, duk_idx_t index);
703
- DUK_EXTERNAL_DECL duk_uint_t duk_get_uint(duk_context *ctx, duk_idx_t index);
704
- DUK_EXTERNAL_DECL const char *duk_get_string(duk_context *ctx, duk_idx_t index);
705
- DUK_EXTERNAL_DECL const char *duk_get_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len);
706
- DUK_EXTERNAL_DECL void *duk_get_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);
707
- DUK_EXTERNAL_DECL void *duk_get_buffer_data(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);
708
- DUK_EXTERNAL_DECL void *duk_get_pointer(duk_context *ctx, duk_idx_t index);
709
- DUK_EXTERNAL_DECL duk_c_function duk_get_c_function(duk_context *ctx, duk_idx_t index);
710
- DUK_EXTERNAL_DECL duk_context *duk_get_context(duk_context *ctx, duk_idx_t index);
711
- DUK_EXTERNAL_DECL void *duk_get_heapptr(duk_context *ctx, duk_idx_t index);
712
- DUK_EXTERNAL_DECL duk_size_t duk_get_length(duk_context *ctx, duk_idx_t index);
780
+ DUK_EXTERNAL_DECL duk_bool_t duk_get_boolean(duk_context *ctx, duk_idx_t idx);
781
+ DUK_EXTERNAL_DECL duk_double_t duk_get_number(duk_context *ctx, duk_idx_t idx);
782
+ DUK_EXTERNAL_DECL duk_int_t duk_get_int(duk_context *ctx, duk_idx_t idx);
783
+ DUK_EXTERNAL_DECL duk_uint_t duk_get_uint(duk_context *ctx, duk_idx_t idx);
784
+ DUK_EXTERNAL_DECL const char *duk_get_string(duk_context *ctx, duk_idx_t idx);
785
+ DUK_EXTERNAL_DECL const char *duk_get_lstring(duk_context *ctx, duk_idx_t idx, duk_size_t *out_len);
786
+ DUK_EXTERNAL_DECL void *duk_get_buffer(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size);
787
+ DUK_EXTERNAL_DECL void *duk_get_buffer_data(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size);
788
+ DUK_EXTERNAL_DECL void *duk_get_pointer(duk_context *ctx, duk_idx_t idx);
789
+ DUK_EXTERNAL_DECL duk_c_function duk_get_c_function(duk_context *ctx, duk_idx_t idx);
790
+ DUK_EXTERNAL_DECL duk_context *duk_get_context(duk_context *ctx, duk_idx_t idx);
791
+ DUK_EXTERNAL_DECL void *duk_get_heapptr(duk_context *ctx, duk_idx_t idx);
792
+ DUK_EXTERNAL_DECL duk_size_t duk_get_length(duk_context *ctx, duk_idx_t idx);
793
+ DUK_EXTERNAL_DECL void duk_set_length(duk_context *ctx, duk_idx_t idx, duk_size_t len);
713
794
 
714
795
  /*
715
796
  * Require operations: no coercion, throw error if index or type
716
797
  * is incorrect. No defaulting.
717
798
  */
718
799
 
719
- #define duk_require_type_mask(ctx,index,mask) \
720
- ((void) duk_check_type_mask((ctx), (index), (mask) | DUK_TYPE_MASK_THROW))
721
-
722
- DUK_EXTERNAL_DECL void duk_require_undefined(duk_context *ctx, duk_idx_t index);
723
- DUK_EXTERNAL_DECL void duk_require_null(duk_context *ctx, duk_idx_t index);
724
- DUK_EXTERNAL_DECL duk_bool_t duk_require_boolean(duk_context *ctx, duk_idx_t index);
725
- DUK_EXTERNAL_DECL duk_double_t duk_require_number(duk_context *ctx, duk_idx_t index);
726
- DUK_EXTERNAL_DECL duk_int_t duk_require_int(duk_context *ctx, duk_idx_t index);
727
- DUK_EXTERNAL_DECL duk_uint_t duk_require_uint(duk_context *ctx, duk_idx_t index);
728
- DUK_EXTERNAL_DECL const char *duk_require_string(duk_context *ctx, duk_idx_t index);
729
- DUK_EXTERNAL_DECL const char *duk_require_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len);
730
- DUK_EXTERNAL_DECL void *duk_require_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);
731
- DUK_EXTERNAL_DECL void *duk_require_buffer_data(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);
732
- DUK_EXTERNAL_DECL void *duk_require_pointer(duk_context *ctx, duk_idx_t index);
733
- DUK_EXTERNAL_DECL duk_c_function duk_require_c_function(duk_context *ctx, duk_idx_t index);
734
- DUK_EXTERNAL_DECL duk_context *duk_require_context(duk_context *ctx, duk_idx_t index);
735
- DUK_EXTERNAL_DECL void duk_require_function(duk_context *ctx, duk_idx_t index);
736
- #define duk_require_callable(ctx,index) \
737
- duk_require_function((ctx), (index))
738
- DUK_EXTERNAL_DECL void *duk_require_heapptr(duk_context *ctx, duk_idx_t index);
739
-
740
- #define duk_require_object_coercible(ctx,index) \
741
- ((void) duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_BOOLEAN | \
800
+ #define duk_require_type_mask(ctx,idx,mask) \
801
+ ((void) duk_check_type_mask((ctx), (idx), (mask) | DUK_TYPE_MASK_THROW))
802
+
803
+ DUK_EXTERNAL_DECL void duk_require_undefined(duk_context *ctx, duk_idx_t idx);
804
+ DUK_EXTERNAL_DECL void duk_require_null(duk_context *ctx, duk_idx_t idx);
805
+ DUK_EXTERNAL_DECL duk_bool_t duk_require_boolean(duk_context *ctx, duk_idx_t idx);
806
+ DUK_EXTERNAL_DECL duk_double_t duk_require_number(duk_context *ctx, duk_idx_t idx);
807
+ DUK_EXTERNAL_DECL duk_int_t duk_require_int(duk_context *ctx, duk_idx_t idx);
808
+ DUK_EXTERNAL_DECL duk_uint_t duk_require_uint(duk_context *ctx, duk_idx_t idx);
809
+ DUK_EXTERNAL_DECL const char *duk_require_string(duk_context *ctx, duk_idx_t idx);
810
+ DUK_EXTERNAL_DECL const char *duk_require_lstring(duk_context *ctx, duk_idx_t idx, duk_size_t *out_len);
811
+ DUK_EXTERNAL_DECL void *duk_require_buffer(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size);
812
+ DUK_EXTERNAL_DECL void *duk_require_buffer_data(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size);
813
+ DUK_EXTERNAL_DECL void *duk_require_pointer(duk_context *ctx, duk_idx_t idx);
814
+ DUK_EXTERNAL_DECL duk_c_function duk_require_c_function(duk_context *ctx, duk_idx_t idx);
815
+ DUK_EXTERNAL_DECL duk_context *duk_require_context(duk_context *ctx, duk_idx_t idx);
816
+ DUK_EXTERNAL_DECL void duk_require_function(duk_context *ctx, duk_idx_t idx);
817
+ #define duk_require_callable(ctx,idx) \
818
+ duk_require_function((ctx), (idx))
819
+ DUK_EXTERNAL_DECL void *duk_require_heapptr(duk_context *ctx, duk_idx_t idx);
820
+
821
+ /* Symbols are object coercible and covered by DUK_TYPE_MASK_STRING. */
822
+ #define duk_require_object_coercible(ctx,idx) \
823
+ ((void) duk_check_type_mask((ctx), (idx), DUK_TYPE_MASK_BOOLEAN | \
742
824
  DUK_TYPE_MASK_NUMBER | \
743
825
  DUK_TYPE_MASK_STRING | \
744
826
  DUK_TYPE_MASK_OBJECT | \
@@ -754,57 +836,58 @@ DUK_EXTERNAL_DECL void *duk_require_heapptr(duk_context *ctx, duk_idx_t index);
754
836
  * or an internal error (e.g. from out of memory).
755
837
  */
756
838
 
757
- DUK_EXTERNAL_DECL void duk_to_undefined(duk_context *ctx, duk_idx_t index);
758
- DUK_EXTERNAL_DECL void duk_to_null(duk_context *ctx, duk_idx_t index);
759
- DUK_EXTERNAL_DECL duk_bool_t duk_to_boolean(duk_context *ctx, duk_idx_t index);
760
- DUK_EXTERNAL_DECL duk_double_t duk_to_number(duk_context *ctx, duk_idx_t index);
761
- DUK_EXTERNAL_DECL duk_int_t duk_to_int(duk_context *ctx, duk_idx_t index);
762
- DUK_EXTERNAL_DECL duk_uint_t duk_to_uint(duk_context *ctx, duk_idx_t index);
763
- DUK_EXTERNAL_DECL duk_int32_t duk_to_int32(duk_context *ctx, duk_idx_t index);
764
- DUK_EXTERNAL_DECL duk_uint32_t duk_to_uint32(duk_context *ctx, duk_idx_t index);
765
- DUK_EXTERNAL_DECL duk_uint16_t duk_to_uint16(duk_context *ctx, duk_idx_t index);
766
- DUK_EXTERNAL_DECL const char *duk_to_string(duk_context *ctx, duk_idx_t index);
767
- DUK_EXTERNAL_DECL const char *duk_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len);
768
- DUK_EXTERNAL_DECL void *duk_to_buffer_raw(duk_context *ctx, duk_idx_t index, duk_size_t *out_size, duk_uint_t flags);
769
- DUK_EXTERNAL_DECL void *duk_to_pointer(duk_context *ctx, duk_idx_t index);
770
- DUK_EXTERNAL_DECL void duk_to_object(duk_context *ctx, duk_idx_t index);
771
- DUK_EXTERNAL_DECL void duk_to_defaultvalue(duk_context *ctx, duk_idx_t index, duk_int_t hint);
772
- DUK_EXTERNAL_DECL void duk_to_primitive(duk_context *ctx, duk_idx_t index, duk_int_t hint);
839
+ DUK_EXTERNAL_DECL void duk_to_undefined(duk_context *ctx, duk_idx_t idx);
840
+ DUK_EXTERNAL_DECL void duk_to_null(duk_context *ctx, duk_idx_t idx);
841
+ DUK_EXTERNAL_DECL duk_bool_t duk_to_boolean(duk_context *ctx, duk_idx_t idx);
842
+ DUK_EXTERNAL_DECL duk_double_t duk_to_number(duk_context *ctx, duk_idx_t idx);
843
+ DUK_EXTERNAL_DECL duk_int_t duk_to_int(duk_context *ctx, duk_idx_t idx);
844
+ DUK_EXTERNAL_DECL duk_uint_t duk_to_uint(duk_context *ctx, duk_idx_t idx);
845
+ DUK_EXTERNAL_DECL duk_int32_t duk_to_int32(duk_context *ctx, duk_idx_t idx);
846
+ DUK_EXTERNAL_DECL duk_uint32_t duk_to_uint32(duk_context *ctx, duk_idx_t idx);
847
+ DUK_EXTERNAL_DECL duk_uint16_t duk_to_uint16(duk_context *ctx, duk_idx_t idx);
848
+ DUK_EXTERNAL_DECL const char *duk_to_string(duk_context *ctx, duk_idx_t idx);
849
+ DUK_EXTERNAL_DECL const char *duk_to_lstring(duk_context *ctx, duk_idx_t idx, duk_size_t *out_len);
850
+ DUK_EXTERNAL_DECL void *duk_to_buffer_raw(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size, duk_uint_t flags);
851
+ DUK_EXTERNAL_DECL void *duk_to_pointer(duk_context *ctx, duk_idx_t idx);
852
+ DUK_EXTERNAL_DECL void duk_to_object(duk_context *ctx, duk_idx_t idx);
853
+ DUK_EXTERNAL_DECL void duk_to_primitive(duk_context *ctx, duk_idx_t idx, duk_int_t hint);
773
854
 
774
855
  #define DUK_BUF_MODE_FIXED 0 /* internal: request fixed buffer result */
775
856
  #define DUK_BUF_MODE_DYNAMIC 1 /* internal: request dynamic buffer result */
776
857
  #define DUK_BUF_MODE_DONTCARE 2 /* internal: don't care about fixed/dynamic nature */
777
858
 
778
- #define duk_to_buffer(ctx,index,out_size) \
779
- duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_DONTCARE)
780
- #define duk_to_fixed_buffer(ctx,index,out_size) \
781
- duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_FIXED)
782
- #define duk_to_dynamic_buffer(ctx,index,out_size) \
783
- duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_DYNAMIC)
859
+ #define duk_to_buffer(ctx,idx,out_size) \
860
+ duk_to_buffer_raw((ctx), (idx), (out_size), DUK_BUF_MODE_DONTCARE)
861
+ #define duk_to_fixed_buffer(ctx,idx,out_size) \
862
+ duk_to_buffer_raw((ctx), (idx), (out_size), DUK_BUF_MODE_FIXED)
863
+ #define duk_to_dynamic_buffer(ctx,idx,out_size) \
864
+ duk_to_buffer_raw((ctx), (idx), (out_size), DUK_BUF_MODE_DYNAMIC)
784
865
 
785
866
  /* safe variants of a few coercion operations */
786
- DUK_EXTERNAL_DECL const char *duk_safe_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len);
787
- #define duk_safe_to_string(ctx,index) \
788
- duk_safe_to_lstring((ctx), (index), NULL)
867
+ DUK_EXTERNAL_DECL const char *duk_safe_to_lstring(duk_context *ctx, duk_idx_t idx, duk_size_t *out_len);
868
+ #define duk_safe_to_string(ctx,idx) \
869
+ duk_safe_to_lstring((ctx), (idx), NULL)
789
870
 
790
871
  /*
791
872
  * Misc conversion
792
873
  */
793
874
 
794
- DUK_EXTERNAL_DECL const char *duk_base64_encode(duk_context *ctx, duk_idx_t index);
795
- DUK_EXTERNAL_DECL void duk_base64_decode(duk_context *ctx, duk_idx_t index);
796
- DUK_EXTERNAL_DECL const char *duk_hex_encode(duk_context *ctx, duk_idx_t index);
797
- DUK_EXTERNAL_DECL void duk_hex_decode(duk_context *ctx, duk_idx_t index);
798
- DUK_EXTERNAL_DECL const char *duk_json_encode(duk_context *ctx, duk_idx_t index);
799
- DUK_EXTERNAL_DECL void duk_json_decode(duk_context *ctx, duk_idx_t index);
875
+ DUK_EXTERNAL_DECL const char *duk_base64_encode(duk_context *ctx, duk_idx_t idx);
876
+ DUK_EXTERNAL_DECL void duk_base64_decode(duk_context *ctx, duk_idx_t idx);
877
+ DUK_EXTERNAL_DECL const char *duk_hex_encode(duk_context *ctx, duk_idx_t idx);
878
+ DUK_EXTERNAL_DECL void duk_hex_decode(duk_context *ctx, duk_idx_t idx);
879
+ DUK_EXTERNAL_DECL const char *duk_json_encode(duk_context *ctx, duk_idx_t idx);
880
+ DUK_EXTERNAL_DECL void duk_json_decode(duk_context *ctx, duk_idx_t idx);
881
+
882
+ DUK_EXTERNAL_DECL const char *duk_buffer_to_string(duk_context *ctx, duk_idx_t idx);
800
883
 
801
884
  /*
802
885
  * Buffer
803
886
  */
804
887
 
805
- DUK_EXTERNAL_DECL void *duk_resize_buffer(duk_context *ctx, duk_idx_t index, duk_size_t new_size);
806
- DUK_EXTERNAL_DECL void *duk_steal_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);
807
- DUK_EXTERNAL_DECL void duk_config_buffer(duk_context *ctx, duk_idx_t index, void *ptr, duk_size_t len);
888
+ DUK_EXTERNAL_DECL void *duk_resize_buffer(duk_context *ctx, duk_idx_t idx, duk_size_t new_size);
889
+ DUK_EXTERNAL_DECL void *duk_steal_buffer(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size);
890
+ DUK_EXTERNAL_DECL void duk_config_buffer(duk_context *ctx, duk_idx_t idx, void *ptr, duk_size_t len);
808
891
 
809
892
  /*
810
893
  * Property access
@@ -814,36 +897,51 @@ DUK_EXTERNAL_DECL void duk_config_buffer(duk_context *ctx, duk_idx_t index, void
814
897
  * index as a property name (e.g. 123 is equivalent to the key "123").
815
898
  */
816
899
 
817
- DUK_EXTERNAL_DECL duk_bool_t duk_get_prop(duk_context *ctx, duk_idx_t obj_index);
818
- DUK_EXTERNAL_DECL duk_bool_t duk_get_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key);
819
- DUK_EXTERNAL_DECL duk_bool_t duk_get_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index);
820
- DUK_EXTERNAL_DECL duk_bool_t duk_put_prop(duk_context *ctx, duk_idx_t obj_index);
821
- DUK_EXTERNAL_DECL duk_bool_t duk_put_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key);
822
- DUK_EXTERNAL_DECL duk_bool_t duk_put_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index);
823
- DUK_EXTERNAL_DECL duk_bool_t duk_del_prop(duk_context *ctx, duk_idx_t obj_index);
824
- DUK_EXTERNAL_DECL duk_bool_t duk_del_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key);
825
- DUK_EXTERNAL_DECL duk_bool_t duk_del_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index);
826
- DUK_EXTERNAL_DECL duk_bool_t duk_has_prop(duk_context *ctx, duk_idx_t obj_index);
827
- DUK_EXTERNAL_DECL duk_bool_t duk_has_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key);
828
- DUK_EXTERNAL_DECL duk_bool_t duk_has_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index);
829
- DUK_EXTERNAL_DECL void duk_def_prop(duk_context *ctx, duk_idx_t obj_index, duk_uint_t flags);
900
+ DUK_EXTERNAL_DECL duk_bool_t duk_get_prop(duk_context *ctx, duk_idx_t obj_idx);
901
+ DUK_EXTERNAL_DECL duk_bool_t duk_get_prop_string(duk_context *ctx, duk_idx_t obj_idx, const char *key);
902
+ 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);
903
+ DUK_EXTERNAL_DECL duk_bool_t duk_get_prop_index(duk_context *ctx, duk_idx_t obj_idx, duk_uarridx_t arr_idx);
904
+ DUK_EXTERNAL_DECL duk_bool_t duk_put_prop(duk_context *ctx, duk_idx_t obj_idx);
905
+ DUK_EXTERNAL_DECL duk_bool_t duk_put_prop_string(duk_context *ctx, duk_idx_t obj_idx, const char *key);
906
+ 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);
907
+ DUK_EXTERNAL_DECL duk_bool_t duk_put_prop_index(duk_context *ctx, duk_idx_t obj_idx, duk_uarridx_t arr_idx);
908
+ DUK_EXTERNAL_DECL duk_bool_t duk_del_prop(duk_context *ctx, duk_idx_t obj_idx);
909
+ DUK_EXTERNAL_DECL duk_bool_t duk_del_prop_string(duk_context *ctx, duk_idx_t obj_idx, const char *key);
910
+ 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);
911
+ DUK_EXTERNAL_DECL duk_bool_t duk_del_prop_index(duk_context *ctx, duk_idx_t obj_idx, duk_uarridx_t arr_idx);
912
+ DUK_EXTERNAL_DECL duk_bool_t duk_has_prop(duk_context *ctx, duk_idx_t obj_idx);
913
+ DUK_EXTERNAL_DECL duk_bool_t duk_has_prop_string(duk_context *ctx, duk_idx_t obj_idx, const char *key);
914
+ 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);
915
+ DUK_EXTERNAL_DECL duk_bool_t duk_has_prop_index(duk_context *ctx, duk_idx_t obj_idx, duk_uarridx_t arr_idx);
916
+
917
+ DUK_EXTERNAL_DECL void duk_get_prop_desc(duk_context *ctx, duk_idx_t obj_idx, duk_uint_t flags);
918
+ DUK_EXTERNAL_DECL void duk_def_prop(duk_context *ctx, duk_idx_t obj_idx, duk_uint_t flags);
830
919
 
831
920
  DUK_EXTERNAL_DECL duk_bool_t duk_get_global_string(duk_context *ctx, const char *key);
921
+ DUK_EXTERNAL_DECL duk_bool_t duk_get_global_lstring(duk_context *ctx, const char *key, duk_size_t key_len);
832
922
  DUK_EXTERNAL_DECL duk_bool_t duk_put_global_string(duk_context *ctx, const char *key);
923
+ DUK_EXTERNAL_DECL duk_bool_t duk_put_global_lstring(duk_context *ctx, const char *key, duk_size_t key_len);
924
+
925
+ /*
926
+ * Inspection
927
+ */
928
+
929
+ DUK_EXTERNAL_DECL void duk_inspect_value(duk_context *ctx, duk_idx_t idx);
930
+ DUK_EXTERNAL_DECL void duk_inspect_callstack_entry(duk_context *ctx, duk_int_t level);
833
931
 
834
932
  /*
835
933
  * Object prototype
836
934
  */
837
935
 
838
- DUK_EXTERNAL_DECL void duk_get_prototype(duk_context *ctx, duk_idx_t index);
839
- DUK_EXTERNAL_DECL void duk_set_prototype(duk_context *ctx, duk_idx_t index);
936
+ DUK_EXTERNAL_DECL void duk_get_prototype(duk_context *ctx, duk_idx_t idx);
937
+ DUK_EXTERNAL_DECL void duk_set_prototype(duk_context *ctx, duk_idx_t idx);
840
938
 
841
939
  /*
842
940
  * Object finalizer
843
941
  */
844
942
 
845
- DUK_EXTERNAL_DECL void duk_get_finalizer(duk_context *ctx, duk_idx_t index);
846
- DUK_EXTERNAL_DECL void duk_set_finalizer(duk_context *ctx, duk_idx_t index);
943
+ DUK_EXTERNAL_DECL void duk_get_finalizer(duk_context *ctx, duk_idx_t idx);
944
+ DUK_EXTERNAL_DECL void duk_set_finalizer(duk_context *ctx, duk_idx_t idx);
847
945
 
848
946
  /*
849
947
  * Global object
@@ -855,36 +953,24 @@ DUK_EXTERNAL_DECL void duk_set_global_object(duk_context *ctx);
855
953
  * Duktape/C function magic value
856
954
  */
857
955
 
858
- DUK_EXTERNAL_DECL duk_int_t duk_get_magic(duk_context *ctx, duk_idx_t index);
859
- DUK_EXTERNAL_DECL void duk_set_magic(duk_context *ctx, duk_idx_t index, duk_int_t magic);
956
+ DUK_EXTERNAL_DECL duk_int_t duk_get_magic(duk_context *ctx, duk_idx_t idx);
957
+ DUK_EXTERNAL_DECL void duk_set_magic(duk_context *ctx, duk_idx_t idx, duk_int_t magic);
860
958
  DUK_EXTERNAL_DECL duk_int_t duk_get_current_magic(duk_context *ctx);
861
959
 
862
960
  /*
863
961
  * Module helpers: put multiple function or constant properties
864
962
  */
865
963
 
866
- DUK_EXTERNAL_DECL void duk_put_function_list(duk_context *ctx, duk_idx_t obj_index, const duk_function_list_entry *funcs);
867
- DUK_EXTERNAL_DECL void duk_put_number_list(duk_context *ctx, duk_idx_t obj_index, const duk_number_list_entry *numbers);
868
-
869
- /*
870
- * Variable access
871
- */
872
-
873
- /* XXX: These calls are incomplete and not usable now. They are not (yet)
874
- * part of the public API.
875
- */
876
- DUK_EXTERNAL_DECL void duk_get_var(duk_context *ctx);
877
- DUK_EXTERNAL_DECL void duk_put_var(duk_context *ctx);
878
- DUK_EXTERNAL_DECL duk_bool_t duk_del_var(duk_context *ctx);
879
- DUK_EXTERNAL_DECL duk_bool_t duk_has_var(duk_context *ctx);
964
+ DUK_EXTERNAL_DECL void duk_put_function_list(duk_context *ctx, duk_idx_t obj_idx, const duk_function_list_entry *funcs);
965
+ DUK_EXTERNAL_DECL void duk_put_number_list(duk_context *ctx, duk_idx_t obj_idx, const duk_number_list_entry *numbers);
880
966
 
881
967
  /*
882
968
  * Object operations
883
969
  */
884
970
 
885
- DUK_EXTERNAL_DECL void duk_compact(duk_context *ctx, duk_idx_t obj_index);
886
- DUK_EXTERNAL_DECL void duk_enum(duk_context *ctx, duk_idx_t obj_index, duk_uint_t enum_flags);
887
- DUK_EXTERNAL_DECL duk_bool_t duk_next(duk_context *ctx, duk_idx_t enum_index, duk_bool_t get_value);
971
+ DUK_EXTERNAL_DECL void duk_compact(duk_context *ctx, duk_idx_t obj_idx);
972
+ DUK_EXTERNAL_DECL void duk_enum(duk_context *ctx, duk_idx_t obj_idx, duk_uint_t enum_flags);
973
+ DUK_EXTERNAL_DECL duk_bool_t duk_next(duk_context *ctx, duk_idx_t enum_idx, duk_bool_t get_value);
888
974
 
889
975
  /*
890
976
  * String manipulation
@@ -892,19 +978,20 @@ DUK_EXTERNAL_DECL duk_bool_t duk_next(duk_context *ctx, duk_idx_t enum_index, du
892
978
 
893
979
  DUK_EXTERNAL_DECL void duk_concat(duk_context *ctx, duk_idx_t count);
894
980
  DUK_EXTERNAL_DECL void duk_join(duk_context *ctx, duk_idx_t count);
895
- DUK_EXTERNAL_DECL void duk_decode_string(duk_context *ctx, duk_idx_t index, duk_decode_char_function callback, void *udata);
896
- DUK_EXTERNAL_DECL void duk_map_string(duk_context *ctx, duk_idx_t index, duk_map_char_function callback, void *udata);
897
- 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);
898
- DUK_EXTERNAL_DECL void duk_trim(duk_context *ctx, duk_idx_t index);
899
- DUK_EXTERNAL_DECL duk_codepoint_t duk_char_code_at(duk_context *ctx, duk_idx_t index, duk_size_t char_offset);
981
+ DUK_EXTERNAL_DECL void duk_decode_string(duk_context *ctx, duk_idx_t idx, duk_decode_char_function callback, void *udata);
982
+ DUK_EXTERNAL_DECL void duk_map_string(duk_context *ctx, duk_idx_t idx, duk_map_char_function callback, void *udata);
983
+ 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);
984
+ DUK_EXTERNAL_DECL void duk_trim(duk_context *ctx, duk_idx_t idx);
985
+ DUK_EXTERNAL_DECL duk_codepoint_t duk_char_code_at(duk_context *ctx, duk_idx_t idx, duk_size_t char_offset);
900
986
 
901
987
  /*
902
988
  * Ecmascript operators
903
989
  */
904
990
 
905
- DUK_EXTERNAL_DECL duk_bool_t duk_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2);
906
- DUK_EXTERNAL_DECL duk_bool_t duk_strict_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2);
907
- DUK_EXTERNAL_DECL duk_bool_t duk_instanceof(duk_context *ctx, duk_idx_t index1, duk_idx_t index2);
991
+ DUK_EXTERNAL_DECL duk_bool_t duk_equals(duk_context *ctx, duk_idx_t idx1, duk_idx_t idx2);
992
+ DUK_EXTERNAL_DECL duk_bool_t duk_strict_equals(duk_context *ctx, duk_idx_t idx1, duk_idx_t idx2);
993
+ DUK_EXTERNAL_DECL duk_bool_t duk_samevalue(duk_context *ctx, duk_idx_t idx1, duk_idx_t idx2);
994
+ DUK_EXTERNAL_DECL duk_bool_t duk_instanceof(duk_context *ctx, duk_idx_t idx1, duk_idx_t idx2);
908
995
 
909
996
  /*
910
997
  * Function (method) calls
@@ -912,13 +999,13 @@ DUK_EXTERNAL_DECL duk_bool_t duk_instanceof(duk_context *ctx, duk_idx_t index1,
912
999
 
913
1000
  DUK_EXTERNAL_DECL void duk_call(duk_context *ctx, duk_idx_t nargs);
914
1001
  DUK_EXTERNAL_DECL void duk_call_method(duk_context *ctx, duk_idx_t nargs);
915
- DUK_EXTERNAL_DECL void duk_call_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs);
1002
+ DUK_EXTERNAL_DECL void duk_call_prop(duk_context *ctx, duk_idx_t obj_idx, duk_idx_t nargs);
916
1003
  DUK_EXTERNAL_DECL duk_int_t duk_pcall(duk_context *ctx, duk_idx_t nargs);
917
1004
  DUK_EXTERNAL_DECL duk_int_t duk_pcall_method(duk_context *ctx, duk_idx_t nargs);
918
- DUK_EXTERNAL_DECL duk_int_t duk_pcall_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs);
1005
+ DUK_EXTERNAL_DECL duk_int_t duk_pcall_prop(duk_context *ctx, duk_idx_t obj_idx, duk_idx_t nargs);
919
1006
  DUK_EXTERNAL_DECL void duk_new(duk_context *ctx, duk_idx_t nargs);
920
1007
  DUK_EXTERNAL_DECL duk_int_t duk_pnew(duk_context *ctx, duk_idx_t nargs);
921
- 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);
1008
+ 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);
922
1009
 
923
1010
  /*
924
1011
  * Thread management
@@ -937,103 +1024,72 @@ DUK_EXTERNAL_DECL duk_int_t duk_compile_raw(duk_context *ctx, const char *src_bu
937
1024
 
938
1025
  /* plain */
939
1026
  #define duk_eval(ctx) \
940
- ((void) duk_eval_raw((ctx), NULL, 0, 2 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOFILENAME))
1027
+ ((void) duk_eval_raw((ctx), NULL, 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOFILENAME))
941
1028
 
942
1029
  #define duk_eval_noresult(ctx) \
943
- ((void) duk_eval_raw((ctx), NULL, 0, 2 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))
1030
+ ((void) duk_eval_raw((ctx), NULL, 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))
944
1031
 
945
1032
  #define duk_peval(ctx) \
946
- (duk_eval_raw((ctx), NULL, 0, 2 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOFILENAME))
1033
+ (duk_eval_raw((ctx), NULL, 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOFILENAME))
947
1034
 
948
1035
  #define duk_peval_noresult(ctx) \
949
- (duk_eval_raw((ctx), NULL, 0, 2 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))
1036
+ (duk_eval_raw((ctx), NULL, 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))
950
1037
 
951
1038
  #define duk_compile(ctx,flags) \
952
- ((void) duk_compile_raw((ctx), NULL, 0, 3 /*args*/ | (flags)))
1039
+ ((void) duk_compile_raw((ctx), NULL, 0, 2 /*args*/ | (flags)))
953
1040
 
954
1041
  #define duk_pcompile(ctx,flags) \
955
- (duk_compile_raw((ctx), NULL, 0, 3 /*args*/ | (flags) | DUK_COMPILE_SAFE))
1042
+ (duk_compile_raw((ctx), NULL, 0, 2 /*args*/ | (flags) | DUK_COMPILE_SAFE))
956
1043
 
957
1044
  /* string */
958
1045
  #define duk_eval_string(ctx,src) \
959
- ((void) duk_eval_raw((ctx), (src), 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))
1046
+ ((void) duk_eval_raw((ctx), (src), 0, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))
960
1047
 
961
1048
  #define duk_eval_string_noresult(ctx,src) \
962
- ((void) duk_eval_raw((ctx), (src), 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))
1049
+ ((void) duk_eval_raw((ctx), (src), 0, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))
963
1050
 
964
1051
  #define duk_peval_string(ctx,src) \
965
- (duk_eval_raw((ctx), (src), 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))
1052
+ (duk_eval_raw((ctx), (src), 0, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))
966
1053
 
967
1054
  #define duk_peval_string_noresult(ctx,src) \
968
- (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))
1055
+ (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))
969
1056
 
970
1057
  #define duk_compile_string(ctx,flags,src) \
971
- ((void) duk_compile_raw((ctx), (src), 0, 1 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))
1058
+ ((void) duk_compile_raw((ctx), (src), 0, 0 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))
972
1059
 
973
1060
  #define duk_compile_string_filename(ctx,flags,src) \
974
- ((void) duk_compile_raw((ctx), (src), 0, 2 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN))
1061
+ ((void) duk_compile_raw((ctx), (src), 0, 1 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN))
975
1062
 
976
1063
  #define duk_pcompile_string(ctx,flags,src) \
977
- (duk_compile_raw((ctx), (src), 0, 1 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))
1064
+ (duk_compile_raw((ctx), (src), 0, 0 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))
978
1065
 
979
1066
  #define duk_pcompile_string_filename(ctx,flags,src) \
980
- (duk_compile_raw((ctx), (src), 0, 2 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN))
1067
+ (duk_compile_raw((ctx), (src), 0, 1 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN))
981
1068
 
982
1069
  /* lstring */
983
1070
  #define duk_eval_lstring(ctx,buf,len) \
984
- ((void) duk_eval_raw((ctx), buf, len, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NOFILENAME))
1071
+ ((void) duk_eval_raw((ctx), buf, len, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NOFILENAME))
985
1072
 
986
1073
  #define duk_eval_lstring_noresult(ctx,buf,len) \
987
- ((void) duk_eval_raw((ctx), buf, len, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))
1074
+ ((void) duk_eval_raw((ctx), buf, len, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))
988
1075
 
989
1076
  #define duk_peval_lstring(ctx,buf,len) \
990
- (duk_eval_raw((ctx), buf, len, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_SAFE | DUK_COMPILE_NOFILENAME))
1077
+ (duk_eval_raw((ctx), buf, len, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_SAFE | DUK_COMPILE_NOFILENAME))
991
1078
 
992
1079
  #define duk_peval_lstring_noresult(ctx,buf,len) \
993
- (duk_eval_raw((ctx), buf, len, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))
1080
+ (duk_eval_raw((ctx), buf, len, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))
994
1081
 
995
1082
  #define duk_compile_lstring(ctx,flags,buf,len) \
996
- ((void) duk_compile_raw((ctx), buf, len, 1 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NOFILENAME))
1083
+ ((void) duk_compile_raw((ctx), buf, len, 0 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NOFILENAME))
997
1084
 
998
1085
  #define duk_compile_lstring_filename(ctx,flags,buf,len) \
999
- ((void) duk_compile_raw((ctx), buf, len, 2 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE))
1086
+ ((void) duk_compile_raw((ctx), buf, len, 1 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE))
1000
1087
 
1001
1088
  #define duk_pcompile_lstring(ctx,flags,buf,len) \
1002
- (duk_compile_raw((ctx), buf, len, 1 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NOFILENAME))
1089
+ (duk_compile_raw((ctx), buf, len, 0 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NOFILENAME))
1003
1090
 
1004
1091
  #define duk_pcompile_lstring_filename(ctx,flags,buf,len) \
1005
- (duk_compile_raw((ctx), buf, len, 2 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE))
1006
-
1007
- /* file */
1008
- #define duk_eval_file(ctx,path) \
1009
- ((void) duk_push_string_file_raw((ctx), (path), 0), \
1010
- (void) duk_push_string((ctx), (path)), \
1011
- (void) duk_eval_raw((ctx), NULL, 0, 3 /*args*/ | DUK_COMPILE_EVAL))
1012
-
1013
- #define duk_eval_file_noresult(ctx,path) \
1014
- ((void) duk_push_string_file_raw((ctx), (path), 0), \
1015
- (void) duk_push_string((ctx), (path)), \
1016
- (void) duk_eval_raw((ctx), NULL, 0, 3 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NORESULT))
1017
-
1018
- #define duk_peval_file(ctx,path) \
1019
- ((void) duk_push_string_file_raw((ctx), (path), DUK_STRING_PUSH_SAFE), \
1020
- (void) duk_push_string((ctx), (path)), \
1021
- duk_eval_raw((ctx), NULL, 0, 3 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE))
1022
-
1023
- #define duk_peval_file_noresult(ctx,path) \
1024
- ((void) duk_push_string_file_raw((ctx), (path), DUK_STRING_PUSH_SAFE), \
1025
- (void) duk_push_string((ctx), (path)), \
1026
- duk_eval_raw((ctx), NULL, 0, 3 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NORESULT))
1027
-
1028
- #define duk_compile_file(ctx,flags,path) \
1029
- ((void) duk_push_string_file_raw((ctx), (path), 0), \
1030
- (void) duk_push_string((ctx), (path)), \
1031
- (void) duk_compile_raw((ctx), NULL, 0, 3 /*args*/ | (flags)))
1032
-
1033
- #define duk_pcompile_file(ctx,flags,path) \
1034
- ((void) duk_push_string_file_raw((ctx), (path), DUK_STRING_PUSH_SAFE), \
1035
- (void) duk_push_string((ctx), (path)), \
1036
- duk_compile_raw((ctx), NULL, 0, 3 /*args*/ | (flags) | DUK_COMPILE_SAFE))
1092
+ (duk_compile_raw((ctx), buf, len, 1 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE))
1037
1093
 
1038
1094
  /*
1039
1095
  * Bytecode load/dump
@@ -1042,58 +1098,38 @@ DUK_EXTERNAL_DECL duk_int_t duk_compile_raw(duk_context *ctx, const char *src_bu
1042
1098
  DUK_EXTERNAL_DECL void duk_dump_function(duk_context *ctx);
1043
1099
  DUK_EXTERNAL_DECL void duk_load_function(duk_context *ctx);
1044
1100
 
1045
- /*
1046
- * Logging
1047
- */
1048
-
1049
- DUK_EXTERNAL_DECL void duk_log(duk_context *ctx, duk_int_t level, const char *fmt, ...);
1050
- DUK_EXTERNAL_DECL void duk_log_va(duk_context *ctx, duk_int_t level, const char *fmt, va_list ap);
1051
-
1052
1101
  /*
1053
1102
  * Debugging
1054
1103
  */
1055
1104
 
1056
1105
  DUK_EXTERNAL_DECL void duk_push_context_dump(duk_context *ctx);
1057
1106
 
1058
- #if defined(DUK_USE_FILE_IO)
1059
- /* internal use */
1060
- #define duk_dump_context_filehandle(ctx,fh) \
1061
- (duk_push_context_dump((ctx)), \
1062
- DUK_FPRINTF((fh), "%s\n", duk_safe_to_string(ctx, -1)), \
1063
- duk_pop(ctx))
1064
-
1065
- /* external use */
1066
- #define duk_dump_context_stdout(ctx) \
1067
- duk_dump_context_filehandle((ctx), DUK_STDOUT)
1068
- #define duk_dump_context_stderr(ctx) \
1069
- duk_dump_context_filehandle((ctx), DUK_STDERR)
1070
- #else /* DUK_USE_FILE_IO */
1071
- #define duk_dump_context_stdout(ctx) ((void) 0)
1072
- #define duk_dump_context_stderr(ctx) ((void) 0)
1073
- #endif /* DUK_USE_FILE_IO */
1074
-
1075
1107
  /*
1076
1108
  * Debugger (debug protocol)
1077
1109
  */
1078
1110
 
1079
- #define duk_debugger_attach(ctx,read_cb,write_cb,peek_cb,read_flush_cb,write_flush_cb,detached_cb,udata) \
1080
- duk_debugger_attach_custom((ctx), (read_cb), (write_cb), (peek_cb), (read_flush_cb), (write_flush_cb), \
1081
- NULL, (detached_cb), (udata))
1082
-
1083
- DUK_EXTERNAL_DECL void duk_debugger_attach_custom(duk_context *ctx,
1084
- duk_debug_read_function read_cb,
1085
- duk_debug_write_function write_cb,
1086
- duk_debug_peek_function peek_cb,
1087
- duk_debug_read_flush_function read_flush_cb,
1088
- duk_debug_write_flush_function write_flush_cb,
1089
- duk_debug_request_function request_cb,
1090
- duk_debug_detached_function detached_cb,
1091
- void *udata);
1111
+ DUK_EXTERNAL_DECL void duk_debugger_attach(duk_context *ctx,
1112
+ duk_debug_read_function read_cb,
1113
+ duk_debug_write_function write_cb,
1114
+ duk_debug_peek_function peek_cb,
1115
+ duk_debug_read_flush_function read_flush_cb,
1116
+ duk_debug_write_flush_function write_flush_cb,
1117
+ duk_debug_request_function request_cb,
1118
+ duk_debug_detached_function detached_cb,
1119
+ void *udata);
1092
1120
  DUK_EXTERNAL_DECL void duk_debugger_detach(duk_context *ctx);
1093
1121
  DUK_EXTERNAL_DECL void duk_debugger_cooperate(duk_context *ctx);
1094
1122
  DUK_EXTERNAL_DECL duk_bool_t duk_debugger_notify(duk_context *ctx, duk_idx_t nvalues);
1095
1123
  DUK_EXTERNAL_DECL void duk_debugger_pause(duk_context *ctx);
1096
1124
 
1125
+ /*
1126
+ * Time handling
1127
+ */
1128
+
1129
+ DUK_EXTERNAL_DECL duk_double_t duk_get_now(duk_context *ctx);
1130
+ DUK_EXTERNAL_DECL void duk_time_to_components(duk_context *ctx, duk_double_t timeval, duk_time_components *comp);
1131
+ DUK_EXTERNAL_DECL duk_double_t duk_components_to_time(duk_context *ctx, duk_time_components *comp);
1132
+
1097
1133
  /*
1098
1134
  * Date provider related constants
1099
1135
  *
@@ -1130,7 +1166,7 @@ DUK_EXTERNAL_DECL void duk_debugger_pause(duk_context *ctx);
1130
1166
  * depend on the specific ordering, so change with care. 16 bits are not
1131
1167
  * enough for all parts (year, specifically).
1132
1168
  *
1133
- * (Must be in-sync with genbuiltins.py.)
1169
+ * Must be in-sync with genbuiltins.py.
1134
1170
  */
1135
1171
  #define DUK_DATE_IDX_YEAR 0 /* year */
1136
1172
  #define DUK_DATE_IDX_MONTH 1 /* month: 0 to 11 */
@@ -1142,7 +1178,7 @@ DUK_EXTERNAL_DECL void duk_debugger_pause(duk_context *ctx);
1142
1178
  #define DUK_DATE_IDX_WEEKDAY 7 /* weekday: 0 to 6, 0=sunday, 1=monday, etc */
1143
1179
  #define DUK_DATE_IDX_NUM_PARTS 8
1144
1180
 
1145
- /* Internal API call flags, used for various functions in this file.
1181
+ /* Internal API call flags, used for various functions in duk_bi_date.c.
1146
1182
  * Certain flags are used by only certain functions, but since the flags
1147
1183
  * don't overlap, a single flags value can be passed around to multiple
1148
1184
  * functions.
@@ -1150,7 +1186,7 @@ DUK_EXTERNAL_DECL void duk_debugger_pause(duk_context *ctx);
1150
1186
  * The unused top bits of the flags field are also used to pass values
1151
1187
  * to helpers (duk__get_part_helper() and duk__set_part_helper()).
1152
1188
  *
1153
- * (Must be in-sync with genbuiltins.py.)
1189
+ * Must be in-sync with genbuiltins.py.
1154
1190
  */
1155
1191
 
1156
1192
  /* NOTE: when writing a Date provider you only need a few specific
@@ -1187,7 +1223,7 @@ DUK_EXTERNAL_DECL const void * const duk_rom_compressed_pointers[];
1187
1223
  * C++ name mangling
1188
1224
  */
1189
1225
 
1190
- #ifdef __cplusplus
1226
+ #if defined(__cplusplus)
1191
1227
  /* end 'extern "C"' wrapper */
1192
1228
  }
1193
1229
  #endif
@@ -1248,7 +1284,7 @@ DUK_EXTERNAL_DECL const void * const duk_rom_compressed_pointers[];
1248
1284
  * duk_tval values. See: misc/clang_aliasing.c.
1249
1285
  */
1250
1286
 
1251
- #ifndef DUK_DBLUNION_H_INCLUDED
1287
+ #if !defined(DUK_DBLUNION_H_INCLUDED)
1252
1288
  #define DUK_DBLUNION_H_INCLUDED
1253
1289
 
1254
1290
  /*
@@ -1276,7 +1312,7 @@ typedef union duk_double_union duk_double_union;
1276
1312
  */
1277
1313
 
1278
1314
  #if defined(DUK_USE_DOUBLE_LE)
1279
- #ifdef DUK_USE_64BIT_OPS
1315
+ #if defined(DUK_USE_64BIT_OPS)
1280
1316
  #define DUK_DBL_IDX_ULL0 0
1281
1317
  #endif
1282
1318
  #define DUK_DBL_IDX_UI0 1
@@ -1296,7 +1332,7 @@ typedef union duk_double_union duk_double_union;
1296
1332
  #define DUK_DBL_IDX_VP0 DUK_DBL_IDX_UI0 /* packed tval */
1297
1333
  #define DUK_DBL_IDX_VP1 DUK_DBL_IDX_UI1 /* packed tval */
1298
1334
  #elif defined(DUK_USE_DOUBLE_BE)
1299
- #ifdef DUK_USE_64BIT_OPS
1335
+ #if defined(DUK_USE_64BIT_OPS)
1300
1336
  #define DUK_DBL_IDX_ULL0 0
1301
1337
  #endif
1302
1338
  #define DUK_DBL_IDX_UI0 0
@@ -1316,7 +1352,7 @@ typedef union duk_double_union duk_double_union;
1316
1352
  #define DUK_DBL_IDX_VP0 DUK_DBL_IDX_UI0 /* packed tval */
1317
1353
  #define DUK_DBL_IDX_VP1 DUK_DBL_IDX_UI1 /* packed tval */
1318
1354
  #elif defined(DUK_USE_DOUBLE_ME)
1319
- #ifdef DUK_USE_64BIT_OPS
1355
+ #if defined(DUK_USE_64BIT_OPS)
1320
1356
  #define DUK_DBL_IDX_ULL0 0 /* not directly applicable, byte order differs from a double */
1321
1357
  #endif
1322
1358
  #define DUK_DBL_IDX_UI0 0
@@ -1352,8 +1388,8 @@ typedef union duk_double_union duk_double_union;
1352
1388
  (u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) (v); \
1353
1389
  } while (0)
1354
1390
 
1355
- #ifdef DUK_USE_64BIT_OPS
1356
- #ifdef DUK_USE_DOUBLE_ME
1391
+ #if defined(DUK_USE_64BIT_OPS)
1392
+ #if defined(DUK_USE_DOUBLE_ME)
1357
1393
  #define DUK_DBLUNION_SET_HIGH32_ZERO_LOW32(u,v) do { \
1358
1394
  (u)->ull[DUK_DBL_IDX_ULL0] = (duk_uint64_t) (v); \
1359
1395
  } while (0)
@@ -1377,8 +1413,8 @@ typedef union duk_double_union duk_double_union;
1377
1413
  #define DUK_DBLUNION_GET_HIGH32(u) ((u)->ui[DUK_DBL_IDX_UI0])
1378
1414
  #define DUK_DBLUNION_GET_LOW32(u) ((u)->ui[DUK_DBL_IDX_UI1])
1379
1415
 
1380
- #ifdef DUK_USE_64BIT_OPS
1381
- #ifdef DUK_USE_DOUBLE_ME
1416
+ #if defined(DUK_USE_64BIT_OPS)
1417
+ #if defined(DUK_USE_DOUBLE_ME)
1382
1418
  #define DUK_DBLUNION_SET_UINT64(u,v) do { \
1383
1419
  (u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) ((v) >> 32); \
1384
1420
  (u)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (v); \
@@ -1418,70 +1454,98 @@ typedef union duk_double_union duk_double_union;
1418
1454
  * feature that while doubles have a mixed byte order (32107654), unsigned
1419
1455
  * long long values has a little endian byte order (76543210). When writing
1420
1456
  * a logical double value through a ULL pointer, the 32-bit words need to be
1421
- * swapped; hence the #ifdefs below for ULL writes with DUK_USE_DOUBLE_ME.
1457
+ * swapped; hence the #if defined()s below for ULL writes with DUK_USE_DOUBLE_ME.
1422
1458
  * This is not full ARM support but suffices for some environments.
1423
1459
  */
1424
1460
 
1425
- #ifdef DUK_USE_64BIT_OPS
1426
- #ifdef DUK_USE_DOUBLE_ME
1461
+ #if defined(DUK_USE_64BIT_OPS)
1462
+ #if defined(DUK_USE_DOUBLE_ME)
1463
+ /* Macros for 64-bit ops + mixed endian doubles. */
1427
1464
  #define DUK__DBLUNION_SET_NAN_FULL(u) do { \
1428
1465
  (u)->ull[DUK_DBL_IDX_ULL0] = 0x000000007ff80000ULL; \
1429
1466
  } while (0)
1467
+ #define DUK__DBLUNION_IS_NAN_FULL(u) \
1468
+ ((((u)->ull[DUK_DBL_IDX_ULL0] & 0x000000007ff00000ULL) == 0x000000007ff00000ULL) && \
1469
+ ((((u)->ull[DUK_DBL_IDX_ULL0]) & 0xffffffff000fffffULL) != 0))
1470
+ #define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \
1471
+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0x000000007ff80000ULL)
1472
+ #define DUK__DBLUNION_IS_ANYINF(u) \
1473
+ (((u)->ull[DUK_DBL_IDX_ULL0] & 0xffffffff7fffffffULL) == 0x000000007ff00000ULL)
1474
+ #define DUK__DBLUNION_IS_POSINF(u) \
1475
+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0x000000007ff00000ULL)
1476
+ #define DUK__DBLUNION_IS_NEGINF(u) \
1477
+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0x00000000fff00000ULL)
1478
+ #define DUK__DBLUNION_IS_ANYZERO(u) \
1479
+ (((u)->ull[DUK_DBL_IDX_ULL0] & 0xffffffff7fffffffULL) == 0x0000000000000000ULL)
1480
+ #define DUK__DBLUNION_IS_POSZERO(u) \
1481
+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0x0000000000000000ULL)
1482
+ #define DUK__DBLUNION_IS_NEGZERO(u) \
1483
+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0x0000000080000000ULL)
1430
1484
  #else
1485
+ /* Macros for 64-bit ops + big/little endian doubles. */
1431
1486
  #define DUK__DBLUNION_SET_NAN_FULL(u) do { \
1432
1487
  (u)->ull[DUK_DBL_IDX_ULL0] = 0x7ff8000000000000ULL; \
1433
1488
  } while (0)
1489
+ #define DUK__DBLUNION_IS_NAN_FULL(u) \
1490
+ ((((u)->ull[DUK_DBL_IDX_ULL0] & 0x7ff0000000000000ULL) == 0x7ff0000000000000UL) && \
1491
+ ((((u)->ull[DUK_DBL_IDX_ULL0]) & 0x000fffffffffffffULL) != 0))
1492
+ #define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \
1493
+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0x7ff8000000000000ULL)
1494
+ #define DUK__DBLUNION_IS_ANYINF(u) \
1495
+ (((u)->ull[DUK_DBL_IDX_ULL0] & 0x7fffffffffffffffULL) == 0x7ff0000000000000ULL)
1496
+ #define DUK__DBLUNION_IS_POSINF(u) \
1497
+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0x7ff0000000000000ULL)
1498
+ #define DUK__DBLUNION_IS_NEGINF(u) \
1499
+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0xfff0000000000000ULL)
1500
+ #define DUK__DBLUNION_IS_ANYZERO(u) \
1501
+ (((u)->ull[DUK_DBL_IDX_ULL0] & 0x7fffffffffffffffULL) == 0x0000000000000000ULL)
1502
+ #define DUK__DBLUNION_IS_POSZERO(u) \
1503
+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0x0000000000000000ULL)
1504
+ #define DUK__DBLUNION_IS_NEGZERO(u) \
1505
+ ((u)->ull[DUK_DBL_IDX_ULL0] == 0x8000000000000000ULL)
1434
1506
  #endif
1435
1507
  #else /* DUK_USE_64BIT_OPS */
1508
+ /* Macros for no 64-bit ops, any endianness. */
1436
1509
  #define DUK__DBLUNION_SET_NAN_FULL(u) do { \
1437
1510
  (u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) 0x7ff80000UL; \
1438
1511
  (u)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) 0x00000000UL; \
1439
1512
  } while (0)
1440
- #endif /* DUK_USE_64BIT_OPS */
1441
-
1442
- #define DUK__DBLUNION_SET_NAN_NOTFULL(u) do { \
1443
- (u)->us[DUK_DBL_IDX_US0] = 0x7ff8UL; \
1444
- } while (0)
1445
-
1446
- #ifdef DUK_USE_64BIT_OPS
1447
- #ifdef DUK_USE_DOUBLE_ME
1448
- #define DUK__DBLUNION_IS_NAN_FULL(u) \
1449
- /* E == 0x7ff, F != 0 => NaN */ \
1450
- ((((u)->us[DUK_DBL_IDX_US0] & 0x7ff0UL) == 0x7ff0UL) && \
1451
- ((((u)->ull[DUK_DBL_IDX_ULL0]) & 0xffffffff000fffffULL) != 0))
1452
- #else
1453
- #define DUK__DBLUNION_IS_NAN_FULL(u) \
1454
- /* E == 0x7ff, F != 0 => NaN */ \
1455
- ((((u)->us[DUK_DBL_IDX_US0] & 0x7ff0UL) == 0x7ff0UL) && \
1456
- ((((u)->ull[DUK_DBL_IDX_ULL0]) & 0x000fffffffffffffULL) != 0))
1457
- #endif
1458
- #else /* DUK_USE_64BIT_OPS */
1459
1513
  #define DUK__DBLUNION_IS_NAN_FULL(u) \
1460
- /* E == 0x7ff, F != 0 => NaN */ \
1461
1514
  ((((u)->ui[DUK_DBL_IDX_UI0] & 0x7ff00000UL) == 0x7ff00000UL) && \
1462
1515
  (((u)->ui[DUK_DBL_IDX_UI0] & 0x000fffffUL) != 0 || \
1463
1516
  (u)->ui[DUK_DBL_IDX_UI1] != 0))
1517
+ #define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \
1518
+ (((u)->ui[DUK_DBL_IDX_UI0] == 0x7ff80000UL) && \
1519
+ ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
1520
+ #define DUK__DBLUNION_IS_ANYINF(u) \
1521
+ ((((u)->ui[DUK_DBL_IDX_UI0] & 0x7fffffffUL) == 0x7ff00000UL) && \
1522
+ ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
1523
+ #define DUK__DBLUNION_IS_POSINF(u) \
1524
+ (((u)->ui[DUK_DBL_IDX_UI0] == 0x7ff00000UL) && \
1525
+ ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
1526
+ #define DUK__DBLUNION_IS_NEGINF(u) \
1527
+ (((u)->ui[DUK_DBL_IDX_UI0] == 0xfff00000UL) && \
1528
+ ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
1529
+ #define DUK__DBLUNION_IS_ANYZERO(u) \
1530
+ ((((u)->ui[DUK_DBL_IDX_UI0] & 0x7fffffffUL) == 0x00000000UL) && \
1531
+ ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
1532
+ #define DUK__DBLUNION_IS_POSZERO(u) \
1533
+ (((u)->ui[DUK_DBL_IDX_UI0] == 0x00000000UL) && \
1534
+ ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
1535
+ #define DUK__DBLUNION_IS_NEGZERO(u) \
1536
+ (((u)->ui[DUK_DBL_IDX_UI0] == 0x80000000UL) && \
1537
+ ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
1464
1538
  #endif /* DUK_USE_64BIT_OPS */
1465
1539
 
1540
+ #define DUK__DBLUNION_SET_NAN_NOTFULL(u) do { \
1541
+ (u)->us[DUK_DBL_IDX_US0] = 0x7ff8UL; \
1542
+ } while (0)
1543
+
1466
1544
  #define DUK__DBLUNION_IS_NAN_NOTFULL(u) \
1467
1545
  /* E == 0x7ff, topmost four bits of F != 0 => assume NaN */ \
1468
1546
  ((((u)->us[DUK_DBL_IDX_US0] & 0x7ff0UL) == 0x7ff0UL) && \
1469
1547
  (((u)->us[DUK_DBL_IDX_US0] & 0x000fUL) != 0x0000UL))
1470
1548
 
1471
- #ifdef DUK_USE_64BIT_OPS
1472
- #ifdef DUK_USE_DOUBLE_ME
1473
- #define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \
1474
- ((u)->ull[DUK_DBL_IDX_ULL0] == 0x000000007ff80000ULL)
1475
- #else
1476
- #define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \
1477
- ((u)->ull[DUK_DBL_IDX_ULL0] == 0x7ff8000000000000ULL)
1478
- #endif
1479
- #else /* DUK_USE_64BIT_OPS */
1480
- #define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \
1481
- (((u)->ui[DUK_DBL_IDX_UI0] == 0x7ff80000UL) && \
1482
- ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
1483
- #endif /* DUK_USE_64BIT_OPS */
1484
-
1485
1549
  #define DUK__DBLUNION_IS_NORMALIZED_NAN_NOTFULL(u) \
1486
1550
  /* E == 0x7ff, F == 8 => normalized NaN */ \
1487
1551
  ((u)->us[DUK_DBL_IDX_US0] == 0x7ff8UL)
@@ -1521,8 +1585,8 @@ typedef union duk_double_union duk_double_union;
1521
1585
  DUK_DBLUNION_IS_NORMALIZED_NAN((u))) /* or is a normalized NaN */
1522
1586
  #else /* DUK_USE_PACKED_TVAL */
1523
1587
  #define DUK_DBLUNION_NORMALIZE_NAN_CHECK(u) /* nop: no need to normalize */
1524
- #define DUK_DBLUNION_IS_NAN(u) (DUK_ISNAN((u)->d))
1525
- #define DUK_DBLUNION_IS_NORMALIZED_NAN(u) (DUK_ISNAN((u)->d))
1588
+ #define DUK_DBLUNION_IS_NAN(u) DUK__DBLUNION_IS_NAN_FULL((u)) /* (DUK_ISNAN((u)->d)) */
1589
+ #define DUK_DBLUNION_IS_NORMALIZED_NAN(u) DUK__DBLUNION_IS_NAN_FULL((u)) /* (DUK_ISNAN((u)->d)) */
1526
1590
  #define DUK_DBLUNION_IS_NORMALIZED(u) 1 /* all doubles are considered normalized */
1527
1591
  #define DUK_DBLUNION_SET_NAN(u) do { \
1528
1592
  /* in non-packed representation we don't care about which NaN is used */ \
@@ -1530,6 +1594,14 @@ typedef union duk_double_union duk_double_union;
1530
1594
  } while (0)
1531
1595
  #endif /* DUK_USE_PACKED_TVAL */
1532
1596
 
1597
+ #define DUK_DBLUNION_IS_ANYINF(u) DUK__DBLUNION_IS_ANYINF((u))
1598
+ #define DUK_DBLUNION_IS_POSINF(u) DUK__DBLUNION_IS_POSINF((u))
1599
+ #define DUK_DBLUNION_IS_NEGINF(u) DUK__DBLUNION_IS_NEGINF((u))
1600
+
1601
+ #define DUK_DBLUNION_IS_ANYZERO(u) DUK__DBLUNION_IS_ANYZERO((u))
1602
+ #define DUK_DBLUNION_IS_POSZERO(u) DUK__DBLUNION_IS_POSZERO((u))
1603
+ #define DUK_DBLUNION_IS_NEGZERO(u) DUK__DBLUNION_IS_NEGZERO((u))
1604
+
1533
1605
  /* XXX: native 64-bit byteswaps when available */
1534
1606
 
1535
1607
  /* 64-bit byteswap, same operation independent of target endianness. */
@@ -1575,6 +1647,15 @@ typedef union duk_double_union duk_double_union;
1575
1647
  /* Reverse operation is the same. */
1576
1648
  #define DUK_DBLUNION_DOUBLE_NTOH(u) DUK_DBLUNION_DOUBLE_HTON((u))
1577
1649
 
1650
+ /* Some sign bit helpers. */
1651
+ #if defined(DUK_USE_64BIT_OPS)
1652
+ #define DUK_DBLUNION_HAS_SIGNBIT(u) (((u)->ull[DUK_DBL_IDX_ULL0] & 0x8000000000000000ULL) != 0)
1653
+ #define DUK_DBLUNION_GET_SIGNBIT(u) (((u)->ull[DUK_DBL_IDX_ULL0] >> 63U))
1654
+ #else
1655
+ #define DUK_DBLUNION_HAS_SIGNBIT(u) (((u)->ui[DUK_DBL_IDX_UI0] & 0x80000000UL) != 0)
1656
+ #define DUK_DBLUNION_GET_SIGNBIT(u) (((u)->ui[DUK_DBL_IDX_UI0] >> 31U))
1657
+ #endif
1658
+
1578
1659
  #endif /* DUK_DBLUNION_H_INCLUDED */
1579
1660
 
1580
1661
  #endif /* DUKTAPE_H_INCLUDED */