Mercurial > malikania

comparison extern/duktape/duktape.h @ 182:3107ce017c3a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Misc: switch back to SDL Qt Quick and QML was an exciting experiment but it's definitely not enough flexible and easy to use for game development. Using SDL2 will let us focusing on our own drawing functions without any kind of overhead. While here, start massive cleanup.
author David Demelier <markand@malikania.fr>
date Fri, 19 Oct 2018 20:18:19 +0200
parents
children
comparison
equal deleted inserted replaced
181:fbfc2555bda5 182:3107ce017c3a
1 /*
2 * Duktape public API for Duktape 2.1.0.
3 *
4 * See the API reference for documentation on call semantics. The exposed,
5 * supported API is between the "BEGIN PUBLIC API" and "END PUBLIC API"
6 * comments. Other parts of the header are Duktape internal and related to
7 * e.g. platform/compiler/feature detection.
8 *
9 * Git commit 1f1f51a4f9595ffe8def0e9ba45b20f14679393a (v2.1.0).
10 * Git branch master.
11 *
12 * See Duktape AUTHORS.rst and LICENSE.txt for copyright and
13 * licensing information.
14 */
15
16 /* LICENSE.txt */
17 /*
18 * ===============
19 * Duktape license
20 * ===============
21 *
22 * (http://opensource.org/licenses/MIT)
23 *
24 * Copyright (c) 2013-2017 by Duktape authors (see AUTHORS.rst)
25 *
26 * Permission is hereby granted, free of charge, to any person obtaining a copy
27 * of this software and associated documentation files (the "Software"), to deal
28 * in the Software without restriction, including without limitation the rights
29 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
30 * copies of the Software, and to permit persons to whom the Software is
31 * furnished to do so, subject to the following conditions:
32 *
33 * The above copyright notice and this permission notice shall be included in
34 * all copies or substantial portions of the Software.
35 *
36 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
37 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
38 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
39 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
40 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
41 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
42 * THE SOFTWARE.
43 */
44
45 /* AUTHORS.rst */
46 /*
47 * ===============
48 * Duktape authors
49 * ===============
50 *
51 * Copyright
52 * =========
53 *
54 * Duktape copyrights are held by its authors. Each author has a copyright
55 * to their contribution, and agrees to irrevocably license the contribution
56 * under the Duktape ``LICENSE.txt``.
57 *
58 * Authors
59 * =======
60 *
61 * Please include an e-mail address, a link to your GitHub profile, or something
62 * similar to allow your contribution to be identified accurately.
63 *
64 * The following people have contributed code, website contents, or Wiki contents,
65 * and agreed to irrevocably license their contributions under the Duktape
66 * ``LICENSE.txt`` (in order of appearance):
67 *
68 * * Sami Vaarala <sami.vaarala@iki.fi>
69 * * Niki Dobrev
70 * * Andreas \u00d6man <andreas@lonelycoder.com>
71 * * L\u00e1szl\u00f3 Lang\u00f3 <llango.u-szeged@partner.samsung.com>
72 * * Legimet <legimet.calc@gmail.com>
73 * * Karl Skomski <karl@skomski.com>
74 * * Bruce Pascoe <fatcerberus1@gmail.com>
75 * * Ren\u00e9 Hollander <rene@rene8888.at>
76 * * Julien Hamaide (https://github.com/crazyjul)
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)
90 * * Romero Malaquias (rbsm@ic.ufal.br)
91 * * Michael Drake <michael.drake@codethink.co.uk>
92 *
93 * Other contributions
94 * ===================
95 *
96 * The following people have contributed something other than code (e.g. reported
97 * bugs, provided ideas, etc; roughly in order of appearance):
98 *
99 * * Greg Burns
100 * * Anthony Rabine
101 * * Carlos Costa
102 * * Aur\u00e9lien Bouilland
103 * * Preet Desai (Pris Matic)
104 * * judofyr (http://www.reddit.com/user/judofyr)
105 * * Jason Woofenden
106 * * Micha\u0142 Przyby\u015b
107 * * Anthony Howe
108 * * Conrad Pankoff
109 * * Jim Schimpf
110 * * Rajaran Gaunker (https://github.com/zimbabao)
111 * * Andreas \u00d6man
112 * * Doug Sanden
113 * * Josh Engebretson (https://github.com/JoshEngebretson)
114 * * Remo Eichenberger (https://github.com/remoe)
115 * * Mamod Mehyar (https://github.com/mamod)
116 * * David Demelier (https://github.com/markand)
117 * * Tim Caswell (https://github.com/creationix)
118 * * Mitchell Blank Jr (https://github.com/mitchblank)
119 * * https://github.com/yushli
120 * * Seo Sanghyeon (https://github.com/sanxiyn)
121 * * Han ChoongWoo (https://github.com/tunz)
122 * * Joshua Peek (https://github.com/josh)
123 * * Bruce E. Pascoe (https://github.com/fatcerberus)
124 * * https://github.com/Kelledin
125 * * https://github.com/sstruchtrup
126 * * Michael Drake (https://github.com/tlsa)
127 * * https://github.com/chris-y
128 * * Laurent Zubiaur (https://github.com/lzubiaur)
129 * * Neil Kolban (https://github.com/nkolban)
130 *
131 * If you are accidentally missing from this list, send me an e-mail
132 * (``sami.vaarala@iki.fi``) and I'll fix the omission.
133 */
134
135 #if !defined(DUKTAPE_H_INCLUDED)
136 #define DUKTAPE_H_INCLUDED
137
138 #define DUK_SINGLE_FILE
139
140 /*
141 * BEGIN PUBLIC API
142 */
143
144 /*
145 * Version and Git commit identification
146 */
147
148 /* Duktape version, (major * 10000) + (minor * 100) + patch. Allows C code
149 * to #if (DUK_VERSION >= NNN) against Duktape API version. The same value
150 * is also available to Ecmascript code in Duktape.version. Unofficial
151 * development snapshots have 99 for patch level (e.g. 0.10.99 would be a
152 * development version after 0.10.0 but before the next official release).
153 */
154 #define DUK_VERSION 20100L
155
156 /* Git commit, describe, and branch for Duktape build. Useful for
157 * non-official snapshot builds so that application code can easily log
158 * which Duktape snapshot was used. Not available in the Ecmascript
159 * environment.
160 */
161 #define DUK_GIT_COMMIT "1f1f51a4f9595ffe8def0e9ba45b20f14679393a"
162 #define DUK_GIT_DESCRIBE "v2.1.0"
163 #define DUK_GIT_BRANCH "master"
164
165 /* External duk_config.h provides platform/compiler/OS dependent
166 * typedefs and macros, and DUK_USE_xxx config options so that
167 * the rest of Duktape doesn't need to do any feature detection.
168 * DUK_VERSION is defined before including so that configuration
169 * snippets can react to it.
170 */
171 #include "duk_config.h"
172
173 /*
174 * Avoid C++ name mangling
175 */
176
177 #if defined(__cplusplus)
178 extern "C" {
179 #endif
180
181 /*
182 * Some defines forwarded from feature detection
183 */
184
185 #undef DUK_API_VARIADIC_MACROS
186 #if defined(DUK_USE_VARIADIC_MACROS)
187 #define DUK_API_VARIADIC_MACROS
188 #endif
189
190 #define DUK_API_NORETURN(decl) DUK_NORETURN(decl)
191
192 /*
193 * Public API specific typedefs
194 *
195 * Many types are wrapped by Duktape for portability to rare platforms
196 * where e.g. 'int' is a 16-bit type. See practical typing discussion
197 * in Duktape web documentation.
198 */
199
200 struct duk_thread_state;
201 struct duk_memory_functions;
202 struct duk_function_list_entry;
203 struct duk_number_list_entry;
204 struct duk_time_components;
205
206 /* duk_context is now defined in duk_config.h because it may also be
207 * referenced there by prototypes.
208 */
209 typedef struct duk_thread_state duk_thread_state;
210 typedef struct duk_memory_functions duk_memory_functions;
211 typedef struct duk_function_list_entry duk_function_list_entry;
212 typedef struct duk_number_list_entry duk_number_list_entry;
213 typedef struct duk_time_components duk_time_components;
214
215 typedef duk_ret_t (*duk_c_function)(duk_context *ctx);
216 typedef void *(*duk_alloc_function) (void *udata, duk_size_t size);
217 typedef void *(*duk_realloc_function) (void *udata, void *ptr, duk_size_t size);
218 typedef void (*duk_free_function) (void *udata, void *ptr);
219 typedef void (*duk_fatal_function) (void *udata, const char *msg);
220 typedef void (*duk_decode_char_function) (void *udata, duk_codepoint_t codepoint);
221 typedef duk_codepoint_t (*duk_map_char_function) (void *udata, duk_codepoint_t codepoint);
222 typedef duk_ret_t (*duk_safe_call_function) (duk_context *ctx, void *udata);
223 typedef duk_size_t (*duk_debug_read_function) (void *udata, char *buffer, duk_size_t length);
224 typedef duk_size_t (*duk_debug_write_function) (void *udata, const char *buffer, duk_size_t length);
225 typedef duk_size_t (*duk_debug_peek_function) (void *udata);
226 typedef void (*duk_debug_read_flush_function) (void *udata);
227 typedef void (*duk_debug_write_flush_function) (void *udata);
228 typedef duk_idx_t (*duk_debug_request_function) (duk_context *ctx, void *udata, duk_idx_t nvalues);
229 typedef void (*duk_debug_detached_function) (duk_context *ctx, void *udata);
230
231 struct duk_thread_state {
232 /* XXX: Enough space to hold internal suspend/resume structure.
233 * This is rather awkward and to be fixed when the internal
234 * structure is visible for the public API header.
235 */
236 char data[128];
237 };
238
239 struct duk_memory_functions {
240 duk_alloc_function alloc_func;
241 duk_realloc_function realloc_func;
242 duk_free_function free_func;
243 void *udata;
244 };
245
246 struct duk_function_list_entry {
247 const char *key;
248 duk_c_function value;
249 duk_idx_t nargs;
250 };
251
252 struct duk_number_list_entry {
253 const char *key;
254 duk_double_t value;
255 };
256
257 struct duk_time_components {
258 duk_double_t year; /* year, e.g. 2016, Ecmascript year range */
259 duk_double_t month; /* month: 1-12 */
260 duk_double_t day; /* day: 1-31 */
261 duk_double_t hours; /* hour: 0-59 */
262 duk_double_t minutes; /* minute: 0-59 */
263 duk_double_t seconds; /* second: 0-59 (in POSIX time no leap second) */
264 duk_double_t milliseconds; /* may contain sub-millisecond fractions */
265 duk_double_t weekday; /* weekday: 0-6, 0=Sunday, 1=Monday, ..., 6=Saturday */
266 };
267
268 /*
269 * Constants
270 */
271
272 /* Duktape debug protocol version used by this build. */
273 #define DUK_DEBUG_PROTOCOL_VERSION 2
274
275 /* Used to represent invalid index; if caller uses this without checking,
276 * this index will map to a non-existent stack entry. Also used in some
277 * API calls as a marker to denote "no value".
278 */
279 #define DUK_INVALID_INDEX DUK_IDX_MIN
280
281 /* Indicates that a native function does not have a fixed number of args,
282 * and the argument stack should not be capped/extended at all.
283 */
284 #define DUK_VARARGS ((duk_int_t) (-1))
285
286 /* Number of value stack entries (in addition to actual call arguments)
287 * guaranteed to be allocated on entry to a Duktape/C function.
288 */
289 #define DUK_API_ENTRY_STACK 64
290
291 /* Value types, used by e.g. duk_get_type() */
292 #define DUK_TYPE_MIN 0
293 #define DUK_TYPE_NONE 0 /* no value, e.g. invalid index */
294 #define DUK_TYPE_UNDEFINED 1 /* Ecmascript undefined */
295 #define DUK_TYPE_NULL 2 /* Ecmascript null */
296 #define DUK_TYPE_BOOLEAN 3 /* Ecmascript boolean: 0 or 1 */
297 #define DUK_TYPE_NUMBER 4 /* Ecmascript number: double */
298 #define DUK_TYPE_STRING 5 /* Ecmascript string: CESU-8 / extended UTF-8 encoded */
299 #define DUK_TYPE_OBJECT 6 /* Ecmascript object: includes objects, arrays, functions, threads */
300 #define DUK_TYPE_BUFFER 7 /* fixed or dynamic, garbage collected byte buffer */
301 #define DUK_TYPE_POINTER 8 /* raw void pointer */
302 #define DUK_TYPE_LIGHTFUNC 9 /* lightweight function pointer */
303 #define DUK_TYPE_MAX 9
304
305 /* Value mask types, used by e.g. duk_get_type_mask() */
306 #define DUK_TYPE_MASK_NONE (1 << DUK_TYPE_NONE)
307 #define DUK_TYPE_MASK_UNDEFINED (1 << DUK_TYPE_UNDEFINED)
308 #define DUK_TYPE_MASK_NULL (1 << DUK_TYPE_NULL)
309 #define DUK_TYPE_MASK_BOOLEAN (1 << DUK_TYPE_BOOLEAN)
310 #define DUK_TYPE_MASK_NUMBER (1 << DUK_TYPE_NUMBER)
311 #define DUK_TYPE_MASK_STRING (1 << DUK_TYPE_STRING)
312 #define DUK_TYPE_MASK_OBJECT (1 << DUK_TYPE_OBJECT)
313 #define DUK_TYPE_MASK_BUFFER (1 << DUK_TYPE_BUFFER)
314 #define DUK_TYPE_MASK_POINTER (1 << DUK_TYPE_POINTER)
315 #define DUK_TYPE_MASK_LIGHTFUNC (1 << DUK_TYPE_LIGHTFUNC)
316 #define DUK_TYPE_MASK_THROW (1 << 10) /* internal flag value: throw if mask doesn't match */
317 #define DUK_TYPE_MASK_PROMOTE (1 << 11) /* internal flag value: promote to object if mask matches */
318
319 /* Coercion hints */
320 #define DUK_HINT_NONE 0 /* prefer number, unless input is a Date, in which
321 * case prefer string (E5 Section 8.12.8)
322 */
323 #define DUK_HINT_STRING 1 /* prefer string */
324 #define DUK_HINT_NUMBER 2 /* prefer number */
325
326 /* Enumeration flags for duk_enum() */
327 #define DUK_ENUM_INCLUDE_NONENUMERABLE (1 << 0) /* enumerate non-numerable properties in addition to enumerable */
328 #define DUK_ENUM_INCLUDE_HIDDEN (1 << 1) /* enumerate hidden symbols too (in Duktape 1.x called internal properties) */
329 #define DUK_ENUM_INCLUDE_SYMBOLS (1 << 2) /* enumerate symbols */
330 #define DUK_ENUM_EXCLUDE_STRINGS (1 << 3) /* exclude strings */
331 #define DUK_ENUM_OWN_PROPERTIES_ONLY (1 << 4) /* don't walk prototype chain, only check own properties */
332 #define DUK_ENUM_ARRAY_INDICES_ONLY (1 << 5) /* only enumerate array indices */
333 #define DUK_ENUM_SORT_ARRAY_INDICES (1 << 6) /* sort array indices (applied to full enumeration result, including inherited array indices) */
334 #define DUK_ENUM_NO_PROXY_BEHAVIOR (1 << 7) /* enumerate a proxy object itself without invoking proxy behavior */
335
336 /* Compilation flags for duk_compile() and duk_eval() */
337 /* DUK_COMPILE_xxx bits 0-2 are reserved for an internal 'nargs' argument.
338 */
339 #define DUK_COMPILE_EVAL (1 << 3) /* compile eval code (instead of global code) */
340 #define DUK_COMPILE_FUNCTION (1 << 4) /* compile function code (instead of global code) */
341 #define DUK_COMPILE_STRICT (1 << 5) /* use strict (outer) context for global, eval, or function code */
342 #define DUK_COMPILE_SHEBANG (1 << 6) /* allow shebang ('#! ...') comment on first line of source */
343 #define DUK_COMPILE_SAFE (1 << 7) /* (internal) catch compilation errors */
344 #define DUK_COMPILE_NORESULT (1 << 8) /* (internal) omit eval result */
345 #define DUK_COMPILE_NOSOURCE (1 << 9) /* (internal) no source string on stack */
346 #define DUK_COMPILE_STRLEN (1 << 10) /* (internal) take strlen() of src_buffer (avoids double evaluation in macro) */
347 #define DUK_COMPILE_NOFILENAME (1 << 11) /* (internal) no filename on stack */
348 #define DUK_COMPILE_FUNCEXPR (1 << 12) /* (internal) source is a function expression (used for Function constructor) */
349
350 /* Flags for duk_def_prop() and its variants */
351 #define DUK_DEFPROP_WRITABLE (1 << 0) /* set writable (effective if DUK_DEFPROP_HAVE_WRITABLE set) */
352 #define DUK_DEFPROP_ENUMERABLE (1 << 1) /* set enumerable (effective if DUK_DEFPROP_HAVE_ENUMERABLE set) */
353 #define DUK_DEFPROP_CONFIGURABLE (1 << 2) /* set configurable (effective if DUK_DEFPROP_HAVE_CONFIGURABLE set) */
354 #define DUK_DEFPROP_HAVE_WRITABLE (1 << 3) /* set/clear writable */
355 #define DUK_DEFPROP_HAVE_ENUMERABLE (1 << 4) /* set/clear enumerable */
356 #define DUK_DEFPROP_HAVE_CONFIGURABLE (1 << 5) /* set/clear configurable */
357 #define DUK_DEFPROP_HAVE_VALUE (1 << 6) /* set value (given on value stack) */
358 #define DUK_DEFPROP_HAVE_GETTER (1 << 7) /* set getter (given on value stack) */
359 #define DUK_DEFPROP_HAVE_SETTER (1 << 8) /* set setter (given on value stack) */
360 #define DUK_DEFPROP_FORCE (1 << 9) /* force change if possible, may still fail for e.g. virtual properties */
361 #define DUK_DEFPROP_SET_WRITABLE (DUK_DEFPROP_HAVE_WRITABLE | DUK_DEFPROP_WRITABLE)
362 #define DUK_DEFPROP_CLEAR_WRITABLE DUK_DEFPROP_HAVE_WRITABLE
363 #define DUK_DEFPROP_SET_ENUMERABLE (DUK_DEFPROP_HAVE_ENUMERABLE | DUK_DEFPROP_ENUMERABLE)
364 #define DUK_DEFPROP_CLEAR_ENUMERABLE DUK_DEFPROP_HAVE_ENUMERABLE
365 #define DUK_DEFPROP_SET_CONFIGURABLE (DUK_DEFPROP_HAVE_CONFIGURABLE | DUK_DEFPROP_CONFIGURABLE)
366 #define DUK_DEFPROP_CLEAR_CONFIGURABLE DUK_DEFPROP_HAVE_CONFIGURABLE
367
368 /* Flags for duk_push_thread_raw() */
369 #define DUK_THREAD_NEW_GLOBAL_ENV (1 << 0) /* create a new global environment */
370
371 /* Flags for duk_gc() */
372 #define DUK_GC_COMPACT (1 << 0) /* compact heap objects */
373
374 /* Error codes (must be 8 bits at most, see duk_error.h) */
375 #define DUK_ERR_NONE 0 /* no error (e.g. from duk_get_error_code()) */
376 #define DUK_ERR_ERROR 1 /* Error */
377 #define DUK_ERR_EVAL_ERROR 2 /* EvalError */
378 #define DUK_ERR_RANGE_ERROR 3 /* RangeError */
379 #define DUK_ERR_REFERENCE_ERROR 4 /* ReferenceError */
380 #define DUK_ERR_SYNTAX_ERROR 5 /* SyntaxError */
381 #define DUK_ERR_TYPE_ERROR 6 /* TypeError */
382 #define DUK_ERR_URI_ERROR 7 /* URIError */
383
384 /* Return codes for C functions (shortcut for throwing an error) */
385 #define DUK_RET_ERROR (-DUK_ERR_ERROR)
386 #define DUK_RET_EVAL_ERROR (-DUK_ERR_EVAL_ERROR)
387 #define DUK_RET_RANGE_ERROR (-DUK_ERR_RANGE_ERROR)
388 #define DUK_RET_REFERENCE_ERROR (-DUK_ERR_REFERENCE_ERROR)
389 #define DUK_RET_SYNTAX_ERROR (-DUK_ERR_SYNTAX_ERROR)
390 #define DUK_RET_TYPE_ERROR (-DUK_ERR_TYPE_ERROR)
391 #define DUK_RET_URI_ERROR (-DUK_ERR_URI_ERROR)
392
393 /* Return codes for protected calls (duk_safe_call(), duk_pcall()) */
394 #define DUK_EXEC_SUCCESS 0
395 #define DUK_EXEC_ERROR 1
396
397 /* Debug levels for DUK_USE_DEBUG_WRITE(). */
398 #define DUK_LEVEL_DEBUG 0
399 #define DUK_LEVEL_DDEBUG 1
400 #define DUK_LEVEL_DDDEBUG 2
401
402 /*
403 * If no variadic macros, __FILE__ and __LINE__ are passed through globals
404 * which is ugly and not thread safe.
405 */
406
407 #if !defined(DUK_API_VARIADIC_MACROS)
408 DUK_EXTERNAL_DECL const char *duk_api_global_filename;
409 DUK_EXTERNAL_DECL duk_int_t duk_api_global_line;
410 #endif
411
412 /*
413 * Context management
414 */
415
416 DUK_EXTERNAL_DECL
417 duk_context *duk_create_heap(duk_alloc_function alloc_func,
418 duk_realloc_function realloc_func,
419 duk_free_function free_func,
420 void *heap_udata,
421 duk_fatal_function fatal_handler);
422 DUK_EXTERNAL_DECL void duk_destroy_heap(duk_context *ctx);
423
424 DUK_EXTERNAL_DECL void duk_suspend(duk_context *ctx, duk_thread_state *state);
425 DUK_EXTERNAL_DECL void duk_resume(duk_context *ctx, const duk_thread_state *state);
426
427 #define duk_create_heap_default() \
428 duk_create_heap(NULL, NULL, NULL, NULL, NULL)
429
430 /*
431 * Memory management
432 *
433 * Raw functions have no side effects (cannot trigger GC).
434 */
435
436 DUK_EXTERNAL_DECL void *duk_alloc_raw(duk_context *ctx, duk_size_t size);
437 DUK_EXTERNAL_DECL void duk_free_raw(duk_context *ctx, void *ptr);
438 DUK_EXTERNAL_DECL void *duk_realloc_raw(duk_context *ctx, void *ptr, duk_size_t size);
439 DUK_EXTERNAL_DECL void *duk_alloc(duk_context *ctx, duk_size_t size);
440 DUK_EXTERNAL_DECL void duk_free(duk_context *ctx, void *ptr);
441 DUK_EXTERNAL_DECL void *duk_realloc(duk_context *ctx, void *ptr, duk_size_t size);
442 DUK_EXTERNAL_DECL void duk_get_memory_functions(duk_context *ctx, duk_memory_functions *out_funcs);
443 DUK_EXTERNAL_DECL void duk_gc(duk_context *ctx, duk_uint_t flags);
444
445 /*
446 * Error handling
447 */
448
449 DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_throw_raw(duk_context *ctx));
450 #define duk_throw(ctx) \
451 (duk_throw_raw((ctx)), (duk_ret_t) 0)
452 DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_fatal_raw(duk_context *ctx, const char *err_msg));
453 #define duk_fatal(ctx,err_msg) \
454 (duk_fatal_raw((ctx), (err_msg)), (duk_ret_t) 0)
455 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, ...));
456
457 #if defined(DUK_API_VARIADIC_MACROS)
458 #define duk_error(ctx,err_code,...) \
459 (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)
460 #define duk_generic_error(ctx,...) \
461 (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)
462 #define duk_eval_error(ctx,...) \
463 (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)
464 #define duk_range_error(ctx,...) \
465 (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)
466 #define duk_reference_error(ctx,...) \
467 (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)
468 #define duk_syntax_error(ctx,...) \
469 (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)
470 #define duk_type_error(ctx,...) \
471 (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)
472 #define duk_uri_error(ctx,...) \
473 (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)
474 #else /* DUK_API_VARIADIC_MACROS */
475 /* For legacy compilers without variadic macros a macro hack is used to allow
476 * variable arguments. While the macro allows "return duk_error(...)", it
477 * will fail with e.g. "(void) duk_error(...)". The calls are noreturn but
478 * with a return value to allow the "return duk_error(...)" idiom. This may
479 * cause some compiler warnings, but without noreturn the generated code is
480 * often worse. The same approach as with variadic macros (using
481 * "(duk_error(...), 0)") won't work due to the macro hack structure.
482 */
483 DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_error_stash(duk_context *ctx, duk_errcode_t err_code, const char *fmt, ...));
484 DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_generic_error_stash(duk_context *ctx, const char *fmt, ...));
485 DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_eval_error_stash(duk_context *ctx, const char *fmt, ...));
486 DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_range_error_stash(duk_context *ctx, const char *fmt, ...));
487 DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_reference_error_stash(duk_context *ctx, const char *fmt, ...));
488 DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_syntax_error_stash(duk_context *ctx, const char *fmt, ...));
489 DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_type_error_stash(duk_context *ctx, const char *fmt, ...));
490 DUK_API_NORETURN(DUK_EXTERNAL_DECL duk_ret_t duk_uri_error_stash(duk_context *ctx, const char *fmt, ...));
491 #define duk_error \
492 (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
493 duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
494 duk_error_stash) /* last value is func pointer, arguments follow in parens */
495 #define duk_generic_error \
496 (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
497 duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
498 duk_generic_error_stash)
499 #define duk_eval_error \
500 (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
501 duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
502 duk_eval_error_stash)
503 #define duk_range_error \
504 (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
505 duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
506 duk_range_error_stash)
507 #define duk_reference_error \
508 (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
509 duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
510 duk_reference_error_stash)
511 #define duk_syntax_error \
512 (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
513 duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
514 duk_syntax_error_stash)
515 #define duk_type_error \
516 (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
517 duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
518 duk_type_error_stash)
519 #define duk_uri_error \
520 (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
521 duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
522 duk_uri_error_stash)
523 #endif /* DUK_API_VARIADIC_MACROS */
524
525 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));
526
527 #define duk_error_va(ctx,err_code,fmt,ap) \
528 (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)
529 #define duk_generic_error_va(ctx,fmt,ap) \
530 (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)
531 #define duk_eval_error_va(ctx,fmt,ap) \
532 (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)
533 #define duk_range_error_va(ctx,fmt,ap) \
534 (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)
535 #define duk_reference_error_va(ctx,fmt,ap) \
536 (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)
537 #define duk_syntax_error_va(ctx,fmt,ap) \
538 (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)
539 #define duk_type_error_va(ctx,fmt,ap) \
540 (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)
541 #define duk_uri_error_va(ctx,fmt,ap) \
542 (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)
543
544 /*
545 * Other state related functions
546 */
547
548 DUK_EXTERNAL_DECL duk_bool_t duk_is_strict_call(duk_context *ctx);
549 DUK_EXTERNAL_DECL duk_bool_t duk_is_constructor_call(duk_context *ctx);
550
551 /*
552 * Stack management
553 */
554
555 DUK_EXTERNAL_DECL duk_idx_t duk_normalize_index(duk_context *ctx, duk_idx_t idx);
556 DUK_EXTERNAL_DECL duk_idx_t duk_require_normalize_index(duk_context *ctx, duk_idx_t idx);
557 DUK_EXTERNAL_DECL duk_bool_t duk_is_valid_index(duk_context *ctx, duk_idx_t idx);
558 DUK_EXTERNAL_DECL void duk_require_valid_index(duk_context *ctx, duk_idx_t idx);
559
560 DUK_EXTERNAL_DECL duk_idx_t duk_get_top(duk_context *ctx);
561 DUK_EXTERNAL_DECL void duk_set_top(duk_context *ctx, duk_idx_t idx);
562 DUK_EXTERNAL_DECL duk_idx_t duk_get_top_index(duk_context *ctx);
563 DUK_EXTERNAL_DECL duk_idx_t duk_require_top_index(duk_context *ctx);
564
565 /* Although extra/top could be an unsigned type here, using a signed type
566 * makes the API more robust to calling code calculation errors or corner
567 * cases (where caller might occasionally come up with negative values).
568 * Negative values are treated as zero, which is better than casting them
569 * to a large unsigned number. (This principle is used elsewhere in the
570 * API too.)
571 */
572 DUK_EXTERNAL_DECL duk_bool_t duk_check_stack(duk_context *ctx, duk_idx_t extra);
573 DUK_EXTERNAL_DECL void duk_require_stack(duk_context *ctx, duk_idx_t extra);
574 DUK_EXTERNAL_DECL duk_bool_t duk_check_stack_top(duk_context *ctx, duk_idx_t top);
575 DUK_EXTERNAL_DECL void duk_require_stack_top(duk_context *ctx, duk_idx_t top);
576
577 /*
578 * Stack manipulation (other than push/pop)
579 */
580
581 DUK_EXTERNAL_DECL void duk_swap(duk_context *ctx, duk_idx_t idx1, duk_idx_t idx2);
582 DUK_EXTERNAL_DECL void duk_swap_top(duk_context *ctx, duk_idx_t idx);
583 DUK_EXTERNAL_DECL void duk_dup(duk_context *ctx, duk_idx_t from_idx);
584 DUK_EXTERNAL_DECL void duk_dup_top(duk_context *ctx);
585 DUK_EXTERNAL_DECL void duk_insert(duk_context *ctx, duk_idx_t to_idx);
586 DUK_EXTERNAL_DECL void duk_replace(duk_context *ctx, duk_idx_t to_idx);
587 DUK_EXTERNAL_DECL void duk_copy(duk_context *ctx, duk_idx_t from_idx, duk_idx_t to_idx);
588 DUK_EXTERNAL_DECL void duk_remove(duk_context *ctx, duk_idx_t idx);
589 DUK_EXTERNAL_DECL void duk_xcopymove_raw(duk_context *to_ctx, duk_context *from_ctx, duk_idx_t count, duk_bool_t is_copy);
590
591 #define duk_xmove_top(to_ctx,from_ctx,count) \
592 duk_xcopymove_raw((to_ctx), (from_ctx), (count), 0 /*is_copy*/)
593 #define duk_xcopy_top(to_ctx,from_ctx,count) \
594 duk_xcopymove_raw((to_ctx), (from_ctx), (count), 1 /*is_copy*/)
595
596 /*
597 * Push operations
598 *
599 * Push functions return the absolute (relative to bottom of frame)
600 * position of the pushed value for convenience.
601 *
602 * Note: duk_dup() is technically a push.
603 */
604
605 DUK_EXTERNAL_DECL void duk_push_undefined(duk_context *ctx);
606 DUK_EXTERNAL_DECL void duk_push_null(duk_context *ctx);
607 DUK_EXTERNAL_DECL void duk_push_boolean(duk_context *ctx, duk_bool_t val);
608 DUK_EXTERNAL_DECL void duk_push_true(duk_context *ctx);
609 DUK_EXTERNAL_DECL void duk_push_false(duk_context *ctx);
610 DUK_EXTERNAL_DECL void duk_push_number(duk_context *ctx, duk_double_t val);
611 DUK_EXTERNAL_DECL void duk_push_nan(duk_context *ctx);
612 DUK_EXTERNAL_DECL void duk_push_int(duk_context *ctx, duk_int_t val);
613 DUK_EXTERNAL_DECL void duk_push_uint(duk_context *ctx, duk_uint_t val);
614 DUK_EXTERNAL_DECL const char *duk_push_string(duk_context *ctx, const char *str);
615 DUK_EXTERNAL_DECL const char *duk_push_lstring(duk_context *ctx, const char *str, duk_size_t len);
616 DUK_EXTERNAL_DECL void duk_push_pointer(duk_context *ctx, void *p);
617 DUK_EXTERNAL_DECL const char *duk_push_sprintf(duk_context *ctx, const char *fmt, ...);
618 DUK_EXTERNAL_DECL const char *duk_push_vsprintf(duk_context *ctx, const char *fmt, va_list ap);
619
620 DUK_EXTERNAL_DECL void duk_push_this(duk_context *ctx);
621 DUK_EXTERNAL_DECL void duk_push_current_function(duk_context *ctx);
622 DUK_EXTERNAL_DECL void duk_push_current_thread(duk_context *ctx);
623 DUK_EXTERNAL_DECL void duk_push_global_object(duk_context *ctx);
624 DUK_EXTERNAL_DECL void duk_push_heap_stash(duk_context *ctx);
625 DUK_EXTERNAL_DECL void duk_push_global_stash(duk_context *ctx);
626 DUK_EXTERNAL_DECL void duk_push_thread_stash(duk_context *ctx, duk_context *target_ctx);
627
628 DUK_EXTERNAL_DECL duk_idx_t duk_push_object(duk_context *ctx);
629 DUK_EXTERNAL_DECL duk_idx_t duk_push_bare_object(duk_context *ctx);
630 DUK_EXTERNAL_DECL duk_idx_t duk_push_array(duk_context *ctx);
631 DUK_EXTERNAL_DECL duk_idx_t duk_push_c_function(duk_context *ctx, duk_c_function func, duk_idx_t nargs);
632 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);
633 DUK_EXTERNAL_DECL duk_idx_t duk_push_thread_raw(duk_context *ctx, duk_uint_t flags);
634
635 #define duk_push_thread(ctx) \
636 duk_push_thread_raw((ctx), 0 /*flags*/)
637
638 #define duk_push_thread_new_globalenv(ctx) \
639 duk_push_thread_raw((ctx), DUK_THREAD_NEW_GLOBAL_ENV /*flags*/)
640
641 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, ...);
642
643 #if defined(DUK_API_VARIADIC_MACROS)
644 #define duk_push_error_object(ctx,err_code,...) \
645 duk_push_error_object_raw((ctx), (err_code), (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), __VA_ARGS__)
646 #else
647 DUK_EXTERNAL_DECL duk_idx_t duk_push_error_object_stash(duk_context *ctx, duk_errcode_t err_code, const char *fmt, ...);
648 /* Note: parentheses are required so that the comma expression works in assignments. */
649 #define duk_push_error_object \
650 (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
651 duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
652 duk_push_error_object_stash) /* last value is func pointer, arguments follow in parens */
653 #endif
654
655 DUK_EXTERNAL_DECL duk_idx_t duk_push_error_object_va_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, va_list ap);
656 #define duk_push_error_object_va(ctx,err_code,fmt,ap) \
657 duk_push_error_object_va_raw((ctx), (err_code), (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), (fmt), (ap))
658
659 #define DUK_BUF_FLAG_DYNAMIC (1 << 0) /* internal flag: dynamic buffer */
660 #define DUK_BUF_FLAG_EXTERNAL (1 << 1) /* internal flag: external buffer */
661 #define DUK_BUF_FLAG_NOZERO (1 << 2) /* internal flag: don't zero allocated buffer */
662
663 DUK_EXTERNAL_DECL void *duk_push_buffer_raw(duk_context *ctx, duk_size_t size, duk_small_uint_t flags);
664
665 #define duk_push_buffer(ctx,size,dynamic) \
666 duk_push_buffer_raw((ctx), (size), (dynamic) ? DUK_BUF_FLAG_DYNAMIC : 0)
667 #define duk_push_fixed_buffer(ctx,size) \
668 duk_push_buffer_raw((ctx), (size), 0 /*flags*/)
669 #define duk_push_dynamic_buffer(ctx,size) \
670 duk_push_buffer_raw((ctx), (size), DUK_BUF_FLAG_DYNAMIC /*flags*/)
671 #define duk_push_external_buffer(ctx) \
672 ((void) duk_push_buffer_raw((ctx), 0, DUK_BUF_FLAG_DYNAMIC | DUK_BUF_FLAG_EXTERNAL))
673
674 #define DUK_BUFOBJ_ARRAYBUFFER 0
675 #define DUK_BUFOBJ_NODEJS_BUFFER 1
676 #define DUK_BUFOBJ_DATAVIEW 2
677 #define DUK_BUFOBJ_INT8ARRAY 3
678 #define DUK_BUFOBJ_UINT8ARRAY 4
679 #define DUK_BUFOBJ_UINT8CLAMPEDARRAY 5
680 #define DUK_BUFOBJ_INT16ARRAY 6
681 #define DUK_BUFOBJ_UINT16ARRAY 7
682 #define DUK_BUFOBJ_INT32ARRAY 8
683 #define DUK_BUFOBJ_UINT32ARRAY 9
684 #define DUK_BUFOBJ_FLOAT32ARRAY 10
685 #define DUK_BUFOBJ_FLOAT64ARRAY 11
686
687 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);
688
689 DUK_EXTERNAL_DECL duk_idx_t duk_push_heapptr(duk_context *ctx, void *ptr);
690
691 /*
692 * Pop operations
693 */
694
695 DUK_EXTERNAL_DECL void duk_pop(duk_context *ctx);
696 DUK_EXTERNAL_DECL void duk_pop_n(duk_context *ctx, duk_idx_t count);
697 DUK_EXTERNAL_DECL void duk_pop_2(duk_context *ctx);
698 DUK_EXTERNAL_DECL void duk_pop_3(duk_context *ctx);
699
700 /*
701 * Type checks
702 *
703 * duk_is_none(), which would indicate whether index it outside of stack,
704 * is not needed; duk_is_valid_index() gives the same information.
705 */
706
707 DUK_EXTERNAL_DECL duk_int_t duk_get_type(duk_context *ctx, duk_idx_t idx);
708 DUK_EXTERNAL_DECL duk_bool_t duk_check_type(duk_context *ctx, duk_idx_t idx, duk_int_t type);
709 DUK_EXTERNAL_DECL duk_uint_t duk_get_type_mask(duk_context *ctx, duk_idx_t idx);
710 DUK_EXTERNAL_DECL duk_bool_t duk_check_type_mask(duk_context *ctx, duk_idx_t idx, duk_uint_t mask);
711
712 DUK_EXTERNAL_DECL duk_bool_t duk_is_undefined(duk_context *ctx, duk_idx_t idx);
713 DUK_EXTERNAL_DECL duk_bool_t duk_is_null(duk_context *ctx, duk_idx_t idx);
714 #define duk_is_null_or_undefined(ctx, idx) \
715 ((duk_get_type_mask((ctx), (idx)) & (DUK_TYPE_MASK_NULL | DUK_TYPE_MASK_UNDEFINED)) ? 1 : 0)
716
717 DUK_EXTERNAL_DECL duk_bool_t duk_is_boolean(duk_context *ctx, duk_idx_t idx);
718 DUK_EXTERNAL_DECL duk_bool_t duk_is_number(duk_context *ctx, duk_idx_t idx);
719 DUK_EXTERNAL_DECL duk_bool_t duk_is_nan(duk_context *ctx, duk_idx_t idx);
720 DUK_EXTERNAL_DECL duk_bool_t duk_is_string(duk_context *ctx, duk_idx_t idx);
721 DUK_EXTERNAL_DECL duk_bool_t duk_is_object(duk_context *ctx, duk_idx_t idx);
722 DUK_EXTERNAL_DECL duk_bool_t duk_is_buffer(duk_context *ctx, duk_idx_t idx);
723 DUK_EXTERNAL_DECL duk_bool_t duk_is_buffer_data(duk_context *ctx, duk_idx_t idx);
724 DUK_EXTERNAL_DECL duk_bool_t duk_is_pointer(duk_context *ctx, duk_idx_t idx);
725 DUK_EXTERNAL_DECL duk_bool_t duk_is_lightfunc(duk_context *ctx, duk_idx_t idx);
726
727 DUK_EXTERNAL_DECL duk_bool_t duk_is_symbol(duk_context *ctx, duk_idx_t idx);
728 DUK_EXTERNAL_DECL duk_bool_t duk_is_array(duk_context *ctx, duk_idx_t idx);
729 DUK_EXTERNAL_DECL duk_bool_t duk_is_function(duk_context *ctx, duk_idx_t idx);
730 DUK_EXTERNAL_DECL duk_bool_t duk_is_c_function(duk_context *ctx, duk_idx_t idx);
731 DUK_EXTERNAL_DECL duk_bool_t duk_is_ecmascript_function(duk_context *ctx, duk_idx_t idx);
732 DUK_EXTERNAL_DECL duk_bool_t duk_is_bound_function(duk_context *ctx, duk_idx_t idx);
733 DUK_EXTERNAL_DECL duk_bool_t duk_is_thread(duk_context *ctx, duk_idx_t idx);
734
735 #define duk_is_callable(ctx,idx) \
736 duk_is_function((ctx), (idx))
737 DUK_EXTERNAL_DECL duk_bool_t duk_is_dynamic_buffer(duk_context *ctx, duk_idx_t idx);
738 DUK_EXTERNAL_DECL duk_bool_t duk_is_fixed_buffer(duk_context *ctx, duk_idx_t idx);
739 DUK_EXTERNAL_DECL duk_bool_t duk_is_external_buffer(duk_context *ctx, duk_idx_t idx);
740
741 /* Buffers and lightfuncs are not considered primitive because they mimic
742 * objects and e.g. duk_to_primitive() will coerce them instead of returning
743 * them as is. Symbols are represented as strings internally.
744 */
745 #define duk_is_primitive(ctx,idx) \
746 duk_check_type_mask((ctx), (idx), DUK_TYPE_MASK_UNDEFINED | \
747 DUK_TYPE_MASK_NULL | \
748 DUK_TYPE_MASK_BOOLEAN | \
749 DUK_TYPE_MASK_NUMBER | \
750 DUK_TYPE_MASK_STRING | \
751 DUK_TYPE_MASK_POINTER)
752
753 /* Symbols are object coercible, covered by DUK_TYPE_MASK_STRING. */
754 #define duk_is_object_coercible(ctx,idx) \
755 duk_check_type_mask((ctx), (idx), DUK_TYPE_MASK_BOOLEAN | \
756 DUK_TYPE_MASK_NUMBER | \
757 DUK_TYPE_MASK_STRING | \
758 DUK_TYPE_MASK_OBJECT | \
759 DUK_TYPE_MASK_BUFFER | \
760 DUK_TYPE_MASK_POINTER | \
761 DUK_TYPE_MASK_LIGHTFUNC)
762
763 DUK_EXTERNAL_DECL duk_errcode_t duk_get_error_code(duk_context *ctx, duk_idx_t idx);
764 #define duk_is_error(ctx,idx) \
765 (duk_get_error_code((ctx), (idx)) != 0)
766 #define duk_is_eval_error(ctx,idx) \
767 (duk_get_error_code((ctx), (idx)) == DUK_ERR_EVAL_ERROR)
768 #define duk_is_range_error(ctx,idx) \
769 (duk_get_error_code((ctx), (idx)) == DUK_ERR_RANGE_ERROR)
770 #define duk_is_reference_error(ctx,idx) \
771 (duk_get_error_code((ctx), (idx)) == DUK_ERR_REFERENCE_ERROR)
772 #define duk_is_syntax_error(ctx,idx) \
773 (duk_get_error_code((ctx), (idx)) == DUK_ERR_SYNTAX_ERROR)
774 #define duk_is_type_error(ctx,idx) \
775 (duk_get_error_code((ctx), (idx)) == DUK_ERR_TYPE_ERROR)
776 #define duk_is_uri_error(ctx,idx) \
777 (duk_get_error_code((ctx), (idx)) == DUK_ERR_URI_ERROR)
778
779 /*
780 * Get operations: no coercion, returns default value for invalid
781 * indices and invalid value types.
782 *
783 * duk_get_undefined() and duk_get_null() would be pointless and
784 * are not included.
785 */
786
787 DUK_EXTERNAL_DECL duk_bool_t duk_get_boolean(duk_context *ctx, duk_idx_t idx);
788 DUK_EXTERNAL_DECL duk_double_t duk_get_number(duk_context *ctx, duk_idx_t idx);
789 DUK_EXTERNAL_DECL duk_int_t duk_get_int(duk_context *ctx, duk_idx_t idx);
790 DUK_EXTERNAL_DECL duk_uint_t duk_get_uint(duk_context *ctx, duk_idx_t idx);
791 DUK_EXTERNAL_DECL const char *duk_get_string(duk_context *ctx, duk_idx_t idx);
792 DUK_EXTERNAL_DECL const char *duk_get_lstring(duk_context *ctx, duk_idx_t idx, duk_size_t *out_len);
793 DUK_EXTERNAL_DECL void *duk_get_buffer(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size);
794 DUK_EXTERNAL_DECL void *duk_get_buffer_data(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size);
795 DUK_EXTERNAL_DECL void *duk_get_pointer(duk_context *ctx, duk_idx_t idx);
796 DUK_EXTERNAL_DECL duk_c_function duk_get_c_function(duk_context *ctx, duk_idx_t idx);
797 DUK_EXTERNAL_DECL duk_context *duk_get_context(duk_context *ctx, duk_idx_t idx);
798 DUK_EXTERNAL_DECL void *duk_get_heapptr(duk_context *ctx, duk_idx_t idx);
799
800 /*
801 * Get-with-explicit default operations: like get operations but with an
802 * explicit default value.
803 */
804
805 DUK_EXTERNAL_DECL duk_bool_t duk_get_boolean_default(duk_context *ctx, duk_idx_t idx, duk_bool_t def_value);
806 DUK_EXTERNAL_DECL duk_double_t duk_get_number_default(duk_context *ctx, duk_idx_t idx, duk_double_t def_value);
807 DUK_EXTERNAL_DECL duk_int_t duk_get_int_default(duk_context *ctx, duk_idx_t idx, duk_int_t def_value);
808 DUK_EXTERNAL_DECL duk_uint_t duk_get_uint_default(duk_context *ctx, duk_idx_t idx, duk_uint_t def_value);
809 DUK_EXTERNAL_DECL const char *duk_get_string_default(duk_context *ctx, duk_idx_t idx, const char *def_value);
810 DUK_EXTERNAL_DECL const char *duk_get_lstring_default(duk_context *ctx, duk_idx_t idx, duk_size_t *out_len, const char *def_ptr, duk_size_t def_len);
811 DUK_EXTERNAL_DECL void *duk_get_buffer_default(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size, void *def_ptr, duk_size_t def_len);
812 DUK_EXTERNAL_DECL void *duk_get_buffer_data_default(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size, void *def_ptr, duk_size_t def_len);
813 DUK_EXTERNAL_DECL void *duk_get_pointer_default(duk_context *ctx, duk_idx_t idx, void *def_value);
814 DUK_EXTERNAL_DECL duk_c_function duk_get_c_function_default(duk_context *ctx, duk_idx_t idx, duk_c_function def_value);
815 DUK_EXTERNAL_DECL duk_context *duk_get_context_default(duk_context *ctx, duk_idx_t idx, duk_context *def_value);
816 DUK_EXTERNAL_DECL void *duk_get_heapptr_default(duk_context *ctx, duk_idx_t idx, void *def_value);
817
818 /*
819 * Opt operations: like require operations but with an explicit default value
820 * when value is undefined or index is invalid, null and non-matching types
821 * cause a TypeError.
822 */
823
824 DUK_EXTERNAL_DECL duk_bool_t duk_opt_boolean(duk_context *ctx, duk_idx_t idx, duk_bool_t def_value);
825 DUK_EXTERNAL_DECL duk_double_t duk_opt_number(duk_context *ctx, duk_idx_t idx, duk_double_t def_value);
826 DUK_EXTERNAL_DECL duk_int_t duk_opt_int(duk_context *ctx, duk_idx_t idx, duk_int_t def_value);
827 DUK_EXTERNAL_DECL duk_uint_t duk_opt_uint(duk_context *ctx, duk_idx_t idx, duk_uint_t def_value);
828 DUK_EXTERNAL_DECL const char *duk_opt_string(duk_context *ctx, duk_idx_t idx, const char *def_ptr);
829 DUK_EXTERNAL_DECL const char *duk_opt_lstring(duk_context *ctx, duk_idx_t idx, duk_size_t *out_len, const char *def_ptr, duk_size_t def_len);
830 DUK_EXTERNAL_DECL void *duk_opt_buffer(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size, void *def_ptr, duk_size_t def_size);
831 DUK_EXTERNAL_DECL void *duk_opt_buffer_data(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size, void *def_ptr, duk_size_t def_size);
832 DUK_EXTERNAL_DECL void *duk_opt_pointer(duk_context *ctx, duk_idx_t idx, void *def_value);
833 DUK_EXTERNAL_DECL duk_c_function duk_opt_c_function(duk_context *ctx, duk_idx_t idx, duk_c_function def_value);
834 DUK_EXTERNAL_DECL duk_context *duk_opt_context(duk_context *ctx, duk_idx_t idx, duk_context *def_value);
835 DUK_EXTERNAL_DECL void *duk_opt_heapptr(duk_context *ctx, duk_idx_t idx, void *def_value);
836
837 /*
838 * Require operations: no coercion, throw error if index or type
839 * is incorrect. No defaulting.
840 */
841
842 #define duk_require_type_mask(ctx,idx,mask) \
843 ((void) duk_check_type_mask((ctx), (idx), (mask) | DUK_TYPE_MASK_THROW))
844
845 DUK_EXTERNAL_DECL void duk_require_undefined(duk_context *ctx, duk_idx_t idx);
846 DUK_EXTERNAL_DECL void duk_require_null(duk_context *ctx, duk_idx_t idx);
847 DUK_EXTERNAL_DECL duk_bool_t duk_require_boolean(duk_context *ctx, duk_idx_t idx);
848 DUK_EXTERNAL_DECL duk_double_t duk_require_number(duk_context *ctx, duk_idx_t idx);
849 DUK_EXTERNAL_DECL duk_int_t duk_require_int(duk_context *ctx, duk_idx_t idx);
850 DUK_EXTERNAL_DECL duk_uint_t duk_require_uint(duk_context *ctx, duk_idx_t idx);
851 DUK_EXTERNAL_DECL const char *duk_require_string(duk_context *ctx, duk_idx_t idx);
852 DUK_EXTERNAL_DECL const char *duk_require_lstring(duk_context *ctx, duk_idx_t idx, duk_size_t *out_len);
853 DUK_EXTERNAL_DECL void *duk_require_buffer(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size);
854 DUK_EXTERNAL_DECL void *duk_require_buffer_data(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size);
855 DUK_EXTERNAL_DECL void *duk_require_pointer(duk_context *ctx, duk_idx_t idx);
856 DUK_EXTERNAL_DECL duk_c_function duk_require_c_function(duk_context *ctx, duk_idx_t idx);
857 DUK_EXTERNAL_DECL duk_context *duk_require_context(duk_context *ctx, duk_idx_t idx);
858 DUK_EXTERNAL_DECL void duk_require_function(duk_context *ctx, duk_idx_t idx);
859 #define duk_require_callable(ctx,idx) \
860 duk_require_function((ctx), (idx))
861 DUK_EXTERNAL_DECL void *duk_require_heapptr(duk_context *ctx, duk_idx_t idx);
862
863 /* Symbols are object coercible and covered by DUK_TYPE_MASK_STRING. */
864 #define duk_require_object_coercible(ctx,idx) \
865 ((void) duk_check_type_mask((ctx), (idx), DUK_TYPE_MASK_BOOLEAN | \
866 DUK_TYPE_MASK_NUMBER | \
867 DUK_TYPE_MASK_STRING | \
868 DUK_TYPE_MASK_OBJECT | \
869 DUK_TYPE_MASK_BUFFER | \
870 DUK_TYPE_MASK_POINTER | \
871 DUK_TYPE_MASK_LIGHTFUNC | \
872 DUK_TYPE_MASK_THROW))
873
874 /*
875 * Coercion operations: in-place coercion, return coerced value where
876 * applicable. If index is invalid, throw error. Some coercions may
877 * throw an expected error (e.g. from a toString() or valueOf() call)
878 * or an internal error (e.g. from out of memory).
879 */
880
881 DUK_EXTERNAL_DECL void duk_to_undefined(duk_context *ctx, duk_idx_t idx);
882 DUK_EXTERNAL_DECL void duk_to_null(duk_context *ctx, duk_idx_t idx);
883 DUK_EXTERNAL_DECL duk_bool_t duk_to_boolean(duk_context *ctx, duk_idx_t idx);
884 DUK_EXTERNAL_DECL duk_double_t duk_to_number(duk_context *ctx, duk_idx_t idx);
885 DUK_EXTERNAL_DECL duk_int_t duk_to_int(duk_context *ctx, duk_idx_t idx);
886 DUK_EXTERNAL_DECL duk_uint_t duk_to_uint(duk_context *ctx, duk_idx_t idx);
887 DUK_EXTERNAL_DECL duk_int32_t duk_to_int32(duk_context *ctx, duk_idx_t idx);
888 DUK_EXTERNAL_DECL duk_uint32_t duk_to_uint32(duk_context *ctx, duk_idx_t idx);
889 DUK_EXTERNAL_DECL duk_uint16_t duk_to_uint16(duk_context *ctx, duk_idx_t idx);
890 DUK_EXTERNAL_DECL const char *duk_to_string(duk_context *ctx, duk_idx_t idx);
891 DUK_EXTERNAL_DECL const char *duk_to_lstring(duk_context *ctx, duk_idx_t idx, duk_size_t *out_len);
892 DUK_EXTERNAL_DECL void *duk_to_buffer_raw(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size, duk_uint_t flags);
893 DUK_EXTERNAL_DECL void *duk_to_pointer(duk_context *ctx, duk_idx_t idx);
894 DUK_EXTERNAL_DECL void duk_to_object(duk_context *ctx, duk_idx_t idx);
895 DUK_EXTERNAL_DECL void duk_to_primitive(duk_context *ctx, duk_idx_t idx, duk_int_t hint);
896
897 #define DUK_BUF_MODE_FIXED 0 /* internal: request fixed buffer result */
898 #define DUK_BUF_MODE_DYNAMIC 1 /* internal: request dynamic buffer result */
899 #define DUK_BUF_MODE_DONTCARE 2 /* internal: don't care about fixed/dynamic nature */
900
901 #define duk_to_buffer(ctx,idx,out_size) \
902 duk_to_buffer_raw((ctx), (idx), (out_size), DUK_BUF_MODE_DONTCARE)
903 #define duk_to_fixed_buffer(ctx,idx,out_size) \
904 duk_to_buffer_raw((ctx), (idx), (out_size), DUK_BUF_MODE_FIXED)
905 #define duk_to_dynamic_buffer(ctx,idx,out_size) \
906 duk_to_buffer_raw((ctx), (idx), (out_size), DUK_BUF_MODE_DYNAMIC)
907
908 /* safe variants of a few coercion operations */
909 DUK_EXTERNAL_DECL const char *duk_safe_to_lstring(duk_context *ctx, duk_idx_t idx, duk_size_t *out_len);
910 #define duk_safe_to_string(ctx,idx) \
911 duk_safe_to_lstring((ctx), (idx), NULL)
912
913 /*
914 * Value length
915 */
916
917 DUK_EXTERNAL_DECL duk_size_t duk_get_length(duk_context *ctx, duk_idx_t idx);
918 DUK_EXTERNAL_DECL void duk_set_length(duk_context *ctx, duk_idx_t idx, duk_size_t len);
919 #if 0
920 /* duk_require_length()? */
921 /* duk_opt_length()? */
922 #endif
923
924 /*
925 * Misc conversion
926 */
927
928 DUK_EXTERNAL_DECL const char *duk_base64_encode(duk_context *ctx, duk_idx_t idx);
929 DUK_EXTERNAL_DECL void duk_base64_decode(duk_context *ctx, duk_idx_t idx);
930 DUK_EXTERNAL_DECL const char *duk_hex_encode(duk_context *ctx, duk_idx_t idx);
931 DUK_EXTERNAL_DECL void duk_hex_decode(duk_context *ctx, duk_idx_t idx);
932 DUK_EXTERNAL_DECL const char *duk_json_encode(duk_context *ctx, duk_idx_t idx);
933 DUK_EXTERNAL_DECL void duk_json_decode(duk_context *ctx, duk_idx_t idx);
934
935 DUK_EXTERNAL_DECL const char *duk_buffer_to_string(duk_context *ctx, duk_idx_t idx);
936
937 /*
938 * Buffer
939 */
940
941 DUK_EXTERNAL_DECL void *duk_resize_buffer(duk_context *ctx, duk_idx_t idx, duk_size_t new_size);
942 DUK_EXTERNAL_DECL void *duk_steal_buffer(duk_context *ctx, duk_idx_t idx, duk_size_t *out_size);
943 DUK_EXTERNAL_DECL void duk_config_buffer(duk_context *ctx, duk_idx_t idx, void *ptr, duk_size_t len);
944
945 /*
946 * Property access
947 *
948 * The basic function assumes key is on stack. The _string variant takes
949 * a C string as a property name, while the _index variant takes an array
950 * index as a property name (e.g. 123 is equivalent to the key "123").
951 */
952
953 DUK_EXTERNAL_DECL duk_bool_t duk_get_prop(duk_context *ctx, duk_idx_t obj_idx);
954 DUK_EXTERNAL_DECL duk_bool_t duk_get_prop_string(duk_context *ctx, duk_idx_t obj_idx, const char *key);
955 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);
956 DUK_EXTERNAL_DECL duk_bool_t duk_get_prop_index(duk_context *ctx, duk_idx_t obj_idx, duk_uarridx_t arr_idx);
957 DUK_EXTERNAL_DECL duk_bool_t duk_put_prop(duk_context *ctx, duk_idx_t obj_idx);
958 DUK_EXTERNAL_DECL duk_bool_t duk_put_prop_string(duk_context *ctx, duk_idx_t obj_idx, const char *key);
959 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);
960 DUK_EXTERNAL_DECL duk_bool_t duk_put_prop_index(duk_context *ctx, duk_idx_t obj_idx, duk_uarridx_t arr_idx);
961 DUK_EXTERNAL_DECL duk_bool_t duk_del_prop(duk_context *ctx, duk_idx_t obj_idx);
962 DUK_EXTERNAL_DECL duk_bool_t duk_del_prop_string(duk_context *ctx, duk_idx_t obj_idx, const char *key);
963 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);
964 DUK_EXTERNAL_DECL duk_bool_t duk_del_prop_index(duk_context *ctx, duk_idx_t obj_idx, duk_uarridx_t arr_idx);
965 DUK_EXTERNAL_DECL duk_bool_t duk_has_prop(duk_context *ctx, duk_idx_t obj_idx);
966 DUK_EXTERNAL_DECL duk_bool_t duk_has_prop_string(duk_context *ctx, duk_idx_t obj_idx, const char *key);
967 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);
968 DUK_EXTERNAL_DECL duk_bool_t duk_has_prop_index(duk_context *ctx, duk_idx_t obj_idx, duk_uarridx_t arr_idx);
969
970 DUK_EXTERNAL_DECL void duk_get_prop_desc(duk_context *ctx, duk_idx_t obj_idx, duk_uint_t flags);
971 DUK_EXTERNAL_DECL void duk_def_prop(duk_context *ctx, duk_idx_t obj_idx, duk_uint_t flags);
972
973 DUK_EXTERNAL_DECL duk_bool_t duk_get_global_string(duk_context *ctx, const char *key);
974 DUK_EXTERNAL_DECL duk_bool_t duk_get_global_lstring(duk_context *ctx, const char *key, duk_size_t key_len);
975 DUK_EXTERNAL_DECL duk_bool_t duk_put_global_string(duk_context *ctx, const char *key);
976 DUK_EXTERNAL_DECL duk_bool_t duk_put_global_lstring(duk_context *ctx, const char *key, duk_size_t key_len);
977
978 /*
979 * Inspection
980 */
981
982 DUK_EXTERNAL_DECL void duk_inspect_value(duk_context *ctx, duk_idx_t idx);
983 DUK_EXTERNAL_DECL void duk_inspect_callstack_entry(duk_context *ctx, duk_int_t level);
984
985 /*
986 * Object prototype
987 */
988
989 DUK_EXTERNAL_DECL void duk_get_prototype(duk_context *ctx, duk_idx_t idx);
990 DUK_EXTERNAL_DECL void duk_set_prototype(duk_context *ctx, duk_idx_t idx);
991
992 /*
993 * Object finalizer
994 */
995
996 DUK_EXTERNAL_DECL void duk_get_finalizer(duk_context *ctx, duk_idx_t idx);
997 DUK_EXTERNAL_DECL void duk_set_finalizer(duk_context *ctx, duk_idx_t idx);
998
999 /*
1000 * Global object
1001 */
1002
1003 DUK_EXTERNAL_DECL void duk_set_global_object(duk_context *ctx);
1004
1005 /*
1006 * Duktape/C function magic value
1007 */
1008
1009 DUK_EXTERNAL_DECL duk_int_t duk_get_magic(duk_context *ctx, duk_idx_t idx);
1010 DUK_EXTERNAL_DECL void duk_set_magic(duk_context *ctx, duk_idx_t idx, duk_int_t magic);
1011 DUK_EXTERNAL_DECL duk_int_t duk_get_current_magic(duk_context *ctx);
1012
1013 /*
1014 * Module helpers: put multiple function or constant properties
1015 */
1016
1017 DUK_EXTERNAL_DECL void duk_put_function_list(duk_context *ctx, duk_idx_t obj_idx, const duk_function_list_entry *funcs);
1018 DUK_EXTERNAL_DECL void duk_put_number_list(duk_context *ctx, duk_idx_t obj_idx, const duk_number_list_entry *numbers);
1019
1020 /*
1021 * Object operations
1022 */
1023
1024 DUK_EXTERNAL_DECL void duk_compact(duk_context *ctx, duk_idx_t obj_idx);
1025 DUK_EXTERNAL_DECL void duk_enum(duk_context *ctx, duk_idx_t obj_idx, duk_uint_t enum_flags);
1026 DUK_EXTERNAL_DECL duk_bool_t duk_next(duk_context *ctx, duk_idx_t enum_idx, duk_bool_t get_value);
1027
1028 /*
1029 * String manipulation
1030 */
1031
1032 DUK_EXTERNAL_DECL void duk_concat(duk_context *ctx, duk_idx_t count);
1033 DUK_EXTERNAL_DECL void duk_join(duk_context *ctx, duk_idx_t count);
1034 DUK_EXTERNAL_DECL void duk_decode_string(duk_context *ctx, duk_idx_t idx, duk_decode_char_function callback, void *udata);
1035 DUK_EXTERNAL_DECL void duk_map_string(duk_context *ctx, duk_idx_t idx, duk_map_char_function callback, void *udata);
1036 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);
1037 DUK_EXTERNAL_DECL void duk_trim(duk_context *ctx, duk_idx_t idx);
1038 DUK_EXTERNAL_DECL duk_codepoint_t duk_char_code_at(duk_context *ctx, duk_idx_t idx, duk_size_t char_offset);
1039
1040 /*
1041 * Ecmascript operators
1042 */
1043
1044 DUK_EXTERNAL_DECL duk_bool_t duk_equals(duk_context *ctx, duk_idx_t idx1, duk_idx_t idx2);
1045 DUK_EXTERNAL_DECL duk_bool_t duk_strict_equals(duk_context *ctx, duk_idx_t idx1, duk_idx_t idx2);
1046 DUK_EXTERNAL_DECL duk_bool_t duk_samevalue(duk_context *ctx, duk_idx_t idx1, duk_idx_t idx2);
1047 DUK_EXTERNAL_DECL duk_bool_t duk_instanceof(duk_context *ctx, duk_idx_t idx1, duk_idx_t idx2);
1048
1049 /*
1050 * Function (method) calls
1051 */
1052
1053 DUK_EXTERNAL_DECL void duk_call(duk_context *ctx, duk_idx_t nargs);
1054 DUK_EXTERNAL_DECL void duk_call_method(duk_context *ctx, duk_idx_t nargs);
1055 DUK_EXTERNAL_DECL void duk_call_prop(duk_context *ctx, duk_idx_t obj_idx, duk_idx_t nargs);
1056 DUK_EXTERNAL_DECL duk_int_t duk_pcall(duk_context *ctx, duk_idx_t nargs);
1057 DUK_EXTERNAL_DECL duk_int_t duk_pcall_method(duk_context *ctx, duk_idx_t nargs);
1058 DUK_EXTERNAL_DECL duk_int_t duk_pcall_prop(duk_context *ctx, duk_idx_t obj_idx, duk_idx_t nargs);
1059 DUK_EXTERNAL_DECL void duk_new(duk_context *ctx, duk_idx_t nargs);
1060 DUK_EXTERNAL_DECL duk_int_t duk_pnew(duk_context *ctx, duk_idx_t nargs);
1061 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);
1062
1063 /*
1064 * Thread management
1065 */
1066
1067 /* There are currently no native functions to yield/resume, due to the internal
1068 * limitations on coroutine handling. These will be added later.
1069 */
1070
1071 /*
1072 * Compilation and evaluation
1073 */
1074
1075 DUK_EXTERNAL_DECL duk_int_t duk_eval_raw(duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags);
1076 DUK_EXTERNAL_DECL duk_int_t duk_compile_raw(duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags);
1077
1078 /* plain */
1079 #define duk_eval(ctx) \
1080 ((void) duk_eval_raw((ctx), NULL, 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOFILENAME))
1081
1082 #define duk_eval_noresult(ctx) \
1083 ((void) duk_eval_raw((ctx), NULL, 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))
1084
1085 #define duk_peval(ctx) \
1086 (duk_eval_raw((ctx), NULL, 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOFILENAME))
1087
1088 #define duk_peval_noresult(ctx) \
1089 (duk_eval_raw((ctx), NULL, 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))
1090
1091 #define duk_compile(ctx,flags) \
1092 ((void) duk_compile_raw((ctx), NULL, 0, 2 /*args*/ | (flags)))
1093
1094 #define duk_pcompile(ctx,flags) \
1095 (duk_compile_raw((ctx), NULL, 0, 2 /*args*/ | (flags) | DUK_COMPILE_SAFE))
1096
1097 /* string */
1098 #define duk_eval_string(ctx,src) \
1099 ((void) duk_eval_raw((ctx), (src), 0, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))
1100
1101 #define duk_eval_string_noresult(ctx,src) \
1102 ((void) duk_eval_raw((ctx), (src), 0, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))
1103
1104 #define duk_peval_string(ctx,src) \
1105 (duk_eval_raw((ctx), (src), 0, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))
1106
1107 #define duk_peval_string_noresult(ctx,src) \
1108 (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))
1109
1110 #define duk_compile_string(ctx,flags,src) \
1111 ((void) duk_compile_raw((ctx), (src), 0, 0 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))
1112
1113 #define duk_compile_string_filename(ctx,flags,src) \
1114 ((void) duk_compile_raw((ctx), (src), 0, 1 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN))
1115
1116 #define duk_pcompile_string(ctx,flags,src) \
1117 (duk_compile_raw((ctx), (src), 0, 0 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))
1118
1119 #define duk_pcompile_string_filename(ctx,flags,src) \
1120 (duk_compile_raw((ctx), (src), 0, 1 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN))
1121
1122 /* lstring */
1123 #define duk_eval_lstring(ctx,buf,len) \
1124 ((void) duk_eval_raw((ctx), buf, len, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NOFILENAME))
1125
1126 #define duk_eval_lstring_noresult(ctx,buf,len) \
1127 ((void) duk_eval_raw((ctx), buf, len, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))
1128
1129 #define duk_peval_lstring(ctx,buf,len) \
1130 (duk_eval_raw((ctx), buf, len, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_SAFE | DUK_COMPILE_NOFILENAME))
1131
1132 #define duk_peval_lstring_noresult(ctx,buf,len) \
1133 (duk_eval_raw((ctx), buf, len, 0 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))
1134
1135 #define duk_compile_lstring(ctx,flags,buf,len) \
1136 ((void) duk_compile_raw((ctx), buf, len, 0 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NOFILENAME))
1137
1138 #define duk_compile_lstring_filename(ctx,flags,buf,len) \
1139 ((void) duk_compile_raw((ctx), buf, len, 1 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE))
1140
1141 #define duk_pcompile_lstring(ctx,flags,buf,len) \
1142 (duk_compile_raw((ctx), buf, len, 0 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NOFILENAME))
1143
1144 #define duk_pcompile_lstring_filename(ctx,flags,buf,len) \
1145 (duk_compile_raw((ctx), buf, len, 1 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE))
1146
1147 /*
1148 * Bytecode load/dump
1149 */
1150
1151 DUK_EXTERNAL_DECL void duk_dump_function(duk_context *ctx);
1152 DUK_EXTERNAL_DECL void duk_load_function(duk_context *ctx);
1153
1154 /*
1155 * Debugging
1156 */
1157
1158 DUK_EXTERNAL_DECL void duk_push_context_dump(duk_context *ctx);
1159
1160 /*
1161 * Debugger (debug protocol)
1162 */
1163
1164 DUK_EXTERNAL_DECL void duk_debugger_attach(duk_context *ctx,
1165 duk_debug_read_function read_cb,
1166 duk_debug_write_function write_cb,
1167 duk_debug_peek_function peek_cb,
1168 duk_debug_read_flush_function read_flush_cb,
1169 duk_debug_write_flush_function write_flush_cb,
1170 duk_debug_request_function request_cb,
1171 duk_debug_detached_function detached_cb,
1172 void *udata);
1173 DUK_EXTERNAL_DECL void duk_debugger_detach(duk_context *ctx);
1174 DUK_EXTERNAL_DECL void duk_debugger_cooperate(duk_context *ctx);
1175 DUK_EXTERNAL_DECL duk_bool_t duk_debugger_notify(duk_context *ctx, duk_idx_t nvalues);
1176 DUK_EXTERNAL_DECL void duk_debugger_pause(duk_context *ctx);
1177
1178 /*
1179 * Time handling
1180 */
1181
1182 DUK_EXTERNAL_DECL duk_double_t duk_get_now(duk_context *ctx);
1183 DUK_EXTERNAL_DECL void duk_time_to_components(duk_context *ctx, duk_double_t timeval, duk_time_components *comp);
1184 DUK_EXTERNAL_DECL duk_double_t duk_components_to_time(duk_context *ctx, duk_time_components *comp);
1185
1186 /*
1187 * Date provider related constants
1188 *
1189 * NOTE: These are "semi public" - you should only use these if you write
1190 * your own platform specific Date provider, see doc/datetime.rst.
1191 */
1192
1193 /* Millisecond count constants. */
1194 #define DUK_DATE_MSEC_SECOND 1000L
1195 #define DUK_DATE_MSEC_MINUTE (60L * 1000L)
1196 #define DUK_DATE_MSEC_HOUR (60L * 60L * 1000L)
1197 #define DUK_DATE_MSEC_DAY (24L * 60L * 60L * 1000L)
1198
1199 /* Ecmascript date range is 100 million days from Epoch:
1200 * > 100e6 * 24 * 60 * 60 * 1000 // 100M days in millisecs
1201 * 8640000000000000
1202 * (= 8.64e15)
1203 */
1204 #define DUK_DATE_MSEC_100M_DAYS (8.64e15)
1205 #define DUK_DATE_MSEC_100M_DAYS_LEEWAY (8.64e15 + 24 * 3600e3)
1206
1207 /* Ecmascript year range:
1208 * > new Date(100e6 * 24 * 3600e3).toISOString()
1209 * '+275760-09-13T00:00:00.000Z'
1210 * > new Date(-100e6 * 24 * 3600e3).toISOString()
1211 * '-271821-04-20T00:00:00.000Z'
1212 */
1213 #define DUK_DATE_MIN_ECMA_YEAR (-271821L)
1214 #define DUK_DATE_MAX_ECMA_YEAR 275760L
1215
1216 /* Part indices for internal breakdowns. Part order from DUK_DATE_IDX_YEAR
1217 * to DUK_DATE_IDX_MILLISECOND matches argument ordering of Ecmascript API
1218 * calls (like Date constructor call). Some functions in duk_bi_date.c
1219 * depend on the specific ordering, so change with care. 16 bits are not
1220 * enough for all parts (year, specifically).
1221 *
1222 * Must be in-sync with genbuiltins.py.
1223 */
1224 #define DUK_DATE_IDX_YEAR 0 /* year */
1225 #define DUK_DATE_IDX_MONTH 1 /* month: 0 to 11 */
1226 #define DUK_DATE_IDX_DAY 2 /* day within month: 0 to 30 */
1227 #define DUK_DATE_IDX_HOUR 3
1228 #define DUK_DATE_IDX_MINUTE 4
1229 #define DUK_DATE_IDX_SECOND 5
1230 #define DUK_DATE_IDX_MILLISECOND 6
1231 #define DUK_DATE_IDX_WEEKDAY 7 /* weekday: 0 to 6, 0=sunday, 1=monday, etc */
1232 #define DUK_DATE_IDX_NUM_PARTS 8
1233
1234 /* Internal API call flags, used for various functions in duk_bi_date.c.
1235 * Certain flags are used by only certain functions, but since the flags
1236 * don't overlap, a single flags value can be passed around to multiple
1237 * functions.
1238 *
1239 * The unused top bits of the flags field are also used to pass values
1240 * to helpers (duk__get_part_helper() and duk__set_part_helper()).
1241 *
1242 * Must be in-sync with genbuiltins.py.
1243 */
1244
1245 /* NOTE: when writing a Date provider you only need a few specific
1246 * flags from here, the rest are internal. Avoid using anything you
1247 * don't need.
1248 */
1249
1250 #define DUK_DATE_FLAG_NAN_TO_ZERO (1 << 0) /* timeval breakdown: internal time value NaN -> zero */
1251 #define DUK_DATE_FLAG_NAN_TO_RANGE_ERROR (1 << 1) /* timeval breakdown: internal time value NaN -> RangeError (toISOString) */
1252 #define DUK_DATE_FLAG_ONEBASED (1 << 2) /* timeval breakdown: convert month and day-of-month parts to one-based (default is zero-based) */
1253 #define DUK_DATE_FLAG_EQUIVYEAR (1 << 3) /* timeval breakdown: replace year with equivalent year in the [1971,2037] range for DST calculations */
1254 #define DUK_DATE_FLAG_LOCALTIME (1 << 4) /* convert time value to local time */
1255 #define DUK_DATE_FLAG_SUB1900 (1 << 5) /* getter: subtract 1900 from year when getting year part */
1256 #define DUK_DATE_FLAG_TOSTRING_DATE (1 << 6) /* include date part in string conversion result */
1257 #define DUK_DATE_FLAG_TOSTRING_TIME (1 << 7) /* include time part in string conversion result */
1258 #define DUK_DATE_FLAG_TOSTRING_LOCALE (1 << 8) /* use locale specific formatting if available */
1259 #define DUK_DATE_FLAG_TIMESETTER (1 << 9) /* setter: call is a time setter (affects hour, min, sec, ms); otherwise date setter (affects year, month, day-in-month) */
1260 #define DUK_DATE_FLAG_YEAR_FIXUP (1 << 10) /* setter: perform 2-digit year fixup (00...99 -> 1900...1999) */
1261 #define DUK_DATE_FLAG_SEP_T (1 << 11) /* string conversion: use 'T' instead of ' ' as a separator */
1262 #define DUK_DATE_FLAG_VALUE_SHIFT 12 /* additional values begin at bit 12 */
1263
1264 /*
1265 * ROM pointer compression
1266 */
1267
1268 /* Support array for ROM pointer compression. Only declared when ROM
1269 * pointer compression is active.
1270 */
1271 #if defined(DUK_USE_ROM_OBJECTS) && defined(DUK_USE_HEAPPTR16)
1272 DUK_EXTERNAL_DECL const void * const duk_rom_compressed_pointers[];
1273 #endif
1274
1275 /*
1276 * C++ name mangling
1277 */
1278
1279 #if defined(__cplusplus)
1280 /* end 'extern "C"' wrapper */
1281 }
1282 #endif
1283
1284 /*
1285 * END PUBLIC API
1286 */
1287
1288 #endif /* DUKTAPE_H_INCLUDED */