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