#include "duk_config.h"

Data Structures
struct	duk_memory_functions

struct	duk_function_list_entry

struct	duk_number_list_entry

union	duk_double_union

Macros
#define	DUK_SINGLE_FILE

#define	DUK_API_PUBLIC_H_INCLUDED

#define	DUK_API_NORETURN(decl) DUK_NORETURN(decl)

#define	DUK_VERSION 10502L

#define	DUK_GIT_COMMIT "cad34ae155acb0846545ca6bf2d29f9463b22bbb"

#define	DUK_GIT_DESCRIBE "v1.5.2"

#define	DUK_GIT_BRANCH "HEAD"

#define	DUK_DEBUG_PROTOCOL_VERSION 1

#define	DUK_INVALID_INDEX DUK_IDX_MIN

#define	DUK_VARARGS ((duk_int_t) (-1))

#define	DUK_API_ENTRY_STACK 64

#define	DUK_TYPE_MIN 0

#define	DUK_TYPE_NONE 0 /* no value, e.g. invalid index */

#define	DUK_TYPE_UNDEFINED 1 /* Ecmascript undefined */

#define	DUK_TYPE_NULL 2 /* Ecmascript null */

#define	DUK_TYPE_BOOLEAN 3 /* Ecmascript boolean: 0 or 1 */

#define	DUK_TYPE_NUMBER 4 /* Ecmascript number: double */

#define	DUK_TYPE_STRING 5 /* Ecmascript string: CESU-8 / extended UTF-8 encoded */

#define	DUK_TYPE_OBJECT 6 /* Ecmascript object: includes objects, arrays, functions, threads */

#define	DUK_TYPE_BUFFER 7 /* fixed or dynamic, garbage collected byte buffer */

#define	DUK_TYPE_POINTER 8 /* raw void pointer */

#define	DUK_TYPE_LIGHTFUNC 9 /* lightweight function pointer */

#define	DUK_TYPE_MAX 9

#define	DUK_TYPE_MASK_NONE (1 << DUK_TYPE_NONE)

#define	DUK_TYPE_MASK_UNDEFINED (1 << DUK_TYPE_UNDEFINED)

#define	DUK_TYPE_MASK_NULL (1 << DUK_TYPE_NULL)

#define	DUK_TYPE_MASK_BOOLEAN (1 << DUK_TYPE_BOOLEAN)

#define	DUK_TYPE_MASK_NUMBER (1 << DUK_TYPE_NUMBER)

#define	DUK_TYPE_MASK_STRING (1 << DUK_TYPE_STRING)

#define	DUK_TYPE_MASK_OBJECT (1 << DUK_TYPE_OBJECT)

#define	DUK_TYPE_MASK_BUFFER (1 << DUK_TYPE_BUFFER)

#define	DUK_TYPE_MASK_POINTER (1 << DUK_TYPE_POINTER)

#define	DUK_TYPE_MASK_LIGHTFUNC (1 << DUK_TYPE_LIGHTFUNC)

#define	DUK_TYPE_MASK_THROW (1 << 10) /* internal flag value: throw if mask doesn't match */

#define	DUK_HINT_NONE

#define	DUK_HINT_STRING 1 /* prefer string */

#define	DUK_HINT_NUMBER 2 /* prefer number */

#define	DUK_ENUM_INCLUDE_NONENUMERABLE (1 << 0) /* enumerate non-numerable properties in addition to enumerable */

#define	DUK_ENUM_INCLUDE_INTERNAL (1 << 1) /* enumerate internal properties (regardless of enumerability) */

#define	DUK_ENUM_OWN_PROPERTIES_ONLY (1 << 2) /* don't walk prototype chain, only check own properties */

#define	DUK_ENUM_ARRAY_INDICES_ONLY (1 << 3) /* only enumerate array indices */

#define	DUK_ENUM_SORT_ARRAY_INDICES (1 << 4) /* sort array indices, use with DUK_ENUM_ARRAY_INDICES_ONLY */

#define	DUK_ENUM_NO_PROXY_BEHAVIOR (1 << 5) /* enumerate a proxy object itself without invoking proxy behavior */

#define	DUK_COMPILE_EVAL (1 << 3) /* compile eval code (instead of global code) */

#define	DUK_COMPILE_FUNCTION (1 << 4) /* compile function code (instead of global code) */

#define	DUK_COMPILE_STRICT (1 << 5) /* use strict (outer) context for global, eval, or function code */

#define	DUK_COMPILE_SAFE (1 << 6) /* (internal) catch compilation errors */

#define	DUK_COMPILE_NORESULT (1 << 7) /* (internal) omit eval result */

#define	DUK_COMPILE_NOSOURCE (1 << 8) /* (internal) no source string on stack */

#define	DUK_COMPILE_STRLEN (1 << 9) /* (internal) take strlen() of src_buffer (avoids double evaluation in macro) */

#define	DUK_COMPILE_NOFILENAME (1 << 10) /* (internal) no filename on stack */

#define	DUK_DEFPROP_WRITABLE (1 << 0) /* set writable (effective if DUK_DEFPROP_HAVE_WRITABLE set) */

#define	DUK_DEFPROP_ENUMERABLE (1 << 1) /* set enumerable (effective if DUK_DEFPROP_HAVE_ENUMERABLE set) */

#define	DUK_DEFPROP_CONFIGURABLE (1 << 2) /* set configurable (effective if DUK_DEFPROP_HAVE_CONFIGURABLE set) */

#define	DUK_DEFPROP_HAVE_WRITABLE (1 << 3) /* set/clear writable */

#define	DUK_DEFPROP_HAVE_ENUMERABLE (1 << 4) /* set/clear enumerable */

#define	DUK_DEFPROP_HAVE_CONFIGURABLE (1 << 5) /* set/clear configurable */

#define	DUK_DEFPROP_HAVE_VALUE (1 << 6) /* set value (given on value stack) */

#define	DUK_DEFPROP_HAVE_GETTER (1 << 7) /* set getter (given on value stack) */

#define	DUK_DEFPROP_HAVE_SETTER (1 << 8) /* set setter (given on value stack) */

#define	DUK_DEFPROP_FORCE (1 << 9) /* force change if possible, may still fail for e.g. virtual properties */

#define	DUK_DEFPROP_SET_WRITABLE (DUK_DEFPROP_HAVE_WRITABLE \| DUK_DEFPROP_WRITABLE)

#define	DUK_DEFPROP_CLEAR_WRITABLE DUK_DEFPROP_HAVE_WRITABLE

#define	DUK_DEFPROP_SET_ENUMERABLE (DUK_DEFPROP_HAVE_ENUMERABLE \| DUK_DEFPROP_ENUMERABLE)

#define	DUK_DEFPROP_CLEAR_ENUMERABLE DUK_DEFPROP_HAVE_ENUMERABLE

#define	DUK_DEFPROP_SET_CONFIGURABLE (DUK_DEFPROP_HAVE_CONFIGURABLE \| DUK_DEFPROP_CONFIGURABLE)

#define	DUK_DEFPROP_CLEAR_CONFIGURABLE DUK_DEFPROP_HAVE_CONFIGURABLE

#define	DUK_THREAD_NEW_GLOBAL_ENV (1 << 0) /* create a new global environment */

#define	DUK_STRING_PUSH_SAFE (1 << 0) /* no error if file does not exist */

#define	DUK_ERR_NONE 0 /* no error (e.g. from duk_get_error_code()) */

#define	DUK_ERR_UNIMPLEMENTED_ERROR 50 /* UnimplementedError / / XXX: replace with TypeError? */

#define	DUK_ERR_UNSUPPORTED_ERROR 51 /* UnsupportedError / / XXX: replace with TypeError? */

#define	DUK_ERR_INTERNAL_ERROR 52 /* InternalError / / XXX: replace with plain Error? */

#define	DUK_ERR_ALLOC_ERROR 53 /* AllocError / / XXX: replace with RangeError? */

#define	DUK_ERR_ASSERTION_ERROR 54 /* AssertionError / / XXX: to be removed? */

#define	DUK_ERR_API_ERROR 55 /* APIError / / XXX: replace with TypeError? */

#define	DUK_ERR_UNCAUGHT_ERROR 56 /* UncaughtError / / XXX: to be removed? */

#define	DUK_ERR_ERROR 100 /* Error */

#define	DUK_ERR_EVAL_ERROR 101 /* EvalError */

#define	DUK_ERR_RANGE_ERROR 102 /* RangeError */

#define	DUK_ERR_REFERENCE_ERROR 103 /* ReferenceError */

#define	DUK_ERR_SYNTAX_ERROR 104 /* SyntaxError */

#define	DUK_ERR_TYPE_ERROR 105 /* TypeError */

#define	DUK_ERR_URI_ERROR 106 /* URIError */

#define	DUK_RET_UNIMPLEMENTED_ERROR (-DUK_ERR_UNIMPLEMENTED_ERROR)

#define	DUK_RET_UNSUPPORTED_ERROR (-DUK_ERR_UNSUPPORTED_ERROR)

#define	DUK_RET_INTERNAL_ERROR (-DUK_ERR_INTERNAL_ERROR)

#define	DUK_RET_ALLOC_ERROR (-DUK_ERR_ALLOC_ERROR)

#define	DUK_RET_ASSERTION_ERROR (-DUK_ERR_ASSERTION_ERROR)

#define	DUK_RET_API_ERROR (-DUK_ERR_API_ERROR)

#define	DUK_RET_UNCAUGHT_ERROR (-DUK_ERR_UNCAUGHT_ERROR)

#define	DUK_RET_ERROR (-DUK_ERR_ERROR)

#define	DUK_RET_EVAL_ERROR (-DUK_ERR_EVAL_ERROR)

#define	DUK_RET_RANGE_ERROR (-DUK_ERR_RANGE_ERROR)

#define	DUK_RET_REFERENCE_ERROR (-DUK_ERR_REFERENCE_ERROR)

#define	DUK_RET_SYNTAX_ERROR (-DUK_ERR_SYNTAX_ERROR)

#define	DUK_RET_TYPE_ERROR (-DUK_ERR_TYPE_ERROR)

#define	DUK_RET_URI_ERROR (-DUK_ERR_URI_ERROR)

#define	DUK_EXEC_SUCCESS 0

#define	DUK_EXEC_ERROR 1

#define	DUK_LOG_TRACE 0

#define	DUK_LOG_DEBUG 1

#define	DUK_LOG_INFO 2

#define	DUK_LOG_WARN 3

#define	DUK_LOG_ERROR 4

#define	DUK_LOG_FATAL 5

#define	duk_create_heap_default() duk_create_heap(NULL, NULL, NULL, NULL, NULL)

#define	duk_error

#define	duk_error_va(ctx, err_code, fmt, ap) duk_error_va_raw((ctx), (duk_errcode_t) (err_code), (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), (fmt), (ap))

#define	duk_xmove_top(to_ctx, from_ctx, count) duk_xcopymove_raw((to_ctx), (from_ctx), (count), 0 /is_copy/)

#define	duk_xcopy_top(to_ctx, from_ctx, count) duk_xcopymove_raw((to_ctx), (from_ctx), (count), 1 /is_copy/)

#define	duk_push_string_file(ctx, path) duk_push_string_file_raw((ctx), (path), 0)

#define	duk_push_thread(ctx) duk_push_thread_raw((ctx), 0 /flags/)

#define	duk_push_thread_new_globalenv(ctx) duk_push_thread_raw((ctx), DUK_THREAD_NEW_GLOBAL_ENV /flags/)

#define	duk_push_error_object

#define	duk_push_error_object_va(ctx, err_code, fmt, ap) duk_push_error_object_va_raw((ctx), (err_code), (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), (fmt), (ap))

#define	DUK_BUF_FLAG_DYNAMIC (1 << 0) /* internal flag: dynamic buffer */

#define	DUK_BUF_FLAG_EXTERNAL (1 << 1) /* internal flag: external buffer */

#define	DUK_BUF_FLAG_NOZERO (1 << 2) /* internal flag: don't zero allocated buffer */

#define	duk_push_buffer(ctx, size, dynamic) duk_push_buffer_raw((ctx), (size), (dynamic) ? DUK_BUF_FLAG_DYNAMIC : 0)

#define	duk_push_fixed_buffer(ctx, size) duk_push_buffer_raw((ctx), (size), 0 /flags/)

#define	duk_push_dynamic_buffer(ctx, size) duk_push_buffer_raw((ctx), (size), DUK_BUF_FLAG_DYNAMIC /flags/)

#define	duk_push_external_buffer(ctx) ((void) duk_push_buffer_raw((ctx), 0, DUK_BUF_FLAG_DYNAMIC \| DUK_BUF_FLAG_EXTERNAL))

#define	DUK_BUFOBJ_CREATE_ARRBUF (1 << 4) /* internal flag: create backing ArrayBuffer; keep in one byte */

#define	DUK_BUFOBJ_DUKTAPE_BUFFER 0

#define	DUK_BUFOBJ_NODEJS_BUFFER 1

#define	DUK_BUFOBJ_ARRAYBUFFER 2

#define	DUK_BUFOBJ_DATAVIEW (3 \| DUK_BUFOBJ_CREATE_ARRBUF)

#define	DUK_BUFOBJ_INT8ARRAY (4 \| DUK_BUFOBJ_CREATE_ARRBUF)

#define	DUK_BUFOBJ_UINT8ARRAY (5 \| DUK_BUFOBJ_CREATE_ARRBUF)

#define	DUK_BUFOBJ_UINT8CLAMPEDARRAY (6 \| DUK_BUFOBJ_CREATE_ARRBUF)

#define	DUK_BUFOBJ_INT16ARRAY (7 \| DUK_BUFOBJ_CREATE_ARRBUF)

#define	DUK_BUFOBJ_UINT16ARRAY (8 \| DUK_BUFOBJ_CREATE_ARRBUF)

#define	DUK_BUFOBJ_INT32ARRAY (9 \| DUK_BUFOBJ_CREATE_ARRBUF)

#define	DUK_BUFOBJ_UINT32ARRAY (10 \| DUK_BUFOBJ_CREATE_ARRBUF)

#define	DUK_BUFOBJ_FLOAT32ARRAY (11 \| DUK_BUFOBJ_CREATE_ARRBUF)

#define	DUK_BUFOBJ_FLOAT64ARRAY (12 \| DUK_BUFOBJ_CREATE_ARRBUF)

#define	duk_is_callable(ctx, index) duk_is_function((ctx), (index))

#define	duk_is_primitive(ctx, index)

#define	duk_is_object_coercible(ctx, index)

#define	duk_is_error(ctx, index) (duk_get_error_code((ctx), (index)) != 0)

#define	duk_is_eval_error(ctx, index) (duk_get_error_code((ctx), (index)) == DUK_ERR_EVAL_ERROR)

#define	duk_is_range_error(ctx, index) (duk_get_error_code((ctx), (index)) == DUK_ERR_RANGE_ERROR)

#define	duk_is_reference_error(ctx, index) (duk_get_error_code((ctx), (index)) == DUK_ERR_REFERENCE_ERROR)

#define	duk_is_syntax_error(ctx, index) (duk_get_error_code((ctx), (index)) == DUK_ERR_SYNTAX_ERROR)

#define	duk_is_type_error(ctx, index) (duk_get_error_code((ctx), (index)) == DUK_ERR_TYPE_ERROR)

#define	duk_is_uri_error(ctx, index) (duk_get_error_code((ctx), (index)) == DUK_ERR_URI_ERROR)

#define	duk_require_type_mask(ctx, index, mask) ((void) duk_check_type_mask((ctx), (index), (mask) \| DUK_TYPE_MASK_THROW))

#define	duk_require_callable(ctx, index) duk_require_function((ctx), (index))

#define	duk_require_object_coercible(ctx, index)

#define	DUK_BUF_MODE_FIXED 0 /* internal: request fixed buffer result */

#define	DUK_BUF_MODE_DYNAMIC 1 /* internal: request dynamic buffer result */

#define	DUK_BUF_MODE_DONTCARE 2 /* internal: don't care about fixed/dynamic nature */

#define	duk_to_buffer(ctx, index, out_size) duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_DONTCARE)

#define	duk_to_fixed_buffer(ctx, index, out_size) duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_FIXED)

#define	duk_to_dynamic_buffer(ctx, index, out_size) duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_DYNAMIC)

#define	duk_safe_to_string(ctx, index) duk_safe_to_lstring((ctx), (index), NULL)

#define	duk_eval(ctx) ((void) duk_eval_raw((ctx), NULL, 0, 2 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_NOFILENAME))

#define	duk_eval_noresult(ctx) ((void) duk_eval_raw((ctx), NULL, 0, 2 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_NORESULT \| DUK_COMPILE_NOFILENAME))

#define	duk_peval(ctx) (duk_eval_raw((ctx), NULL, 0, 2 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_SAFE \| DUK_COMPILE_NOFILENAME))

#define	duk_peval_noresult(ctx) (duk_eval_raw((ctx), NULL, 0, 2 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_SAFE \| DUK_COMPILE_NORESULT \| DUK_COMPILE_NOFILENAME))

#define	duk_compile(ctx, flags) ((void) duk_compile_raw((ctx), NULL, 0, 3 /args/ \| (flags)))

#define	duk_pcompile(ctx, flags) (duk_compile_raw((ctx), NULL, 0, 3 /args/ \| (flags) \| DUK_COMPILE_SAFE))

#define	duk_eval_string(ctx, src) ((void) duk_eval_raw((ctx), (src), 0, 1 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_STRLEN \| DUK_COMPILE_NOFILENAME))

#define	duk_eval_string_noresult(ctx, src) ((void) duk_eval_raw((ctx), (src), 0, 1 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_STRLEN \| DUK_COMPILE_NORESULT \| DUK_COMPILE_NOFILENAME))

#define	duk_peval_string(ctx, src) (duk_eval_raw((ctx), (src), 0, 1 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_SAFE \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_STRLEN \| DUK_COMPILE_NOFILENAME))

#define	duk_peval_string_noresult(ctx, src) (duk_eval_raw((ctx), (src), 0, 1 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_SAFE \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_STRLEN \| DUK_COMPILE_NORESULT \| DUK_COMPILE_NOFILENAME))

#define	duk_compile_string(ctx, flags, src) ((void) duk_compile_raw((ctx), (src), 0, 1 /args/ \| (flags) \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_STRLEN \| DUK_COMPILE_NOFILENAME))

#define	duk_compile_string_filename(ctx, flags, src) ((void) duk_compile_raw((ctx), (src), 0, 2 /args/ \| (flags) \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_STRLEN))

#define	duk_pcompile_string(ctx, flags, src) (duk_compile_raw((ctx), (src), 0, 1 /args/ \| (flags) \| DUK_COMPILE_SAFE \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_STRLEN \| DUK_COMPILE_NOFILENAME))

#define	duk_pcompile_string_filename(ctx, flags, src) (duk_compile_raw((ctx), (src), 0, 2 /args/ \| (flags) \| DUK_COMPILE_SAFE \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_STRLEN))

#define	duk_eval_lstring(ctx, buf, len) ((void) duk_eval_raw((ctx), buf, len, 1 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_NOFILENAME))

#define	duk_eval_lstring_noresult(ctx, buf, len) ((void) duk_eval_raw((ctx), buf, len, 1 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_NORESULT \| DUK_COMPILE_NOFILENAME))

#define	duk_peval_lstring(ctx, buf, len) (duk_eval_raw((ctx), buf, len, 1 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_SAFE \| DUK_COMPILE_NOFILENAME))

#define	duk_peval_lstring_noresult(ctx, buf, len) (duk_eval_raw((ctx), buf, len, 1 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_SAFE \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_NORESULT \| DUK_COMPILE_NOFILENAME))

#define	duk_compile_lstring(ctx, flags, buf, len) ((void) duk_compile_raw((ctx), buf, len, 1 /args/ \| (flags) \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_NOFILENAME))

#define	duk_compile_lstring_filename(ctx, flags, buf, len) ((void) duk_compile_raw((ctx), buf, len, 2 /args/ \| (flags) \| DUK_COMPILE_NOSOURCE))

#define	duk_pcompile_lstring(ctx, flags, buf, len) (duk_compile_raw((ctx), buf, len, 1 /args/ \| (flags) \| DUK_COMPILE_SAFE \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_NOFILENAME))

#define	duk_pcompile_lstring_filename(ctx, flags, buf, len) (duk_compile_raw((ctx), buf, len, 2 /args/ \| (flags) \| DUK_COMPILE_SAFE \| DUK_COMPILE_NOSOURCE))

#define	duk_eval_file(ctx, path)

#define	duk_eval_file_noresult(ctx, path)

#define	duk_peval_file(ctx, path)

#define	duk_peval_file_noresult(ctx, path)

#define	duk_compile_file(ctx, flags, path)

#define	duk_pcompile_file(ctx, flags, path)

#define	duk_dump_context_filehandle(ctx, fh)

#define	duk_dump_context_stdout(ctx) duk_dump_context_filehandle((ctx), DUK_STDOUT)

#define	duk_dump_context_stderr(ctx) duk_dump_context_filehandle((ctx), DUK_STDERR)

#define	duk_debugger_attach(ctx, read_cb, write_cb, peek_cb, read_flush_cb, write_flush_cb, detached_cb, udata)

#define	DUK_DATE_MSEC_SECOND 1000L

#define	DUK_DATE_MSEC_MINUTE (60L * 1000L)

#define	DUK_DATE_MSEC_HOUR (60L * 60L * 1000L)

#define	DUK_DATE_MSEC_DAY (24L * 60L * 60L * 1000L)

#define	DUK_DATE_MSEC_100M_DAYS (8.64e15)

#define	DUK_DATE_MSEC_100M_DAYS_LEEWAY (8.64e15 + 24 * 3600e3)

#define	DUK_DATE_MIN_ECMA_YEAR (-271821L)

#define	DUK_DATE_MAX_ECMA_YEAR 275760L

#define	DUK_DATE_IDX_YEAR 0 /* year */

#define	DUK_DATE_IDX_MONTH 1 /* month: 0 to 11 */

#define	DUK_DATE_IDX_DAY 2 /* day within month: 0 to 30 */

#define	DUK_DATE_IDX_HOUR 3

#define	DUK_DATE_IDX_MINUTE 4

#define	DUK_DATE_IDX_SECOND 5

#define	DUK_DATE_IDX_MILLISECOND 6

#define	DUK_DATE_IDX_WEEKDAY 7 /* weekday: 0 to 6, 0=sunday, 1=monday, etc */

#define	DUK_DATE_IDX_NUM_PARTS 8

#define	DUK_DATE_FLAG_NAN_TO_ZERO (1 << 0) /* timeval breakdown: internal time value NaN -> zero */

#define	DUK_DATE_FLAG_NAN_TO_RANGE_ERROR (1 << 1) /* timeval breakdown: internal time value NaN -> RangeError (toISOString) */

#define	DUK_DATE_FLAG_ONEBASED (1 << 2) /* timeval breakdown: convert month and day-of-month parts to one-based (default is zero-based) */

#define	DUK_DATE_FLAG_EQUIVYEAR (1 << 3) /* timeval breakdown: replace year with equivalent year in the [1971,2037] range for DST calculations */

#define	DUK_DATE_FLAG_LOCALTIME (1 << 4) /* convert time value to local time */

#define	DUK_DATE_FLAG_SUB1900 (1 << 5) /* getter: subtract 1900 from year when getting year part */

#define	DUK_DATE_FLAG_TOSTRING_DATE (1 << 6) /* include date part in string conversion result */

#define	DUK_DATE_FLAG_TOSTRING_TIME (1 << 7) /* include time part in string conversion result */

#define	DUK_DATE_FLAG_TOSTRING_LOCALE (1 << 8) /* use locale specific formatting if available */

#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) */

#define	DUK_DATE_FLAG_YEAR_FIXUP (1 << 10) /* setter: perform 2-digit year fixup (00...99 -> 1900...1999) */

#define	DUK_DATE_FLAG_SEP_T (1 << 11) /* string conversion: use 'T' instead of ' ' as a separator */

#define	DUK_DATE_FLAG_VALUE_SHIFT 12 /* additional values begin at bit 12 */

#define	DUK_DBLUNION_H_INCLUDED

#define	DUK_DBLUNION_SET_DOUBLE(u, v)

#define	DUK_DBLUNION_SET_HIGH32(u, v)

#define	DUK_DBLUNION_SET_HIGH32_ZERO_LOW32(u, v)

#define	DUK_DBLUNION_SET_LOW32(u, v)

#define	DUK_DBLUNION_GET_DOUBLE(u) ((u)->d)

#define	DUK_DBLUNION_GET_HIGH32(u) ((u)->ui[DUK_DBL_IDX_UI0])

#define	DUK_DBLUNION_GET_LOW32(u) ((u)->ui[DUK_DBL_IDX_UI1])

#define	DUK__DBLUNION_SET_NAN_FULL(u)

#define	DUK__DBLUNION_SET_NAN_NOTFULL(u)

#define	DUK__DBLUNION_IS_NAN_FULL(u)

#define	DUK__DBLUNION_IS_NAN_NOTFULL(u)

#define	DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u)

#define	DUK__DBLUNION_IS_NORMALIZED_NAN_NOTFULL(u)

#define	DUK__DBLUNION_NORMALIZE_NAN_CHECK_FULL(u)

#define	DUK__DBLUNION_NORMALIZE_NAN_CHECK_NOTFULL(u)

#define	DUK_DBLUNION_NORMALIZE_NAN_CHECK(u) /* nop: no need to normalize */

#define	DUK_DBLUNION_IS_NAN(u) (DUK_ISNAN((u)->d))

#define	DUK_DBLUNION_IS_NORMALIZED_NAN(u) (DUK_ISNAN((u)->d))

#define	DUK_DBLUNION_IS_NORMALIZED(u) 1 /* all doubles are considered normalized */

#define	DUK_DBLUNION_SET_NAN(u)

#define	DUK_DBLUNION_BSWAP64(u)

#define	DUK_DBLUNION_DOUBLE_NTOH(u) DUK_DBLUNION_DOUBLE_HTON((u))

Typedefs
typedef struct duk_memory_functions	duk_memory_functions

typedef struct duk_function_list_entry	duk_function_list_entry

typedef struct duk_number_list_entry	duk_number_list_entry

typedef duk_ret_t(*	duk_c_function) (duk_context *ctx)

typedef void (	duk_alloc_function) (void *udata, duk_size_t size)

typedef void (	duk_realloc_function) (void udata, void ptr, duk_size_t size)

typedef void(*	duk_free_function) (void udata, void ptr)

typedef void(*	duk_fatal_function) (duk_context ctx, duk_errcode_t code, const char msg)

typedef void(*	duk_decode_char_function) (void *udata, duk_codepoint_t codepoint)

typedef duk_codepoint_t(*	duk_map_char_function) (void *udata, duk_codepoint_t codepoint)

typedef duk_ret_t(*	duk_safe_call_function) (duk_context *ctx)

typedef duk_size_t(*	duk_debug_read_function) (void udata, char buffer, duk_size_t length)

typedef duk_size_t(*	duk_debug_write_function) (void udata, const char buffer, duk_size_t length)

typedef duk_size_t(*	duk_debug_peek_function) (void *udata)

typedef void(*	duk_debug_read_flush_function) (void *udata)

typedef void(*	duk_debug_write_flush_function) (void *udata)

typedef duk_idx_t(*	duk_debug_request_function) (duk_context ctx, void udata, duk_idx_t nvalues)

typedef void(*	duk_debug_detached_function) (void *udata)

typedef union duk_double_union	duk_double_union

Functions
DUK_EXTERNAL_DECL duk_context *	duk_create_heap (duk_alloc_function alloc_func, duk_realloc_function realloc_func, duk_free_function free_func, void *heap_udata, duk_fatal_function fatal_handler)

DUK_EXTERNAL_DECL void	duk_destroy_heap (duk_context *ctx)

DUK_EXTERNAL_DECL void *	duk_alloc_raw (duk_context *ctx, duk_size_t size)

DUK_EXTERNAL_DECL void	duk_free_raw (duk_context ctx, void ptr)

DUK_EXTERNAL_DECL void *	duk_realloc_raw (duk_context ctx, void ptr, duk_size_t size)

DUK_EXTERNAL_DECL void *	duk_alloc (duk_context *ctx, duk_size_t size)

DUK_EXTERNAL_DECL void	duk_free (duk_context ctx, void ptr)

DUK_EXTERNAL_DECL void *	duk_realloc (duk_context ctx, void ptr, duk_size_t size)

DUK_EXTERNAL_DECL void	duk_get_memory_functions (duk_context ctx, duk_memory_functions out_funcs)

DUK_EXTERNAL_DECL void	duk_gc (duk_context *ctx, duk_uint_t flags)

	DUK_API_NORETURN (DUK_EXTERNAL_DECL void duk_throw(duk_context *ctx))

	DUK_API_NORETURN (DUK_EXTERNAL_DECL void duk_fatal(duk_context ctx, duk_errcode_t err_code, const char err_msg))

	DUK_API_NORETURN (DUK_EXTERNAL_DECL void duk_error_raw(duk_context ctx, duk_errcode_t err_code, const char filename, duk_int_t line, const char *fmt,...))

	DUK_API_NORETURN (DUK_EXTERNAL_DECL void duk_error_stash(duk_context ctx, duk_errcode_t err_code, const char fmt,...))

	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))

DUK_EXTERNAL_DECL duk_bool_t	duk_is_strict_call (duk_context *ctx)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_constructor_call (duk_context *ctx)

DUK_EXTERNAL_DECL duk_idx_t	duk_normalize_index (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_idx_t	duk_require_normalize_index (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_valid_index (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void	duk_require_valid_index (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_idx_t	duk_get_top (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_set_top (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_idx_t	duk_get_top_index (duk_context *ctx)

DUK_EXTERNAL_DECL duk_idx_t	duk_require_top_index (duk_context *ctx)

DUK_EXTERNAL_DECL duk_bool_t	duk_check_stack (duk_context *ctx, duk_idx_t extra)

DUK_EXTERNAL_DECL void	duk_require_stack (duk_context *ctx, duk_idx_t extra)

DUK_EXTERNAL_DECL duk_bool_t	duk_check_stack_top (duk_context *ctx, duk_idx_t top)

DUK_EXTERNAL_DECL void	duk_require_stack_top (duk_context *ctx, duk_idx_t top)

DUK_EXTERNAL_DECL void	duk_swap (duk_context *ctx, duk_idx_t index1, duk_idx_t index2)

DUK_EXTERNAL_DECL void	duk_swap_top (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void	duk_dup (duk_context *ctx, duk_idx_t from_index)

DUK_EXTERNAL_DECL void	duk_dup_top (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_insert (duk_context *ctx, duk_idx_t to_index)

DUK_EXTERNAL_DECL void	duk_replace (duk_context *ctx, duk_idx_t to_index)

DUK_EXTERNAL_DECL void	duk_copy (duk_context *ctx, duk_idx_t from_index, duk_idx_t to_index)

DUK_EXTERNAL_DECL void	duk_remove (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void	duk_xcopymove_raw (duk_context to_ctx, duk_context from_ctx, duk_idx_t count, duk_bool_t is_copy)

DUK_EXTERNAL_DECL void	duk_push_undefined (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_push_null (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_push_boolean (duk_context *ctx, duk_bool_t val)

DUK_EXTERNAL_DECL void	duk_push_true (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_push_false (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_push_number (duk_context *ctx, duk_double_t val)

DUK_EXTERNAL_DECL void	duk_push_nan (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_push_int (duk_context *ctx, duk_int_t val)

DUK_EXTERNAL_DECL void	duk_push_uint (duk_context *ctx, duk_uint_t val)

DUK_EXTERNAL_DECL const char *	duk_push_string (duk_context ctx, const char str)

DUK_EXTERNAL_DECL const char *	duk_push_lstring (duk_context ctx, const char str, duk_size_t len)

DUK_EXTERNAL_DECL void	duk_push_pointer (duk_context ctx, void p)

DUK_EXTERNAL_DECL const char *	duk_push_sprintf (duk_context ctx, const char fmt,...)

DUK_EXTERNAL_DECL const char *	duk_push_vsprintf (duk_context ctx, const char fmt, va_list ap)

DUK_EXTERNAL_DECL const char *	duk_push_string_file_raw (duk_context ctx, const char path, duk_uint_t flags)

DUK_EXTERNAL_DECL void	duk_push_this (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_push_current_function (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_push_current_thread (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_push_global_object (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_push_heap_stash (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_push_global_stash (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_push_thread_stash (duk_context ctx, duk_context target_ctx)

DUK_EXTERNAL_DECL duk_idx_t	duk_push_object (duk_context *ctx)

DUK_EXTERNAL_DECL duk_idx_t	duk_push_array (duk_context *ctx)

DUK_EXTERNAL_DECL duk_idx_t	duk_push_c_function (duk_context *ctx, duk_c_function func, duk_idx_t nargs)

DUK_EXTERNAL_DECL duk_idx_t	duk_push_c_lightfunc (duk_context *ctx, duk_c_function func, duk_idx_t nargs, duk_idx_t length, duk_int_t magic)

DUK_EXTERNAL_DECL duk_idx_t	duk_push_thread_raw (duk_context *ctx, duk_uint_t flags)

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,...)

DUK_EXTERNAL_DECL duk_idx_t	duk_push_error_object_stash (duk_context ctx, duk_errcode_t err_code, const char fmt,...)

DUK_EXTERNAL_DECL duk_idx_t	duk_push_error_object_va_raw (duk_context ctx, duk_errcode_t err_code, const char filename, duk_int_t line, const char *fmt, va_list ap)

DUK_EXTERNAL_DECL void *	duk_push_buffer_raw (duk_context *ctx, duk_size_t size, duk_small_uint_t flags)

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)

DUK_EXTERNAL_DECL duk_idx_t	duk_push_heapptr (duk_context ctx, void ptr)

DUK_EXTERNAL_DECL void	duk_pop (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_pop_n (duk_context *ctx, duk_idx_t count)

DUK_EXTERNAL_DECL void	duk_pop_2 (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_pop_3 (duk_context *ctx)

DUK_EXTERNAL_DECL duk_int_t	duk_get_type (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_check_type (duk_context *ctx, duk_idx_t index, duk_int_t type)

DUK_EXTERNAL_DECL duk_uint_t	duk_get_type_mask (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_check_type_mask (duk_context *ctx, duk_idx_t index, duk_uint_t mask)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_undefined (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_null (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_null_or_undefined (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_boolean (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_number (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_nan (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_string (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_object (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_buffer (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_pointer (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_lightfunc (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_array (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_function (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_c_function (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_ecmascript_function (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_bound_function (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_thread (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_dynamic_buffer (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_fixed_buffer (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_is_external_buffer (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_errcode_t	duk_get_error_code (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_get_boolean (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_double_t	duk_get_number (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_int_t	duk_get_int (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_uint_t	duk_get_uint (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL const char *	duk_get_string (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL const char *	duk_get_lstring (duk_context ctx, duk_idx_t index, duk_size_t out_len)

DUK_EXTERNAL_DECL void *	duk_get_buffer (duk_context ctx, duk_idx_t index, duk_size_t out_size)

DUK_EXTERNAL_DECL void *	duk_get_buffer_data (duk_context ctx, duk_idx_t index, duk_size_t out_size)

DUK_EXTERNAL_DECL void *	duk_get_pointer (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_c_function	duk_get_c_function (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_context *	duk_get_context (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void *	duk_get_heapptr (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_size_t	duk_get_length (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void	duk_require_undefined (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void	duk_require_null (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_require_boolean (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_double_t	duk_require_number (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_int_t	duk_require_int (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_uint_t	duk_require_uint (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL const char *	duk_require_string (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL const char *	duk_require_lstring (duk_context ctx, duk_idx_t index, duk_size_t out_len)

DUK_EXTERNAL_DECL void *	duk_require_buffer (duk_context ctx, duk_idx_t index, duk_size_t out_size)

DUK_EXTERNAL_DECL void *	duk_require_buffer_data (duk_context ctx, duk_idx_t index, duk_size_t out_size)

DUK_EXTERNAL_DECL void *	duk_require_pointer (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_c_function	duk_require_c_function (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_context *	duk_require_context (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void	duk_require_function (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void *	duk_require_heapptr (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void	duk_to_undefined (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void	duk_to_null (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_bool_t	duk_to_boolean (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_double_t	duk_to_number (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_int_t	duk_to_int (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_uint_t	duk_to_uint (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_int32_t	duk_to_int32 (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_uint32_t	duk_to_uint32 (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_uint16_t	duk_to_uint16 (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL const char *	duk_to_string (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL const char *	duk_to_lstring (duk_context ctx, duk_idx_t index, duk_size_t out_len)

DUK_EXTERNAL_DECL void *	duk_to_buffer_raw (duk_context ctx, duk_idx_t index, duk_size_t out_size, duk_uint_t flags)

DUK_EXTERNAL_DECL void *	duk_to_pointer (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void	duk_to_object (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void	duk_to_defaultvalue (duk_context *ctx, duk_idx_t index, duk_int_t hint)

DUK_EXTERNAL_DECL void	duk_to_primitive (duk_context *ctx, duk_idx_t index, duk_int_t hint)

DUK_EXTERNAL_DECL const char *	duk_safe_to_lstring (duk_context ctx, duk_idx_t index, duk_size_t out_len)

DUK_EXTERNAL_DECL const char *	duk_base64_encode (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void	duk_base64_decode (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL const char *	duk_hex_encode (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void	duk_hex_decode (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL const char *	duk_json_encode (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void	duk_json_decode (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void *	duk_resize_buffer (duk_context *ctx, duk_idx_t index, duk_size_t new_size)

DUK_EXTERNAL_DECL void *	duk_steal_buffer (duk_context ctx, duk_idx_t index, duk_size_t out_size)

DUK_EXTERNAL_DECL void	duk_config_buffer (duk_context ctx, duk_idx_t index, void ptr, duk_size_t len)

DUK_EXTERNAL_DECL duk_bool_t	duk_get_prop (duk_context *ctx, duk_idx_t obj_index)

DUK_EXTERNAL_DECL duk_bool_t	duk_get_prop_string (duk_context ctx, duk_idx_t obj_index, const char key)

DUK_EXTERNAL_DECL duk_bool_t	duk_get_prop_index (duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index)

DUK_EXTERNAL_DECL duk_bool_t	duk_put_prop (duk_context *ctx, duk_idx_t obj_index)

DUK_EXTERNAL_DECL duk_bool_t	duk_put_prop_string (duk_context ctx, duk_idx_t obj_index, const char key)

DUK_EXTERNAL_DECL duk_bool_t	duk_put_prop_index (duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index)

DUK_EXTERNAL_DECL duk_bool_t	duk_del_prop (duk_context *ctx, duk_idx_t obj_index)

DUK_EXTERNAL_DECL duk_bool_t	duk_del_prop_string (duk_context ctx, duk_idx_t obj_index, const char key)

DUK_EXTERNAL_DECL duk_bool_t	duk_del_prop_index (duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index)

DUK_EXTERNAL_DECL duk_bool_t	duk_has_prop (duk_context *ctx, duk_idx_t obj_index)

DUK_EXTERNAL_DECL duk_bool_t	duk_has_prop_string (duk_context ctx, duk_idx_t obj_index, const char key)

DUK_EXTERNAL_DECL duk_bool_t	duk_has_prop_index (duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index)

DUK_EXTERNAL_DECL void	duk_def_prop (duk_context *ctx, duk_idx_t obj_index, duk_uint_t flags)

DUK_EXTERNAL_DECL duk_bool_t	duk_get_global_string (duk_context ctx, const char key)

DUK_EXTERNAL_DECL duk_bool_t	duk_put_global_string (duk_context ctx, const char key)

DUK_EXTERNAL_DECL void	duk_get_prototype (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void	duk_set_prototype (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void	duk_get_finalizer (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void	duk_set_finalizer (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void	duk_set_global_object (duk_context *ctx)

DUK_EXTERNAL_DECL duk_int_t	duk_get_magic (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL void	duk_set_magic (duk_context *ctx, duk_idx_t index, duk_int_t magic)

DUK_EXTERNAL_DECL duk_int_t	duk_get_current_magic (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_put_function_list (duk_context ctx, duk_idx_t obj_index, const duk_function_list_entry funcs)

DUK_EXTERNAL_DECL void	duk_put_number_list (duk_context ctx, duk_idx_t obj_index, const duk_number_list_entry numbers)

DUK_EXTERNAL_DECL void	duk_get_var (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_put_var (duk_context *ctx)

DUK_EXTERNAL_DECL duk_bool_t	duk_del_var (duk_context *ctx)

DUK_EXTERNAL_DECL duk_bool_t	duk_has_var (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_compact (duk_context *ctx, duk_idx_t obj_index)

DUK_EXTERNAL_DECL void	duk_enum (duk_context *ctx, duk_idx_t obj_index, duk_uint_t enum_flags)

DUK_EXTERNAL_DECL duk_bool_t	duk_next (duk_context *ctx, duk_idx_t enum_index, duk_bool_t get_value)

DUK_EXTERNAL_DECL void	duk_concat (duk_context *ctx, duk_idx_t count)

DUK_EXTERNAL_DECL void	duk_join (duk_context *ctx, duk_idx_t count)

DUK_EXTERNAL_DECL void	duk_decode_string (duk_context ctx, duk_idx_t index, duk_decode_char_function callback, void udata)

DUK_EXTERNAL_DECL void	duk_map_string (duk_context ctx, duk_idx_t index, duk_map_char_function callback, void udata)

DUK_EXTERNAL_DECL void	duk_substring (duk_context *ctx, duk_idx_t index, duk_size_t start_char_offset, duk_size_t end_char_offset)

DUK_EXTERNAL_DECL void	duk_trim (duk_context *ctx, duk_idx_t index)

DUK_EXTERNAL_DECL duk_codepoint_t	duk_char_code_at (duk_context *ctx, duk_idx_t index, duk_size_t char_offset)

DUK_EXTERNAL_DECL duk_bool_t	duk_equals (duk_context *ctx, duk_idx_t index1, duk_idx_t index2)

DUK_EXTERNAL_DECL duk_bool_t	duk_strict_equals (duk_context *ctx, duk_idx_t index1, duk_idx_t index2)

DUK_EXTERNAL_DECL duk_bool_t	duk_instanceof (duk_context *ctx, duk_idx_t index1, duk_idx_t index2)

DUK_EXTERNAL_DECL void	duk_call (duk_context *ctx, duk_idx_t nargs)

DUK_EXTERNAL_DECL void	duk_call_method (duk_context *ctx, duk_idx_t nargs)

DUK_EXTERNAL_DECL void	duk_call_prop (duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs)

DUK_EXTERNAL_DECL duk_int_t	duk_pcall (duk_context *ctx, duk_idx_t nargs)

DUK_EXTERNAL_DECL duk_int_t	duk_pcall_method (duk_context *ctx, duk_idx_t nargs)

DUK_EXTERNAL_DECL duk_int_t	duk_pcall_prop (duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs)

DUK_EXTERNAL_DECL void	duk_new (duk_context *ctx, duk_idx_t nargs)

DUK_EXTERNAL_DECL duk_int_t	duk_pnew (duk_context *ctx, duk_idx_t nargs)

DUK_EXTERNAL_DECL duk_int_t	duk_safe_call (duk_context *ctx, duk_safe_call_function func, duk_idx_t nargs, duk_idx_t nrets)

DUK_EXTERNAL_DECL duk_int_t	duk_eval_raw (duk_context ctx, const char src_buffer, duk_size_t src_length, duk_uint_t flags)

DUK_EXTERNAL_DECL duk_int_t	duk_compile_raw (duk_context ctx, const char src_buffer, duk_size_t src_length, duk_uint_t flags)

DUK_EXTERNAL_DECL void	duk_dump_function (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_load_function (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_log (duk_context ctx, duk_int_t level, const char fmt,...)

DUK_EXTERNAL_DECL void	duk_log_va (duk_context ctx, duk_int_t level, const char fmt, va_list ap)

DUK_EXTERNAL_DECL void	duk_push_context_dump (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_debugger_attach_custom (duk_context ctx, duk_debug_read_function read_cb, duk_debug_write_function write_cb, duk_debug_peek_function peek_cb, duk_debug_read_flush_function read_flush_cb, duk_debug_write_flush_function write_flush_cb, duk_debug_request_function request_cb, duk_debug_detached_function detached_cb, void udata)

DUK_EXTERNAL_DECL void	duk_debugger_detach (duk_context *ctx)

DUK_EXTERNAL_DECL void	duk_debugger_cooperate (duk_context *ctx)

DUK_EXTERNAL_DECL duk_bool_t	duk_debugger_notify (duk_context *ctx, duk_idx_t nvalues)

DUK_EXTERNAL_DECL void	duk_debugger_pause (duk_context *ctx)

Variables
DUK_EXTERNAL_DECL const char *	duk_api_global_filename

DUK_EXTERNAL_DECL duk_int_t	duk_api_global_line

Macro Definition Documentation

◆ DUK__DBLUNION_IS_NAN_FULL

#define DUK__DBLUNION_IS_NAN_FULL ( u )

Value:

    /* E == 0x7ff, F != 0 => NaN */ \
    ((((u)->ui[DUK_DBL_IDX_UI0] & 0x7ff00000UL) == 0x7ff00000UL) && \
     (((u)->ui[DUK_DBL_IDX_UI0] & 0x000fffffUL) != 0 || \
          (u)->ui[DUK_DBL_IDX_UI1] != 0))

Definition at line 1444 of file duktape-1.5.2/src-noline/duktape.h.

#endif
#else  /* DUK_USE_64BIT_OPS */
#define DUK__DBLUNION_IS_NAN_FULL(u) \
    /* E == 0x7ff, F != 0 => NaN */ \
    ((((u)->ui[DUK_DBL_IDX_UI0] & 0x7ff00000UL) == 0x7ff00000UL) && \

◆ DUK__DBLUNION_IS_NAN_NOTFULL

#define DUK__DBLUNION_IS_NAN_NOTFULL ( u )

Value:

    /* E == 0x7ff, topmost four bits of F != 0 => assume NaN */ \
    ((((u)->us[DUK_DBL_IDX_US0] & 0x7ff0UL) == 0x7ff0UL) && \
     (((u)->us[DUK_DBL_IDX_US0] & 0x000fUL) != 0x0000UL))

Definition at line 1451 of file duktape-1.5.2/src-noline/duktape.h.

#endif  /* DUK_USE_64BIT_OPS */
 
#define DUK__DBLUNION_IS_NAN_NOTFULL(u) \
    /* E == 0x7ff, topmost four bits of F != 0 => assume NaN */ \

◆ DUK__DBLUNION_IS_NORMALIZED_NAN_FULL

#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL ( u )

Value:

(((u)->ui[DUK_DBL_IDX_UI0] == 0x7ff80000UL) && \

((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))

Definition at line 1465 of file duktape-1.5.2/src-noline/duktape.h.

#endif
#else  /* DUK_USE_64BIT_OPS */
#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \

◆ DUK__DBLUNION_IS_NORMALIZED_NAN_NOTFULL

#define DUK__DBLUNION_IS_NORMALIZED_NAN_NOTFULL ( u )

Value:

/* E == 0x7ff, F == 8 => normalized NaN */ \

((u)->us[DUK_DBL_IDX_US0] == 0x7ff8UL)

Definition at line 1470 of file duktape-1.5.2/src-noline/duktape.h.

#endif  /* DUK_USE_64BIT_OPS */
 
#define DUK__DBLUNION_IS_NORMALIZED_NAN_NOTFULL(u) \

◆ DUK__DBLUNION_NORMALIZE_NAN_CHECK_FULL

#define DUK__DBLUNION_NORMALIZE_NAN_CHECK_FULL ( u )

Value:

        do { \
        if (DUK__DBLUNION_IS_NAN_FULL((u))) { \
            DUK__DBLUNION_SET_NAN_FULL((u)); \
        } \
    } while (0)

Definition at line 1474 of file duktape-1.5.2/src-noline/duktape.h.

    ((u)->us[DUK_DBL_IDX_US0] == 0x7ff8UL)
 
#define DUK__DBLUNION_NORMALIZE_NAN_CHECK_FULL(u)  do { \
        if (DUK__DBLUNION_IS_NAN_FULL((u))) { \
            DUK__DBLUNION_SET_NAN_FULL((u)); \

◆ DUK__DBLUNION_NORMALIZE_NAN_CHECK_NOTFULL

#define DUK__DBLUNION_NORMALIZE_NAN_CHECK_NOTFULL ( u )

Value:

        do { \
        if (DUK__DBLUNION_IS_NAN_NOTFULL((u))) { \
            DUK__DBLUNION_SET_NAN_NOTFULL((u)); \
        } \
    } while (0)

Definition at line 1480 of file duktape-1.5.2/src-noline/duktape.h.

    } while (0)
 
#define DUK__DBLUNION_NORMALIZE_NAN_CHECK_NOTFULL(u)  do { \
        if (DUK__DBLUNION_IS_NAN_NOTFULL((u))) { \
            DUK__DBLUNION_SET_NAN_NOTFULL((u)); \

◆ DUK__DBLUNION_SET_NAN_FULL

#define DUK__DBLUNION_SET_NAN_FULL ( u )

Value:

        do { \
        (u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) 0x7ff80000UL; \
        (u)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) 0x00000000UL; \
    } while (0)

Definition at line 1421 of file duktape-1.5.2/src-noline/duktape.h.

#endif
#else  /* DUK_USE_64BIT_OPS */
#define DUK__DBLUNION_SET_NAN_FULL(u)  do { \
        (u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) 0x7ff80000UL; \

◆ DUK__DBLUNION_SET_NAN_NOTFULL

#define DUK__DBLUNION_SET_NAN_NOTFULL ( u )

Value:

        do { \
        (u)->us[DUK_DBL_IDX_US0] = 0x7ff8UL; \
    } while (0)

Definition at line 1427 of file duktape-1.5.2/src-noline/duktape.h.

#endif  /* DUK_USE_64BIT_OPS */
 
#define DUK__DBLUNION_SET_NAN_NOTFULL(u)  do { \

◆ DUK_API_ENTRY_STACK

#define DUK_API_ENTRY_STACK 64

Definition at line 249 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_API_NORETURN

#define DUK_API_NORETURN ( decl ) DUK_NORETURN(decl)

Definition at line 156 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_API_PUBLIC_H_INCLUDED

#define DUK_API_PUBLIC_H_INCLUDED

Definition at line 137 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_BUF_FLAG_DYNAMIC

#define DUK_BUF_FLAG_DYNAMIC (1 << 0) /* internal flag: dynamic buffer */

Definition at line 562 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_hbuffer_alloc().

◆ DUK_BUF_FLAG_EXTERNAL

#define DUK_BUF_FLAG_EXTERNAL (1 << 1) /* internal flag: external buffer */

Definition at line 563 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_hbuffer_alloc().

◆ DUK_BUF_FLAG_NOZERO

#define DUK_BUF_FLAG_NOZERO (1 << 2) /* internal flag: don't zero allocated buffer */

Definition at line 564 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_hbuffer_alloc(), duk_hex_decode(), and duk_hex_encode().

◆ DUK_BUF_MODE_DONTCARE

#define DUK_BUF_MODE_DONTCARE 2 /* internal: don't care about fixed/dynamic nature */

Definition at line 761 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_to_buffer_raw().

◆ DUK_BUF_MODE_DYNAMIC

#define DUK_BUF_MODE_DYNAMIC 1 /* internal: request dynamic buffer result */

Definition at line 760 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_to_buffer_raw().

◆ DUK_BUF_MODE_FIXED

#define DUK_BUF_MODE_FIXED 0 /* internal: request fixed buffer result */

Definition at line 759 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_to_buffer_raw().

◆ DUK_BUFOBJ_ARRAYBUFFER

#define DUK_BUFOBJ_ARRAYBUFFER 2

Definition at line 580 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_BUFOBJ_CREATE_ARRBUF

#define DUK_BUFOBJ_CREATE_ARRBUF (1 << 4) /* internal flag: create backing ArrayBuffer; keep in one byte */

Definition at line 577 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_push_buffer_object().

◆ DUK_BUFOBJ_DATAVIEW

#define DUK_BUFOBJ_DATAVIEW (3 | DUK_BUFOBJ_CREATE_ARRBUF)

Definition at line 581 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_BUFOBJ_DUKTAPE_BUFFER

#define DUK_BUFOBJ_DUKTAPE_BUFFER 0

Definition at line 578 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_BUFOBJ_FLOAT32ARRAY

#define DUK_BUFOBJ_FLOAT32ARRAY (11 | DUK_BUFOBJ_CREATE_ARRBUF)

Definition at line 589 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_BUFOBJ_FLOAT64ARRAY

#define DUK_BUFOBJ_FLOAT64ARRAY (12 | DUK_BUFOBJ_CREATE_ARRBUF)

Definition at line 590 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_BUFOBJ_INT16ARRAY

#define DUK_BUFOBJ_INT16ARRAY (7 | DUK_BUFOBJ_CREATE_ARRBUF)

Definition at line 585 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_BUFOBJ_INT32ARRAY

#define DUK_BUFOBJ_INT32ARRAY (9 | DUK_BUFOBJ_CREATE_ARRBUF)

Definition at line 587 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_BUFOBJ_INT8ARRAY

#define DUK_BUFOBJ_INT8ARRAY (4 | DUK_BUFOBJ_CREATE_ARRBUF)

Definition at line 582 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_BUFOBJ_NODEJS_BUFFER

#define DUK_BUFOBJ_NODEJS_BUFFER 1

Definition at line 579 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_BUFOBJ_UINT16ARRAY

#define DUK_BUFOBJ_UINT16ARRAY (8 | DUK_BUFOBJ_CREATE_ARRBUF)

Definition at line 586 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_BUFOBJ_UINT32ARRAY

#define DUK_BUFOBJ_UINT32ARRAY (10 | DUK_BUFOBJ_CREATE_ARRBUF)

Definition at line 588 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_BUFOBJ_UINT8ARRAY

#define DUK_BUFOBJ_UINT8ARRAY (5 | DUK_BUFOBJ_CREATE_ARRBUF)

Definition at line 583 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_BUFOBJ_UINT8CLAMPEDARRAY

#define DUK_BUFOBJ_UINT8CLAMPEDARRAY (6 | DUK_BUFOBJ_CREATE_ARRBUF)

Definition at line 584 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_compile

#define duk_compile	(		ctx,
			flags ) ((void) duk_compile_raw((ctx), NULL, 0, 3 /args/ \| (flags)))

Definition at line 936 of file duktape-1.5.2/src-noline/duktape.h.

936 (duk_eval_raw((ctx), NULL, 0, 2 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))

937

duk_eval_raw

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)

Definition duktape-1.5.2/src-noline/duktape.c:13532

DUK_COMPILE_SAFE

#define DUK_COMPILE_SAFE

Definition duktape-1.5.2/src-noline/duktape.h:299

DUK_COMPILE_NORESULT

#define DUK_COMPILE_NORESULT

Definition duktape-1.5.2/src-noline/duktape.h:300

DUK_COMPILE_NOFILENAME

#define DUK_COMPILE_NOFILENAME

Definition duktape-1.5.2/src-noline/duktape.h:303

DUK_COMPILE_EVAL

#define DUK_COMPILE_EVAL

Definition duktape-1.5.2/src-noline/duktape.h:296

NULL

#define NULL

Definition gmacros.h:924

Referenced by do_sandbox_test(), do_sandbox_test(), and wrapped_compile_execute().

◆ DUK_COMPILE_EVAL

#define DUK_COMPILE_EVAL (1 << 3) /* compile eval code (instead of global code) */

Definition at line 296 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__do_compile(), duk_bi_global_object_require(), and duk_eval_raw().

◆ duk_compile_file

#define duk_compile_file	(	ctx,
		flags,
		path )

Value:

    ((void) duk_push_string_file_raw((ctx), (path), 0), \
     (void) duk_push_string((ctx), (path)), \
     (void) duk_compile_raw((ctx), NULL, 0, 3 /*args*/ | (flags)))

Definition at line 1013 of file duktape-1.5.2/src-noline/duktape.h.

     duk_eval_raw((ctx), NULL, 0, 3 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NORESULT))
 
#define duk_compile_file(ctx,flags,path)  \
    ((void) duk_push_string_file_raw((ctx), (path), 0), \

◆ DUK_COMPILE_FUNCTION

#define DUK_COMPILE_FUNCTION (1 << 4) /* compile function code (instead of global code) */

Definition at line 297 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__do_compile().

◆ duk_compile_lstring

#define duk_compile_lstring	(	ctx,
		flags,
		buf,
		len ) ((void) duk_compile_raw((ctx), buf, len, 1 /args/ \| (flags) \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_NOFILENAME))

Definition at line 980 of file duktape-1.5.2/src-noline/duktape.h.

980 (duk_eval_raw((ctx), buf, len, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))

981

DUK_COMPILE_NOSOURCE

#define DUK_COMPILE_NOSOURCE

Definition duktape-1.5.2/src-noline/duktape.h:301

◆ duk_compile_lstring_filename

#define duk_compile_lstring_filename	(	ctx,
		flags,
		buf,
		len ) ((void) duk_compile_raw((ctx), buf, len, 2 /args/ \| (flags) \| DUK_COMPILE_NOSOURCE))

Definition at line 983 of file duktape-1.5.2/src-noline/duktape.h.

983 ((void) duk_compile_raw((ctx), buf, len, 1 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NOFILENAME))

984

Referenced by wrapped_compile_execute(), and wrapped_compile_execute().

◆ DUK_COMPILE_NOFILENAME

#define DUK_COMPILE_NOFILENAME (1 << 10) /* (internal) no filename on stack */

Definition at line 303 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__do_compile(), and duk_compile_raw().

◆ DUK_COMPILE_NORESULT

#define DUK_COMPILE_NORESULT (1 << 7) /* (internal) omit eval result */

Definition at line 300 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_eval_raw().

◆ DUK_COMPILE_NOSOURCE

#define DUK_COMPILE_NOSOURCE (1 << 8) /* (internal) no source string on stack */

Definition at line 301 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__do_compile(), and duk_compile_raw().

◆ DUK_COMPILE_SAFE

#define DUK_COMPILE_SAFE (1 << 6) /* (internal) catch compilation errors */

Definition at line 299 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_compile_raw(), and duk_eval_raw().

◆ DUK_COMPILE_STRICT

#define DUK_COMPILE_STRICT (1 << 5) /* use strict (outer) context for global, eval, or function code */

Definition at line 298 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__do_compile().

◆ duk_compile_string

#define duk_compile_string	(	ctx,
		flags,
		src ) ((void) duk_compile_raw((ctx), (src), 0, 1 /args/ \| (flags) \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_STRLEN \| DUK_COMPILE_NOFILENAME))

Definition at line 955 of file duktape-1.5.2/src-noline/duktape.h.

955 (duk_eval_raw((ctx), (src), 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))

956

DUK_COMPILE_STRLEN

#define DUK_COMPILE_STRLEN

Definition duktape-1.5.2/src-noline/duktape.h:302

◆ duk_compile_string_filename

#define duk_compile_string_filename	(	ctx,
		flags,
		src ) ((void) duk_compile_raw((ctx), (src), 0, 2 /args/ \| (flags) \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_STRLEN))

Definition at line 958 of file duktape-1.5.2/src-noline/duktape.h.

958 ((void) duk_compile_raw((ctx), (src), 0, 1 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))

959

◆ DUK_COMPILE_STRLEN

#define DUK_COMPILE_STRLEN (1 << 9) /* (internal) take strlen() of src_buffer (avoids double evaluation in macro) */

Definition at line 302 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_compile_raw().

◆ duk_create_heap_default

#define duk_create_heap_default ( ) duk_create_heap(NULL, NULL, NULL, NULL, NULL)

Definition at line 398 of file duktape-1.5.2/src-noline/duktape.h.

398DUK_EXTERNAL_DECL void duk_destroy_heap(duk_context *ctx);

399

DUK_EXTERNAL_DECL

#define DUK_EXTERNAL_DECL

Definition duktape-1.5.2/src-noline/duk_config.h:2532

duk_destroy_heap

DUK_EXTERNAL_DECL void duk_destroy_heap(duk_context *ctx)

Definition duktape-1.5.2/src-noline/duktape.c:14033

duk_hthread

Definition duktape-1.5.2/src-noline/duktape.c:6190

Referenced by create_duktape_heap(), create_duktape_heap(), main(), and main().

◆ DUK_DATE_FLAG_EQUIVYEAR

#define DUK_DATE_FLAG_EQUIVYEAR (1 << 3) /* timeval breakdown: replace year with equivalent year in the [1971,2037] range for DST calculations */

Definition at line 1149 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_date_get_local_tzoffset_gmtime(), and duk_bi_date_timeval_to_parts().

◆ DUK_DATE_FLAG_LOCALTIME

#define DUK_DATE_FLAG_LOCALTIME (1 << 4) /* convert time value to local time */

Definition at line 1150 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__format_parts_iso8601(), duk__push_this_get_timeval_tzoffset(), duk_bi_date_constructor(), and duk_bi_date_get_timeval_from_dparts().

◆ DUK_DATE_FLAG_NAN_TO_RANGE_ERROR

#define DUK_DATE_FLAG_NAN_TO_RANGE_ERROR (1 << 1) /* timeval breakdown: internal time value NaN -> RangeError (toISOString) */

Definition at line 1147 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__push_this_get_timeval_tzoffset().

◆ DUK_DATE_FLAG_NAN_TO_ZERO

#define DUK_DATE_FLAG_NAN_TO_ZERO (1 << 0) /* timeval breakdown: internal time value NaN -> zero */

Definition at line 1146 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__push_this_get_timeval_tzoffset().

◆ DUK_DATE_FLAG_ONEBASED

#define DUK_DATE_FLAG_ONEBASED (1 << 2) /* timeval breakdown: convert month and day-of-month parts to one-based (default is zero-based) */

Definition at line 1148 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__to_string_helper(), duk_bi_date_format_timeval(), and duk_bi_date_timeval_to_parts().

◆ DUK_DATE_FLAG_SEP_T

#define DUK_DATE_FLAG_SEP_T (1 << 11) /* string conversion: use 'T' instead of ' ' as a separator */

Definition at line 1157 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__format_parts_iso8601(), and duk_bi_date_format_timeval().

◆ DUK_DATE_FLAG_SUB1900

#define DUK_DATE_FLAG_SUB1900 (1 << 5) /* getter: subtract 1900 from year when getting year part */

Definition at line 1151 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__get_part_helper().

◆ DUK_DATE_FLAG_TIMESETTER

#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) */

Definition at line 1155 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__set_part_helper().

◆ DUK_DATE_FLAG_TOSTRING_DATE

#define DUK_DATE_FLAG_TOSTRING_DATE (1 << 6) /* include date part in string conversion result */

Definition at line 1152 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__format_parts_iso8601(), and duk_bi_date_format_timeval().

◆ DUK_DATE_FLAG_TOSTRING_LOCALE

#define DUK_DATE_FLAG_TOSTRING_LOCALE (1 << 8) /* use locale specific formatting if available */

Definition at line 1154 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__to_string_helper().

◆ DUK_DATE_FLAG_TOSTRING_TIME

#define DUK_DATE_FLAG_TOSTRING_TIME (1 << 7) /* include time part in string conversion result */

Definition at line 1153 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__format_parts_iso8601(), and duk_bi_date_format_timeval().

◆ DUK_DATE_FLAG_VALUE_SHIFT

#define DUK_DATE_FLAG_VALUE_SHIFT 12 /* additional values begin at bit 12 */

Definition at line 1158 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__get_part_helper(), and duk__set_part_helper().

◆ DUK_DATE_FLAG_YEAR_FIXUP

#define DUK_DATE_FLAG_YEAR_FIXUP (1 << 10) /* setter: perform 2-digit year fixup (00...99 -> 1900...1999) */

Definition at line 1156 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__set_part_helper().

◆ DUK_DATE_IDX_DAY

#define DUK_DATE_IDX_DAY 2 /* day within month: 0 to 30 */

Definition at line 1122 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__format_parts_iso8601(), duk__parse_string_iso8601_subset(), duk__set_part_helper(), duk__set_parts_from_args(), duk__to_string_helper(), duk_bi_date_get_timeval_from_dparts(), and duk_bi_date_timeval_to_parts().

◆ DUK_DATE_IDX_HOUR

#define DUK_DATE_IDX_HOUR 3

Definition at line 1123 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__format_parts_iso8601(), duk_bi_date_get_timeval_from_dparts(), and duk_bi_date_timeval_to_parts().

◆ DUK_DATE_IDX_MILLISECOND

#define DUK_DATE_IDX_MILLISECOND 6

Definition at line 1126 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__format_parts_iso8601(), duk__set_part_helper(), duk_bi_date_get_timeval_from_dparts(), and duk_bi_date_timeval_to_parts().

◆ DUK_DATE_IDX_MINUTE

#define DUK_DATE_IDX_MINUTE 4

Definition at line 1124 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__format_parts_iso8601(), duk_bi_date_get_timeval_from_dparts(), and duk_bi_date_timeval_to_parts().

◆ DUK_DATE_IDX_MONTH

#define DUK_DATE_IDX_MONTH 1 /* month: 0 to 11 */

Definition at line 1121 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__format_parts_iso8601(), duk__parse_string_iso8601_subset(), duk__to_string_helper(), duk_bi_date_get_timeval_from_dparts(), and duk_bi_date_timeval_to_parts().

◆ DUK_DATE_IDX_NUM_PARTS

#define DUK_DATE_IDX_NUM_PARTS 8

Definition at line 1128 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__get_part_helper(), duk__parse_string_iso8601_subset(), duk__set_part_helper(), duk__to_string_helper(), duk_bi_date_constructor(), duk_bi_date_constructor_utc(), duk_bi_date_format_timeval(), duk_bi_date_get_local_tzoffset_gmtime(), and duk_bi_date_timeval_to_parts().

◆ DUK_DATE_IDX_SECOND

#define DUK_DATE_IDX_SECOND 5

Definition at line 1125 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__format_parts_iso8601(), duk_bi_date_get_timeval_from_dparts(), and duk_bi_date_timeval_to_parts().

◆ DUK_DATE_IDX_WEEKDAY

#define DUK_DATE_IDX_WEEKDAY 7 /* weekday: 0 to 6, 0=sunday, 1=monday, etc */

Definition at line 1127 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_date_timeval_to_parts().

◆ DUK_DATE_IDX_YEAR

#define DUK_DATE_IDX_YEAR 0 /* year */

Definition at line 1120 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__format_parts_iso8601(), duk__parse_string_iso8601_subset(), duk__set_part_helper(), duk__set_parts_from_args(), duk_bi_date_get_local_tzoffset_gmtime(), duk_bi_date_get_timeval_from_dparts(), and duk_bi_date_timeval_to_parts().

◆ DUK_DATE_MAX_ECMA_YEAR

#define DUK_DATE_MAX_ECMA_YEAR 275760L

Definition at line 1110 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_date_year_in_valid_range().

◆ DUK_DATE_MIN_ECMA_YEAR

#define DUK_DATE_MIN_ECMA_YEAR (-271821L)

Definition at line 1109 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_date_year_in_valid_range().

◆ DUK_DATE_MSEC_100M_DAYS

#define DUK_DATE_MSEC_100M_DAYS (8.64e15)

Definition at line 1100 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_date_timeval_in_valid_range().

◆ DUK_DATE_MSEC_100M_DAYS_LEEWAY

#define DUK_DATE_MSEC_100M_DAYS_LEEWAY (8.64e15 + 24 * 3600e3)

Definition at line 1101 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_date_timeval_in_leeway_range().

◆ DUK_DATE_MSEC_DAY

#define DUK_DATE_MSEC_DAY (24L * 60L * 60L * 1000L)

Definition at line 1093 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_date_get_timeval_from_dparts(), and duk_bi_date_timeval_to_parts().

◆ DUK_DATE_MSEC_HOUR

#define DUK_DATE_MSEC_HOUR (60L * 60L * 1000L)

Definition at line 1092 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_date_get_timeval_from_dparts().

◆ DUK_DATE_MSEC_MINUTE

#define DUK_DATE_MSEC_MINUTE (60L * 1000L)

Definition at line 1091 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_date_get_timeval_from_dparts().

◆ DUK_DATE_MSEC_SECOND

#define DUK_DATE_MSEC_SECOND 1000L

Definition at line 1090 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_date_get_timeval_from_dparts().

◆ DUK_DBLUNION_BSWAP64

#define DUK_DBLUNION_BSWAP64 ( u )

Value:

        do { \
        duk_uint32_t duk__bswaptmp1, duk__bswaptmp2; \
        duk__bswaptmp1 = (u)->ui[0]; \
        duk__bswaptmp2 = (u)->ui[1]; \
        duk__bswaptmp1 = DUK_BSWAP32(duk__bswaptmp1); \
        duk__bswaptmp2 = DUK_BSWAP32(duk__bswaptmp2); \
        (u)->ui[0] = duk__bswaptmp2; \
        (u)->ui[1] = duk__bswaptmp1; \
    } while (0)

Definition at line 1521 of file duktape-1.5.2/src-noline/duktape.h.

 
/* 64-bit byteswap, same operation independent of target endianness. */
#define DUK_DBLUNION_BSWAP64(u) do { \
        duk_uint32_t duk__bswaptmp1, duk__bswaptmp2; \
        duk__bswaptmp1 = (u)->ui[0]; \
        duk__bswaptmp2 = (u)->ui[1]; \
        duk__bswaptmp1 = DUK_BSWAP32(duk__bswaptmp1); \
        duk__bswaptmp2 = DUK_BSWAP32(duk__bswaptmp2); \
        (u)->ui[0] = duk__bswaptmp2; \

Referenced by duk_bi_buffer_readfield(), and duk_bi_buffer_writefield().

◆ DUK_DBLUNION_DOUBLE_NTOH

#define DUK_DBLUNION_DOUBLE_NTOH ( u ) DUK_DBLUNION_DOUBLE_HTON((u))

Definition at line 1561 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_DBLUNION_GET_DOUBLE

#define DUK_DBLUNION_GET_DOUBLE ( u ) ((u)->d)

Definition at line 1361 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__dragon4_ctx_to_double().

◆ DUK_DBLUNION_GET_HIGH32

#define DUK_DBLUNION_GET_HIGH32 ( u ) ((u)->ui[DUK_DBL_IDX_UI0])

Definition at line 1362 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__dragon4_ctx_to_double(), and duk__dragon4_double_to_ctx().

◆ DUK_DBLUNION_GET_LOW32

#define DUK_DBLUNION_GET_LOW32 ( u ) ((u)->ui[DUK_DBL_IDX_UI1])

Definition at line 1363 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__dragon4_ctx_to_double(), and duk__dragon4_double_to_ctx().

◆ DUK_DBLUNION_H_INCLUDED

#define DUK_DBLUNION_H_INCLUDED

Definition at line 1237 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_DBLUNION_IS_NAN

#define DUK_DBLUNION_IS_NAN ( u ) (DUK_ISNAN((u)->d))

Definition at line 1509 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_DBLUNION_IS_NORMALIZED

#define DUK_DBLUNION_IS_NORMALIZED ( u ) 1 /* all doubles are considered normalized */

Definition at line 1511 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__vm_arith_add(), duk__vm_arith_binary_op(), duk__vm_arith_unary_op(), duk_js_tonumber(), and duk_push_nan().

◆ DUK_DBLUNION_IS_NORMALIZED_NAN

#define DUK_DBLUNION_IS_NORMALIZED_NAN ( u ) (DUK_ISNAN((u)->d))

Definition at line 1510 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_DBLUNION_NORMALIZE_NAN_CHECK

#define DUK_DBLUNION_NORMALIZE_NAN_CHECK ( u ) /* nop: no need to normalize */

Definition at line 1508 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__expr_nud(), duk__ivalue_toplain_raw(), duk__vm_arith_add(), duk__vm_arith_binary_op(), duk__vm_arith_unary_op(), duk_get_number(), duk_push_number(), and duk_require_number().

◆ DUK_DBLUNION_SET_DOUBLE

#define DUK_DBLUNION_SET_DOUBLE	(		u,
			v )

Value:

        do {  \
        (u)->d = (v); \
    } while (0)

Definition at line 1332 of file duktape-1.5.2/src-noline/duktape.h.

 */
 
#define DUK_DBLUNION_SET_DOUBLE(u,v)  do {  \

Referenced by duk__dragon4_double_to_ctx().

◆ DUK_DBLUNION_SET_HIGH32

#define DUK_DBLUNION_SET_HIGH32	(		u,
			v )

Value:

        do {  \
        (u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) (v); \
    } while (0)

Definition at line 1336 of file duktape-1.5.2/src-noline/duktape.h.

    } while (0)
 
#define DUK_DBLUNION_SET_HIGH32(u,v)  do {  \

Referenced by duk__dragon4_ctx_to_double().

◆ DUK_DBLUNION_SET_HIGH32_ZERO_LOW32

#define DUK_DBLUNION_SET_HIGH32_ZERO_LOW32	(		u,
			v )

Value:

        do { \
        (u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) (v); \
        (u)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) 0; \
    } while (0)

Definition at line 1351 of file duktape-1.5.2/src-noline/duktape.h.

#endif
#else  /* DUK_USE_64BIT_OPS */
#define DUK_DBLUNION_SET_HIGH32_ZERO_LOW32(u,v)  do { \
        (u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) (v); \

◆ DUK_DBLUNION_SET_LOW32

#define DUK_DBLUNION_SET_LOW32	(		u,
			v )

Value:

        do {  \
        (u)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (v); \
    } while (0)

Definition at line 1357 of file duktape-1.5.2/src-noline/duktape.h.

#endif  /* DUK_USE_64BIT_OPS */
 
#define DUK_DBLUNION_SET_LOW32(u,v)  do {  \

Referenced by duk__dragon4_ctx_to_double().

◆ DUK_DBLUNION_SET_NAN

#define DUK_DBLUNION_SET_NAN ( u )

Value:

        do { \
        /* in non-packed representation we don't care about which NaN is used */ \
        (u)->d = DUK_DOUBLE_NAN; \
    } while (0)

Definition at line 1512 of file duktape-1.5.2/src-noline/duktape.h.

#define DUK_DBLUNION_IS_NORMALIZED_NAN(u)    (DUK_ISNAN((u)->d))
#define DUK_DBLUNION_IS_NORMALIZED(u)        1  /* all doubles are considered normalized */
#define DUK_DBLUNION_SET_NAN(u)  do { \
        /* in non-packed representation we don't care about which NaN is used */ \

Referenced by duk_js_tonumber(), and duk_push_nan().

◆ DUK_DEBUG_PROTOCOL_VERSION

#define DUK_DEBUG_PROTOCOL_VERSION 1

Definition at line 233 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_debugger_attach

#define duk_debugger_attach	(	ctx,
		read_cb,
		write_cb,
		peek_cb,
		read_flush_cb,
		write_flush_cb,
		detached_cb,
		udata )

Value:

duk_debugger_attach_custom((ctx), (read_cb), (write_cb), (peek_cb), (read_flush_cb), (write_flush_cb), \

NULL, (detached_cb), (udata))

duk_debugger_attach_custom

DUK_EXTERNAL_DECL void duk_debugger_attach_custom(duk_context *ctx, duk_debug_read_function read_cb, duk_debug_write_function write_cb, duk_debug_peek_function peek_cb, duk_debug_read_flush_function read_flush_cb, duk_debug_write_flush_function write_flush_cb, duk_debug_request_function request_cb, duk_debug_detached_function detached_cb, void *udata)

Definition duktape-1.5.2/src-noline/duktape.c:13920

Definition at line 1064 of file duktape-1.5.2/src-noline/duktape.h.

 */
 
#define duk_debugger_attach(ctx,read_cb,write_cb,peek_cb,read_flush_cb,write_flush_cb,detached_cb,udata) \

Referenced by main().

◆ DUK_DEFPROP_CLEAR_CONFIGURABLE

#define DUK_DEFPROP_CLEAR_CONFIGURABLE DUK_DEFPROP_HAVE_CONFIGURABLE

Definition at line 321 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_DEFPROP_CLEAR_ENUMERABLE

#define DUK_DEFPROP_CLEAR_ENUMERABLE DUK_DEFPROP_HAVE_ENUMERABLE

Definition at line 319 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_DEFPROP_CLEAR_WRITABLE

#define DUK_DEFPROP_CLEAR_WRITABLE DUK_DEFPROP_HAVE_WRITABLE

Definition at line 317 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_DEFPROP_CONFIGURABLE

#define DUK_DEFPROP_CONFIGURABLE (1 << 2) /* set configurable (effective if DUK_DEFPROP_HAVE_CONFIGURABLE set) */

Definition at line 308 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__error_setter_helper(), duk_hobject_define_property_helper(), and duk_hobject_prepare_property_descriptor().

◆ DUK_DEFPROP_ENUMERABLE

#define DUK_DEFPROP_ENUMERABLE (1 << 1) /* set enumerable (effective if DUK_DEFPROP_HAVE_ENUMERABLE set) */

Definition at line 307 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_hobject_define_property_helper(), and duk_hobject_prepare_property_descriptor().

◆ DUK_DEFPROP_FORCE

#define DUK_DEFPROP_FORCE (1 << 9) /* force change if possible, may still fail for e.g. virtual properties */

Definition at line 315 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_global_object_require(), and duk_hobject_define_property_helper().

◆ DUK_DEFPROP_HAVE_CONFIGURABLE

#define DUK_DEFPROP_HAVE_CONFIGURABLE (1 << 5) /* set/clear configurable */

Definition at line 311 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__error_setter_helper(), duk_hobject_define_property_helper(), and duk_hobject_prepare_property_descriptor().

◆ DUK_DEFPROP_HAVE_ENUMERABLE

#define DUK_DEFPROP_HAVE_ENUMERABLE (1 << 4) /* set/clear enumerable */

Definition at line 310 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__error_setter_helper(), duk_hobject_define_property_helper(), and duk_hobject_prepare_property_descriptor().

◆ DUK_DEFPROP_HAVE_GETTER

#define DUK_DEFPROP_HAVE_GETTER (1 << 7) /* set getter (given on value stack) */

Definition at line 313 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_def_prop(), duk_hobject_define_property_helper(), and duk_hobject_prepare_property_descriptor().

◆ DUK_DEFPROP_HAVE_SETTER

#define DUK_DEFPROP_HAVE_SETTER (1 << 8) /* set setter (given on value stack) */

Definition at line 314 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_def_prop(), duk_hobject_define_property_helper(), and duk_hobject_prepare_property_descriptor().

◆ DUK_DEFPROP_HAVE_VALUE

#define DUK_DEFPROP_HAVE_VALUE (1 << 6) /* set value (given on value stack) */

Definition at line 312 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__error_setter_helper(), duk_bi_global_object_require(), duk_def_prop(), duk_hobject_define_property_helper(), and duk_hobject_prepare_property_descriptor().

◆ DUK_DEFPROP_HAVE_WRITABLE

#define DUK_DEFPROP_HAVE_WRITABLE (1 << 3) /* set/clear writable */

Definition at line 309 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__error_setter_helper(), duk_def_prop(), duk_hobject_define_property_helper(), and duk_hobject_prepare_property_descriptor().

◆ DUK_DEFPROP_SET_CONFIGURABLE

#define DUK_DEFPROP_SET_CONFIGURABLE (DUK_DEFPROP_HAVE_CONFIGURABLE | DUK_DEFPROP_CONFIGURABLE)

Definition at line 320 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_DEFPROP_SET_ENUMERABLE

#define DUK_DEFPROP_SET_ENUMERABLE (DUK_DEFPROP_HAVE_ENUMERABLE | DUK_DEFPROP_ENUMERABLE)

Definition at line 318 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_DEFPROP_SET_WRITABLE

#define DUK_DEFPROP_SET_WRITABLE (DUK_DEFPROP_HAVE_WRITABLE | DUK_DEFPROP_WRITABLE)

Definition at line 316 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_DEFPROP_WRITABLE

#define DUK_DEFPROP_WRITABLE (1 << 0) /* set writable (effective if DUK_DEFPROP_HAVE_WRITABLE set) */

Definition at line 306 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__error_setter_helper(), duk_hobject_define_property_helper(), and duk_hobject_prepare_property_descriptor().

◆ duk_dump_context_filehandle

#define duk_dump_context_filehandle	(		ctx,
			fh )

Value:

    (duk_push_context_dump((ctx)), \
     DUK_FPRINTF((fh), "%s\n", duk_safe_to_string(ctx, -1)), \
     duk_pop(ctx))

Definition at line 1045 of file duktape-1.5.2/src-noline/duktape.h.

#if defined(DUK_USE_FILE_IO)
/* internal use */
#define duk_dump_context_filehandle(ctx,fh) \
    (duk_push_context_dump((ctx)), \

◆ duk_dump_context_stderr

#define duk_dump_context_stderr ( ctx ) duk_dump_context_filehandle((ctx), DUK_STDERR)

Definition at line 1053 of file duktape-1.5.2/src-noline/duktape.h.

1053#define duk_dump_context_stdout(ctx) \

1054 duk_dump_context_filehandle((ctx), DUK_STDOUT)

◆ duk_dump_context_stdout

#define duk_dump_context_stdout ( ctx ) duk_dump_context_filehandle((ctx), DUK_STDOUT)

Definition at line 1051 of file duktape-1.5.2/src-noline/duktape.h.

1051

1052/* external use */

◆ DUK_ENUM_ARRAY_INDICES_ONLY

#define DUK_ENUM_ARRAY_INDICES_ONLY (1 << 3) /* only enumerate array indices */

Definition at line 287 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_json_stringify_helper(), and duk_hobject_enumerator_create().

◆ DUK_ENUM_INCLUDE_INTERNAL

#define DUK_ENUM_INCLUDE_INTERNAL (1 << 1) /* enumerate internal properties (regardless of enumerability) */

Definition at line 285 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_hobject_enumerator_create().

◆ DUK_ENUM_INCLUDE_NONENUMERABLE

#define DUK_ENUM_INCLUDE_NONENUMERABLE (1 << 0) /* enumerate non-numerable properties in addition to enumerable */

Definition at line 284 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_object_constructor_keys_shared(), and duk_hobject_enumerator_create().

◆ DUK_ENUM_NO_PROXY_BEHAVIOR

#define DUK_ENUM_NO_PROXY_BEHAVIOR (1 << 5) /* enumerate a proxy object itself without invoking proxy behavior */

Definition at line 289 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_object_constructor_keys_shared(), and duk_hobject_enumerator_create().

◆ DUK_ENUM_OWN_PROPERTIES_ONLY

#define DUK_ENUM_OWN_PROPERTIES_ONLY (1 << 2) /* don't walk prototype chain, only check own properties */

Definition at line 286 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__dec_reviver_walk(), duk__enc_object(), duk_bi_object_constructor_define_properties(), duk_bi_object_constructor_keys_shared(), and duk_hobject_enumerator_create().

◆ DUK_ENUM_SORT_ARRAY_INDICES

#define DUK_ENUM_SORT_ARRAY_INDICES (1 << 4) /* sort array indices, use with DUK_ENUM_ARRAY_INDICES_ONLY */

Definition at line 288 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_json_stringify_helper(), and duk_hobject_enumerator_create().

◆ DUK_ERR_ALLOC_ERROR

#define DUK_ERR_ALLOC_ERROR 53 /* AllocError */ /* XXX: replace with RangeError? */

Definition at line 334 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_err_alloc(), duk_err_create_and_throw(), and duk_error_prototype_from_code().

◆ DUK_ERR_API_ERROR

#define DUK_ERR_API_ERROR 55 /* APIError */ /* XXX: replace with TypeError? */

Definition at line 336 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_err_alloc(), duk_err_api(), duk_err_api_index(), duk_err_internal(), duk_error_prototype_from_code(), duk_fatal(), duk_handle_call_protected(), duk_handle_safe_call(), and duk_js_execute_bytecode().

◆ DUK_ERR_ASSERTION_ERROR

#define DUK_ERR_ASSERTION_ERROR 54 /* AssertionError */ /* XXX: to be removed? */

Definition at line 335 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_error_prototype_from_code().

◆ DUK_ERR_ERROR

#define DUK_ERR_ERROR 100 /* Error */

Definition at line 340 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by do_jxpretty(), do_jxpretty(), do_sandbox_test(), do_sandbox_test(), duk_error_prototype_from_code(), duk_get_error_code(), listen_fd(), listen_fd(), poll_poll(), poll_poll(), socket_connect(), socket_connect(), socket_create_server_socket(), socket_create_server_socket(), wrapped_compile_execute(), and wrapped_compile_execute().

◆ DUK_ERR_EVAL_ERROR

#define DUK_ERR_EVAL_ERROR 101 /* EvalError */

Definition at line 341 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_error_prototype_from_code(), and duk_get_error_code().

◆ DUK_ERR_INTERNAL_ERROR

#define DUK_ERR_INTERNAL_ERROR 52 /* InternalError */ /* XXX: replace with plain Error? */

Definition at line 333 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__js_execute_bytecode_inner(), duk_err_internal(), duk_err_internal_defmsg(), and duk_error_prototype_from_code().

◆ DUK_ERR_NONE

#define DUK_ERR_NONE 0 /* no error (e.g. from duk_get_error_code()) */

Definition at line 330 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_get_error_code().

◆ DUK_ERR_RANGE_ERROR

#define DUK_ERR_RANGE_ERROR 102 /* RangeError */

Definition at line 342 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by create_timer(), create_timer(), duk_decode_string_codepage(), duk_err_internal_defmsg(), duk_err_range(), duk_error_prototype_from_code(), duk_get_error_code(), expire_timers(), and expire_timers().

◆ DUK_ERR_REFERENCE_ERROR

#define DUK_ERR_REFERENCE_ERROR 103 /* ReferenceError */

Definition at line 343 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__getvar_helper(), duk__js_execute_bytecode_inner(), duk__putvar_helper(), duk_error_prototype_from_code(), duk_get_error_code(), and duk_js_putvar_envrec().

◆ DUK_ERR_SYNTAX_ERROR

#define DUK_ERR_SYNTAX_ERROR 104 /* SyntaxError */

Definition at line 344 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__dec_eat_white(), duk__dec_syntax_error(), duk_error_prototype_from_code(), and duk_get_error_code().

◆ DUK_ERR_TYPE_ERROR

#define DUK_ERR_TYPE_ERROR 105 /* TypeError */

Definition at line 345 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__bi_global_resolve_module_id(), duk__handle_call_inner(), duk__handle_safe_call_inner(), duk__nonbound_func_lookup(), duk_err_api(), duk_err_require_type_index(), duk_error_prototype_from_code(), duk_get_error_code(), duk_hobject_delprop(), duk_hobject_getprop(), and duk_hobject_putprop().

◆ DUK_ERR_UNCAUGHT_ERROR

#define DUK_ERR_UNCAUGHT_ERROR 56 /* UncaughtError */ /* XXX: to be removed? */

Definition at line 337 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_err_longjmp().

◆ DUK_ERR_UNIMPLEMENTED_ERROR

#define DUK_ERR_UNIMPLEMENTED_ERROR 50 /* UnimplementedError */ /* XXX: replace with TypeError? */

Definition at line 331 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_err_unimplemented_defmsg(), and duk_error_prototype_from_code().

◆ DUK_ERR_UNSUPPORTED_ERROR

#define DUK_ERR_UNSUPPORTED_ERROR 51 /* UnsupportedError */ /* XXX: replace with TypeError? */

Definition at line 332 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_ERR_URI_ERROR

#define DUK_ERR_URI_ERROR 106 /* URIError */

Definition at line 346 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__transform_callback_decode_uri(), duk__transform_callback_encode_uri(), duk_error_prototype_from_code(), duk_get_error_code(), and duk_push_tval().

◆ duk_error

#define duk_error

Value:

    (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
     duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
     duk_error_stash)  /* last value is func pointer, arguments follow in parens */

Definition at line 434 of file duktape-1.5.2/src-noline/duktape.h.

 * they make little sense anyway.
 */
#define duk_error  \
    (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \

Referenced by create_timer(), create_timer(), do_jxpretty(), do_jxpretty(), do_sandbox_test(), do_sandbox_test(), duk_decode_string_codepage(), expire_timers(), expire_timers(), listen_fd(), listen_fd(), poll_poll(), poll_poll(), socket_connect(), socket_connect(), socket_create_server_socket(), socket_create_server_socket(), wrapped_compile_execute(), and wrapped_compile_execute().

◆ duk_error_va

#define duk_error_va	(	ctx,
		err_code,
		fmt,
		ap ) duk_error_va_raw((ctx), (duk_errcode_t) (err_code), (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), (fmt), (ap))

Definition at line 441 of file duktape-1.5.2/src-noline/duktape.h.

441

442DUK_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));

duk_errcode_t

duk_int_t duk_errcode_t

Definition duktape-1.5.2/src-noline/duk_config.h:1857

duk_error_va_raw

DUK_EXTERNAL 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)

Definition duktape-1.5.2/src-noline/duktape.c:19240

DUK_API_NORETURN

#define DUK_API_NORETURN(decl)

Definition duktape-1.5.2/src-noline/duktape.h:156

◆ duk_eval

#define duk_eval ( ctx ) ((void) duk_eval_raw((ctx), NULL, 0, 2 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOFILENAME))

Definition at line 924 of file duktape-1.5.2/src-noline/duktape.h.

924

925/* plain */

Referenced by eval_raw(), and eval_raw().

◆ duk_eval_file

#define duk_eval_file	(		ctx,
			path )

Value:

    ((void) duk_push_string_file_raw((ctx), (path), 0), \
     (void) duk_push_string((ctx), (path)), \
     (void) duk_eval_raw((ctx), NULL, 0, 3 /*args*/ | DUK_COMPILE_EVAL))

Definition at line 993 of file duktape-1.5.2/src-noline/duktape.h.

 
/* file */
#define duk_eval_file(ctx,path)  \
    ((void) duk_push_string_file_raw((ctx), (path), 0), \

Referenced by main().

◆ duk_eval_file_noresult

#define duk_eval_file_noresult	(		ctx,
			path )

Value:

    ((void) duk_push_string_file_raw((ctx), (path), 0), \
     (void) duk_push_string((ctx), (path)), \
     (void) duk_eval_raw((ctx), NULL, 0, 3 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NORESULT))

Definition at line 998 of file duktape-1.5.2/src-noline/duktape.h.

     (void) duk_eval_raw((ctx), NULL, 0, 3 /*args*/ | DUK_COMPILE_EVAL))
 
#define duk_eval_file_noresult(ctx,path)  \
    ((void) duk_push_string_file_raw((ctx), (path), 0), \

◆ duk_eval_lstring

#define duk_eval_lstring	(	ctx,
		buf,
		len ) ((void) duk_eval_raw((ctx), buf, len, 1 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_NOFILENAME))

Definition at line 968 of file duktape-1.5.2/src-noline/duktape.h.

968

969/* lstring */

◆ duk_eval_lstring_noresult

#define duk_eval_lstring_noresult	(	ctx,
		buf,
		len ) ((void) duk_eval_raw((ctx), buf, len, 1 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_NORESULT \| DUK_COMPILE_NOFILENAME))

Definition at line 971 of file duktape-1.5.2/src-noline/duktape.h.

971 ((void) duk_eval_raw((ctx), buf, len, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NOFILENAME))

972

◆ duk_eval_noresult

#define duk_eval_noresult ( ctx ) ((void) duk_eval_raw((ctx), NULL, 0, 2 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))

Definition at line 927 of file duktape-1.5.2/src-noline/duktape.h.

927 ((void) duk_eval_raw((ctx), NULL, 0, 2 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOFILENAME))

928

Referenced by main().

◆ duk_eval_string

#define duk_eval_string	(		ctx,
			src ) ((void) duk_eval_raw((ctx), (src), 0, 1 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_STRLEN \| DUK_COMPILE_NOFILENAME))

Definition at line 943 of file duktape-1.5.2/src-noline/duktape.h.

943

944/* string */

Referenced by do_jxpretty(), do_jxpretty(), do_sandbox_test(), do_sandbox_test(), duk_hthread_create_builtin_objects(), handle_interactive(), handle_interactive(), main(), test1(), and wrapped_compile_execute().

◆ duk_eval_string_noresult

#define duk_eval_string_noresult	(		ctx,
			src ) ((void) duk_eval_raw((ctx), (src), 0, 1 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_STRLEN \| DUK_COMPILE_NORESULT \| DUK_COMPILE_NOFILENAME))

Definition at line 946 of file duktape-1.5.2/src-noline/duktape.h.

946 ((void) duk_eval_raw((ctx), (src), 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))

947

Referenced by duk_hthread_create_builtin_objects(), and main().

◆ DUK_EXEC_ERROR

#define DUK_EXEC_ERROR 1

Definition at line 366 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__pcall_prop_raw(), duk_eval_raw(), duk_handle_call_protected(), duk_handle_safe_call(), duk_pcall(), duk_pcall_method(), and duk_safe_call().

◆ DUK_EXEC_SUCCESS

#define DUK_EXEC_SUCCESS 0

Definition at line 365 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_global_object_require(), duk_bi_json_stringify_helper(), duk_compile_raw(), duk_eval_raw(), duk_handle_call_protected(), duk_handle_safe_call(), duk_hobject_run_finalizer(), duk_js_compile(), handle_eval(), handle_eval(), handle_fh(), handle_fh(), handle_fh(), handle_interactive(), and handle_interactive().

◆ DUK_GIT_BRANCH

#define DUK_GIT_BRANCH "HEAD"

Definition at line 230 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_GIT_COMMIT

#define DUK_GIT_COMMIT "cad34ae155acb0846545ca6bf2d29f9463b22bbb"

Definition at line 228 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_GIT_DESCRIBE

#define DUK_GIT_DESCRIBE "v1.5.2"

Definition at line 229 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_HINT_NONE

#define DUK_HINT_NONE

Value:

                                                0    /* prefer number, unless input is a Date, in which
                                                * case prefer string (E5 Section 8.12.8)
                                                */

Definition at line 279 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__vm_arith_add(), duk_bi_date_constructor(), duk_js_equals_helper(), duk_to_boolean(), duk_to_defaultvalue(), and duk_to_primitive().

◆ DUK_HINT_NUMBER

#define DUK_HINT_NUMBER 2 /* prefer number */

Definition at line 281 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_date_prototype_to_json(), duk_js_compare_helper(), duk_js_tonumber(), duk_to_boolean(), duk_to_defaultvalue(), and duk_to_primitive().

◆ DUK_HINT_STRING

#define DUK_HINT_STRING 1 /* prefer string */

Definition at line 280 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_to_boolean(), duk_to_defaultvalue(), duk_to_primitive(), and duk_to_string().

◆ DUK_INVALID_INDEX

#define DUK_INVALID_INDEX DUK_IDX_MIN

Definition at line 239 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_json_parse_helper(), duk_bi_json_stringify_helper(), duk_get_top(), duk_get_top_index(), duk_get_tval(), duk_is_valid_index(), duk_json_decode(), duk_json_encode(), duk_normalize_index(), duk_push_context_dump(), duk_require_normalize_index(), duk_require_top_index(), duk_require_tval(), duk_require_valid_index(), and duk_set_top().

◆ duk_is_callable

#define duk_is_callable	(		ctx,
			index ) duk_is_function((ctx), (index))

Definition at line 636 of file duktape-1.5.2/src-noline/duktape.h.

636DUK_EXTERNAL_DECL duk_bool_t duk_is_thread(duk_context *ctx, duk_idx_t index);

637

index

guint index

Definition deprecated/gthread.h:1

duk_idx_t

duk_int_t duk_idx_t

Definition duktape-1.5.2/src-noline/duk_config.h:1830

duk_bool_t

duk_small_int_t duk_bool_t

Definition duktape-1.5.2/src-noline/duk_config.h:1825

duk_is_thread

DUK_EXTERNAL_DECL duk_bool_t duk_is_thread(duk_context *ctx, duk_idx_t index)

Definition duktape-1.5.2/src-noline/duktape.c:17740

Referenced by duk__defaultvalue_coerce_attempt(), duk__enc_value(), duk__finalize_helper(), duk_bi_array_prototype_reduce_shared(), duk_bi_array_prototype_to_string(), duk_bi_function_prototype_apply(), duk_bi_function_prototype_bind(), duk_bi_json_parse_helper(), duk_bi_object_prototype_is_prototype_of(), duk_bi_object_prototype_to_locale_string(), duk_bi_thread_constructor(), duk_new(), and duk_to_defaultvalue().

◆ duk_is_error

#define duk_is_error	(		ctx,
			index ) (duk_get_error_code((ctx), (index)) != 0)

Definition at line 662 of file duktape-1.5.2/src-noline/duktape.h.

662

663DUK_EXTERNAL_DECL duk_errcode_t duk_get_error_code(duk_context *ctx, duk_idx_t index);

duk_get_error_code

DUK_EXTERNAL_DECL duk_errcode_t duk_get_error_code(duk_context *ctx, duk_idx_t index)

Definition duktape-1.5.2/src-noline/duktape.c:17789

Referenced by get_stack_raw(), and get_stack_raw().

◆ duk_is_eval_error

#define duk_is_eval_error	(		ctx,
			index ) (duk_get_error_code((ctx), (index)) == DUK_ERR_EVAL_ERROR)

Definition at line 664 of file duktape-1.5.2/src-noline/duktape.h.

664#define duk_is_error(ctx,index) \

665 (duk_get_error_code((ctx), (index)) != 0)

◆ duk_is_object_coercible

#define duk_is_object_coercible	(		ctx,
			index )

Value:

    duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_BOOLEAN | \
                                        DUK_TYPE_MASK_NUMBER | \
                                        DUK_TYPE_MASK_STRING | \
                                        DUK_TYPE_MASK_OBJECT | \
                                        DUK_TYPE_MASK_BUFFER | \
                                        DUK_TYPE_MASK_POINTER | \
                                        DUK_TYPE_MASK_LIGHTFUNC)

Definition at line 652 of file duktape-1.5.2/src-noline/duktape.h.

                                        DUK_TYPE_MASK_LIGHTFUNC)
 
#define duk_is_object_coercible(ctx,index) \
    duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_BOOLEAN | \
                                        DUK_TYPE_MASK_NUMBER | \
                                        DUK_TYPE_MASK_STRING | \
                                        DUK_TYPE_MASK_OBJECT | \
                                        DUK_TYPE_MASK_BUFFER | \

◆ duk_is_primitive

#define duk_is_primitive	(		ctx,
			index )

Value:

    duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_UNDEFINED | \
                                        DUK_TYPE_MASK_NULL | \
                                        DUK_TYPE_MASK_BOOLEAN | \
                                        DUK_TYPE_MASK_NUMBER | \
                                        DUK_TYPE_MASK_STRING | \
                                        DUK_TYPE_MASK_BUFFER | \
                                        DUK_TYPE_MASK_POINTER | \
                                        DUK_TYPE_MASK_LIGHTFUNC)

Definition at line 642 of file duktape-1.5.2/src-noline/duktape.h.

DUK_EXTERNAL_DECL duk_bool_t duk_is_external_buffer(duk_context *ctx, duk_idx_t index);
 
#define duk_is_primitive(ctx,index) \
    duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_UNDEFINED | \
                                        DUK_TYPE_MASK_NULL | \
                                        DUK_TYPE_MASK_BOOLEAN | \
                                        DUK_TYPE_MASK_NUMBER | \
                                        DUK_TYPE_MASK_STRING | \
                                        DUK_TYPE_MASK_BUFFER | \

Referenced by duk__defaultvalue_coerce_attempt(), and duk_to_defaultvalue().

◆ duk_is_range_error

#define duk_is_range_error	(		ctx,
			index ) (duk_get_error_code((ctx), (index)) == DUK_ERR_RANGE_ERROR)

Definition at line 666 of file duktape-1.5.2/src-noline/duktape.h.

666#define duk_is_eval_error(ctx,index) \

667 (duk_get_error_code((ctx), (index)) == DUK_ERR_EVAL_ERROR)

◆ duk_is_reference_error

#define duk_is_reference_error	(		ctx,
			index ) (duk_get_error_code((ctx), (index)) == DUK_ERR_REFERENCE_ERROR)

Definition at line 668 of file duktape-1.5.2/src-noline/duktape.h.

668#define duk_is_range_error(ctx,index) \

669 (duk_get_error_code((ctx), (index)) == DUK_ERR_RANGE_ERROR)

◆ duk_is_syntax_error

#define duk_is_syntax_error	(		ctx,
			index ) (duk_get_error_code((ctx), (index)) == DUK_ERR_SYNTAX_ERROR)

Definition at line 670 of file duktape-1.5.2/src-noline/duktape.h.

670#define duk_is_reference_error(ctx,index) \

671 (duk_get_error_code((ctx), (index)) == DUK_ERR_REFERENCE_ERROR)

◆ duk_is_type_error

#define duk_is_type_error	(		ctx,
			index ) (duk_get_error_code((ctx), (index)) == DUK_ERR_TYPE_ERROR)

Definition at line 672 of file duktape-1.5.2/src-noline/duktape.h.

672#define duk_is_syntax_error(ctx,index) \

673 (duk_get_error_code((ctx), (index)) == DUK_ERR_SYNTAX_ERROR)

◆ duk_is_uri_error

#define duk_is_uri_error	(		ctx,
			index ) (duk_get_error_code((ctx), (index)) == DUK_ERR_URI_ERROR)

Definition at line 674 of file duktape-1.5.2/src-noline/duktape.h.

674#define duk_is_type_error(ctx,index) \

675 (duk_get_error_code((ctx), (index)) == DUK_ERR_TYPE_ERROR)

◆ DUK_LOG_DEBUG

#define DUK_LOG_DEBUG 1

Definition at line 370 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_LOG_ERROR

#define DUK_LOG_ERROR 4

Definition at line 373 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_LOG_FATAL

#define DUK_LOG_FATAL 5

Definition at line 374 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_LOG_INFO

#define DUK_LOG_INFO 2

Definition at line 371 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_LOG_TRACE

#define DUK_LOG_TRACE 0

Definition at line 369 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_LOG_WARN

#define DUK_LOG_WARN 3

Definition at line 372 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_pcompile

#define duk_pcompile	(		ctx,
			flags ) (duk_compile_raw((ctx), NULL, 0, 3 /args/ \| (flags) \| DUK_COMPILE_SAFE))

Definition at line 939 of file duktape-1.5.2/src-noline/duktape.h.

939 ((void) duk_compile_raw((ctx), NULL, 0, 3 /*args*/ | (flags)))

940

◆ duk_pcompile_file

#define duk_pcompile_file	(	ctx,
		flags,
		path )

Value:

    ((void) duk_push_string_file_raw((ctx), (path), DUK_STRING_PUSH_SAFE), \
     (void) duk_push_string((ctx), (path)), \
     duk_compile_raw((ctx), NULL, 0, 3 /*args*/ | (flags) | DUK_COMPILE_SAFE))

Definition at line 1018 of file duktape-1.5.2/src-noline/duktape.h.

     (void) duk_compile_raw((ctx), NULL, 0, 3 /*args*/ | (flags)))
 
#define duk_pcompile_file(ctx,flags,path)  \
    ((void) duk_push_string_file_raw((ctx), (path), DUK_STRING_PUSH_SAFE), \

◆ duk_pcompile_lstring

#define duk_pcompile_lstring	(	ctx,
		flags,
		buf,
		len ) (duk_compile_raw((ctx), buf, len, 1 /args/ \| (flags) \| DUK_COMPILE_SAFE \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_NOFILENAME))

Definition at line 986 of file duktape-1.5.2/src-noline/duktape.h.

986 ((void) duk_compile_raw((ctx), buf, len, 2 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE))

987

◆ duk_pcompile_lstring_filename

#define duk_pcompile_lstring_filename	(	ctx,
		flags,
		buf,
		len ) (duk_compile_raw((ctx), buf, len, 2 /args/ \| (flags) \| DUK_COMPILE_SAFE \| DUK_COMPILE_NOSOURCE))

Definition at line 989 of file duktape-1.5.2/src-noline/duktape.h.

989 (duk_compile_raw((ctx), buf, len, 1 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NOFILENAME))

990

◆ duk_pcompile_string

#define duk_pcompile_string	(	ctx,
		flags,
		src ) (duk_compile_raw((ctx), (src), 0, 1 /args/ \| (flags) \| DUK_COMPILE_SAFE \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_STRLEN \| DUK_COMPILE_NOFILENAME))

Definition at line 961 of file duktape-1.5.2/src-noline/duktape.h.

961 ((void) duk_compile_raw((ctx), (src), 0, 2 /*args*/ | (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN))

962

◆ duk_pcompile_string_filename

#define duk_pcompile_string_filename	(	ctx,
		flags,
		src ) (duk_compile_raw((ctx), (src), 0, 2 /args/ \| (flags) \| DUK_COMPILE_SAFE \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_STRLEN))

Definition at line 964 of file duktape-1.5.2/src-noline/duktape.h.

964 (duk_compile_raw((ctx), (src), 0, 1 /*args*/ | (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))

965

◆ duk_peval

#define duk_peval ( ctx ) (duk_eval_raw((ctx), NULL, 0, 2 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOFILENAME))

Definition at line 930 of file duktape-1.5.2/src-noline/duktape.h.

930 ((void) duk_eval_raw((ctx), NULL, 0, 2 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))

931

◆ duk_peval_file

#define duk_peval_file	(		ctx,
			path )

Value:

    ((void) duk_push_string_file_raw((ctx), (path), DUK_STRING_PUSH_SAFE), \
     (void) duk_push_string((ctx), (path)), \
     duk_eval_raw((ctx), NULL, 0, 3 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE))

Definition at line 1003 of file duktape-1.5.2/src-noline/duktape.h.

     (void) duk_eval_raw((ctx), NULL, 0, 3 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NORESULT))
 
#define duk_peval_file(ctx,path)  \
    ((void) duk_push_string_file_raw((ctx), (path), DUK_STRING_PUSH_SAFE), \

Referenced by main().

◆ duk_peval_file_noresult

#define duk_peval_file_noresult	(		ctx,
			path )

Value:

    ((void) duk_push_string_file_raw((ctx), (path), DUK_STRING_PUSH_SAFE), \
     (void) duk_push_string((ctx), (path)), \
     duk_eval_raw((ctx), NULL, 0, 3 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NORESULT))

Definition at line 1008 of file duktape-1.5.2/src-noline/duktape.h.

     duk_eval_raw((ctx), NULL, 0, 3 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE))
 
#define duk_peval_file_noresult(ctx,path)  \
    ((void) duk_push_string_file_raw((ctx), (path), DUK_STRING_PUSH_SAFE), \

◆ duk_peval_lstring

#define duk_peval_lstring	(	ctx,
		buf,
		len ) (duk_eval_raw((ctx), buf, len, 1 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_SAFE \| DUK_COMPILE_NOFILENAME))

Definition at line 974 of file duktape-1.5.2/src-noline/duktape.h.

974 ((void) duk_eval_raw((ctx), buf, len, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))

975

◆ duk_peval_lstring_noresult

#define duk_peval_lstring_noresult	(	ctx,
		buf,
		len ) (duk_eval_raw((ctx), buf, len, 1 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_SAFE \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_NORESULT \| DUK_COMPILE_NOFILENAME))

Definition at line 977 of file duktape-1.5.2/src-noline/duktape.h.

977 (duk_eval_raw((ctx), buf, len, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_SAFE | DUK_COMPILE_NOFILENAME))

978

◆ duk_peval_noresult

#define duk_peval_noresult ( ctx ) (duk_eval_raw((ctx), NULL, 0, 2 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))

Definition at line 933 of file duktape-1.5.2/src-noline/duktape.h.

933 (duk_eval_raw((ctx), NULL, 0, 2 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOFILENAME))

934

◆ duk_peval_string

#define duk_peval_string	(		ctx,
			src ) (duk_eval_raw((ctx), (src), 0, 1 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_SAFE \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_STRLEN \| DUK_COMPILE_NOFILENAME))

Definition at line 949 of file duktape-1.5.2/src-noline/duktape.h.

949 ((void) duk_eval_raw((ctx), (src), 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NORESULT | DUK_COMPILE_NOFILENAME))

950

◆ duk_peval_string_noresult

#define duk_peval_string_noresult	(		ctx,
			src ) (duk_eval_raw((ctx), (src), 0, 1 /args/ \| DUK_COMPILE_EVAL \| DUK_COMPILE_SAFE \| DUK_COMPILE_NOSOURCE \| DUK_COMPILE_STRLEN \| DUK_COMPILE_NORESULT \| DUK_COMPILE_NOFILENAME))

Definition at line 952 of file duktape-1.5.2/src-noline/duktape.h.

952 (duk_eval_raw((ctx), (src), 0, 1 /*args*/ | DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NOFILENAME))

953

◆ duk_push_buffer

#define duk_push_buffer	(	ctx,
		size,
		dynamic ) duk_push_buffer_raw((ctx), (size), (dynamic) ? DUK_BUF_FLAG_DYNAMIC : 0)

Definition at line 568 of file duktape-1.5.2/src-noline/duktape.h.

568DUK_EXTERNAL_DECL void *duk_push_buffer_raw(duk_context *ctx, duk_size_t size, duk_small_uint_t flags);

569

duk_small_uint_t

unsigned int duk_small_uint_t

Definition duktape-1.5.2/src-noline/duk_config.h:1808

duk_size_t

size_t duk_size_t

Definition duktape-1.5.2/src-noline/duk_config.h:1770

duk_push_buffer_raw

DUK_EXTERNAL_DECL void * duk_push_buffer_raw(duk_context *ctx, duk_size_t size, duk_small_uint_t flags)

Definition duktape-1.5.2/src-noline/duktape.c:18974

Referenced by duk_bi_buffer_constructor(), and duk_to_buffer_raw().

◆ duk_push_dynamic_buffer

#define duk_push_dynamic_buffer	(		ctx,
			size ) duk_push_buffer_raw((ctx), (size), DUK_BUF_FLAG_DYNAMIC /flags/)

Definition at line 572 of file duktape-1.5.2/src-noline/duktape.h.

572#define duk_push_fixed_buffer(ctx,size) \

573 duk_push_buffer_raw((ctx), (size), 0 /*flags*/)

Referenced by duk__init_func_valstack_slots(), duk__js_compile_raw(), duk__realloc_props(), duk_base64_decode(), duk_bw_init_pushbuf(), duk_hobject_pc2line_pack(), and duk_push_vsprintf().

◆ duk_push_error_object

#define duk_push_error_object

Value:

    (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \
     duk_api_global_line = (duk_int_t) (DUK_LINE_MACRO), \
     duk_push_error_object_stash)  /* last value is func pointer, arguments follow in parens */

Definition at line 552 of file duktape-1.5.2/src-noline/duktape.h.

DUK_EXTERNAL_DECL duk_idx_t duk_push_error_object_stash(duk_context *ctx, duk_errcode_t err_code, const char *fmt, ...);
/* Note: parentheses are required so that the comma expression works in assignments. */
#define duk_push_error_object  \
    (duk_api_global_filename = (const char *) (DUK_FILE_MACRO), \

◆ duk_push_error_object_va

#define duk_push_error_object_va	(	ctx,
		err_code,
		fmt,
		ap ) duk_push_error_object_va_raw((ctx), (err_code), (const char *) (DUK_FILE_MACRO), (duk_int_t) (DUK_LINE_MACRO), (fmt), (ap))

Definition at line 559 of file duktape-1.5.2/src-noline/duktape.h.

559

560DUK_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);

duk_push_error_object_va_raw

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)

Definition duktape-1.5.2/src-noline/duktape.c:18892

◆ duk_push_external_buffer

#define duk_push_external_buffer ( ctx ) ((void) duk_push_buffer_raw((ctx), 0, DUK_BUF_FLAG_DYNAMIC | DUK_BUF_FLAG_EXTERNAL))

Definition at line 574 of file duktape-1.5.2/src-noline/duktape.h.

574#define duk_push_dynamic_buffer(ctx,size) \

575 duk_push_buffer_raw((ctx), (size), DUK_BUF_FLAG_DYNAMIC /*flags*/)

◆ duk_push_fixed_buffer

#define duk_push_fixed_buffer	(		ctx,
			size ) duk_push_buffer_raw((ctx), (size), 0 /flags/)

Definition at line 570 of file duktape-1.5.2/src-noline/duktape.h.

570#define duk_push_buffer(ctx,size,dynamic) \

571 duk_push_buffer_raw((ctx), (size), (dynamic) ? DUK_BUF_FLAG_DYNAMIC : 0)

Referenced by duk__concat_and_join_helper(), duk__convert_to_func_template(), duk__dec_buffer(), duk__load_buffer_raw(), duk__load_func(), duk__load_func(), duk__match_regexp(), duk__push_arraybuffer_with_length(), duk__push_string(), duk__regexp_match_helper(), duk_base64_encode(), duk_bi_arraybuffer_constructor(), duk_bi_buffer_slice_shared(), duk_bi_global_object_print_helper(), duk_bi_logger_prototype_log_shared(), duk_bi_nodejs_buffer_concat(), duk_bi_nodejs_buffer_constructor(), duk_bi_nodejs_buffer_tostring(), duk_bi_typedarray_set(), duk_decode_string_codepage(), duk_push_string_file_raw(), fileio_readfile(), fileio_readfile(), socket_read(), and socket_read().

◆ duk_push_string_file

#define duk_push_string_file	(		ctx,
			path ) duk_push_string_file_raw((ctx), (path), 0)

Definition at line 521 of file duktape-1.5.2/src-noline/duktape.h.

521

522DUK_EXTERNAL_DECL const char *duk_push_string_file_raw(duk_context *ctx, const char *path, duk_uint_t flags);

duk_uint_t

duk_uint_fast32_t duk_uint_t

Definition duktape-1.5.2/src-noline/duk_config.h:1786

◆ duk_push_thread

#define duk_push_thread ( ctx ) duk_push_thread_raw((ctx), 0 /*flags*/)

Definition at line 538 of file duktape-1.5.2/src-noline/duktape.h.

538DUK_EXTERNAL_DECL duk_idx_t duk_push_thread_raw(duk_context *ctx, duk_uint_t flags);

539

duk_push_thread_raw

DUK_EXTERNAL_DECL duk_idx_t duk_push_thread_raw(duk_context *ctx, duk_uint_t flags)

Definition duktape-1.5.2/src-noline/duktape.c:18496

Referenced by duk_bi_thread_constructor().

◆ duk_push_thread_new_globalenv

#define duk_push_thread_new_globalenv ( ctx ) duk_push_thread_raw((ctx), DUK_THREAD_NEW_GLOBAL_ENV /*flags*/)

Definition at line 541 of file duktape-1.5.2/src-noline/duktape.h.

541 duk_push_thread_raw((ctx), 0 /*flags*/)

542

◆ duk_require_callable

#define duk_require_callable	(		ctx,
			index ) duk_require_function((ctx), (index))

Definition at line 721 of file duktape-1.5.2/src-noline/duktape.h.

721DUK_EXTERNAL_DECL duk_context *duk_require_context(duk_context *ctx, duk_idx_t index);

722DUK_EXTERNAL_DECL void duk_require_function(duk_context *ctx, duk_idx_t index);

duk_require_context

DUK_EXTERNAL_DECL duk_context * duk_require_context(duk_context *ctx, duk_idx_t index)

Definition duktape-1.5.2/src-noline/duktape.c:16429

duk_require_function

DUK_EXTERNAL_DECL void duk_require_function(duk_context *ctx, duk_idx_t index)

Definition duktape-1.5.2/src-noline/duktape.c:16417

Referenced by duk_bi_array_prototype_iter_shared().

◆ duk_require_object_coercible

#define duk_require_object_coercible	(		ctx,
			index )

Value:

    ((void) duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_BOOLEAN | \
                                                DUK_TYPE_MASK_NUMBER | \
                                                DUK_TYPE_MASK_STRING | \
                                                DUK_TYPE_MASK_OBJECT | \
                                                DUK_TYPE_MASK_BUFFER | \
                                                DUK_TYPE_MASK_POINTER | \
                                                DUK_TYPE_MASK_LIGHTFUNC | \
                                                DUK_TYPE_MASK_THROW))

Definition at line 725 of file duktape-1.5.2/src-noline/duktape.h.

DUK_EXTERNAL_DECL void *duk_require_heapptr(duk_context *ctx, duk_idx_t index);
 
#define duk_require_object_coercible(ctx,index) \
    ((void) duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_BOOLEAN | \
                                                DUK_TYPE_MASK_NUMBER | \
                                                DUK_TYPE_MASK_STRING | \
                                                DUK_TYPE_MASK_OBJECT | \
                                                DUK_TYPE_MASK_BUFFER | \
                                                DUK_TYPE_MASK_POINTER | \

Referenced by duk_bi_object_setprototype_shared().

◆ duk_require_type_mask

#define duk_require_type_mask	(	ctx,
		index,
		mask ) ((void) duk_check_type_mask((ctx), (index), (mask) \| DUK_TYPE_MASK_THROW))

Definition at line 704 of file duktape-1.5.2/src-noline/duktape.h.

704 */

705

Referenced by duk_bi_object_setprototype_shared(), duk_def_prop(), duk_js_in(), and duk_set_prototype().

◆ DUK_RET_ALLOC_ERROR

#define DUK_RET_ALLOC_ERROR (-DUK_ERR_ALLOC_ERROR)

Definition at line 352 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_error_throw_from_negative_rc().

◆ DUK_RET_API_ERROR

#define DUK_RET_API_ERROR (-DUK_ERR_API_ERROR)

Definition at line 354 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_error_throw_from_negative_rc().

◆ DUK_RET_ASSERTION_ERROR

#define DUK_RET_ASSERTION_ERROR (-DUK_ERR_ASSERTION_ERROR)

Definition at line 353 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_error_throw_from_negative_rc().

◆ DUK_RET_ERROR

#define DUK_RET_ERROR (-DUK_ERR_ERROR)

Definition at line 356 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_error_throw_from_negative_rc(), fileio_readfile(), and fileio_readfile().

◆ DUK_RET_EVAL_ERROR

#define DUK_RET_EVAL_ERROR (-DUK_ERR_EVAL_ERROR)

Definition at line 357 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_error_throw_from_negative_rc().

◆ DUK_RET_INTERNAL_ERROR

#define DUK_RET_INTERNAL_ERROR (-DUK_ERR_INTERNAL_ERROR)

Definition at line 351 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_error_throw_from_negative_rc().

◆ DUK_RET_RANGE_ERROR

#define DUK_RET_RANGE_ERROR (-DUK_ERR_RANGE_ERROR)

Definition at line 358 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_array_constructor(), duk_bi_array_prototype_push(), duk_bi_array_prototype_splice(), duk_bi_array_prototype_unshift(), duk_bi_arraybuffer_constructor(), duk_bi_buffer_readfield(), duk_bi_buffer_writefield(), duk_bi_nodejs_buffer_concat(), duk_bi_nodejs_buffer_copy(), duk_bi_typedarray_constructor(), duk_bi_typedarray_set(), and duk_error_throw_from_negative_rc().

◆ DUK_RET_REFERENCE_ERROR

#define DUK_RET_REFERENCE_ERROR (-DUK_ERR_REFERENCE_ERROR)

Definition at line 359 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_error_throw_from_negative_rc().

◆ DUK_RET_SYNTAX_ERROR

#define DUK_RET_SYNTAX_ERROR (-DUK_ERR_SYNTAX_ERROR)

Definition at line 360 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_error_throw_from_negative_rc().

◆ DUK_RET_TYPE_ERROR

#define DUK_RET_TYPE_ERROR (-DUK_ERR_TYPE_ERROR)

Definition at line 361 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_RET_UNCAUGHT_ERROR

#define DUK_RET_UNCAUGHT_ERROR (-DUK_ERR_UNCAUGHT_ERROR)

Definition at line 355 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_error_throw_from_negative_rc().

◆ DUK_RET_UNIMPLEMENTED_ERROR

#define DUK_RET_UNIMPLEMENTED_ERROR (-DUK_ERR_UNIMPLEMENTED_ERROR)

Definition at line 349 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__push_this_number_plain(), and duk_error_throw_from_negative_rc().

◆ DUK_RET_UNSUPPORTED_ERROR

#define DUK_RET_UNSUPPORTED_ERROR (-DUK_ERR_UNSUPPORTED_ERROR)

Definition at line 350 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_string_prototype_replace(), duk_bi_string_prototype_split(), and duk_error_throw_from_negative_rc().

◆ DUK_RET_URI_ERROR

#define DUK_RET_URI_ERROR (-DUK_ERR_URI_ERROR)

Definition at line 362 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_error_throw_from_negative_rc().

◆ duk_safe_to_string

#define duk_safe_to_string	(		ctx,
			index ) duk_safe_to_lstring((ctx), (index), NULL)

Definition at line 772 of file duktape-1.5.2/src-noline/duktape.h.

772/* safe variants of a few coercion operations */

773DUK_EXTERNAL_DECL const char *duk_safe_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len);

duk_safe_to_lstring

DUK_EXTERNAL_DECL const char * duk_safe_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len)

Definition duktape-1.5.2/src-noline/duktape.c:16929

Referenced by duk_push_context_dump(), main(), main(), print_pop_error(), and print_pop_error().

◆ DUK_SINGLE_FILE

#define DUK_SINGLE_FILE

Definition at line 124 of file duktape-1.5.2/src-noline/duktape.h.

◆ DUK_STRING_PUSH_SAFE

#define DUK_STRING_PUSH_SAFE (1 << 0) /* no error if file does not exist */

Definition at line 327 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_push_pointer(), and duk_push_string_file_raw().

◆ DUK_THREAD_NEW_GLOBAL_ENV

#define DUK_THREAD_NEW_GLOBAL_ENV (1 << 0) /* create a new global environment */

Definition at line 324 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_push_thread_raw().

◆ duk_to_buffer

#define duk_to_buffer	(	ctx,
		index,
		out_size ) duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_DONTCARE)

Definition at line 763 of file duktape-1.5.2/src-noline/duktape.h.

763#define DUK_BUF_MODE_DONTCARE 2 /* internal: don't care about fixed/dynamic nature */

764

Referenced by duk_bi_nodejs_buffer_constructor(), socket_write(), socket_write(), wrapped_compile_execute(), and wrapped_compile_execute().

◆ duk_to_dynamic_buffer

#define duk_to_dynamic_buffer	(	ctx,
		index,
		out_size ) duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_DYNAMIC)

Definition at line 767 of file duktape-1.5.2/src-noline/duktape.h.

767#define duk_to_fixed_buffer(ctx,index,out_size) \

768 duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_FIXED)

◆ duk_to_fixed_buffer

#define duk_to_fixed_buffer	(	ctx,
		index,
		out_size ) duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_FIXED)

Definition at line 765 of file duktape-1.5.2/src-noline/duktape.h.

765#define duk_to_buffer(ctx,index,out_size) \

766 duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_DONTCARE)

Referenced by duk_hobject_pc2line_pack().

◆ DUK_TYPE_BOOLEAN

#define DUK_TYPE_BOOLEAN 3 /* Ecmascript boolean: 0 or 1 */

Definition at line 256 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_get_type().

◆ DUK_TYPE_BUFFER

#define DUK_TYPE_BUFFER 7 /* fixed or dynamic, garbage collected byte buffer */

Definition at line 260 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_buffer_constructor(), duk_bi_nodejs_buffer_constructor(), and duk_get_type().

◆ DUK_TYPE_LIGHTFUNC

#define DUK_TYPE_LIGHTFUNC 9 /* lightweight function pointer */

Definition at line 262 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__error_getter_helper(), and duk_get_type().

◆ DUK_TYPE_MASK_BOOLEAN

#define DUK_TYPE_MASK_BOOLEAN (1 << DUK_TYPE_BOOLEAN)

Definition at line 269 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_object_constructor(), and duk_get_type_mask().

◆ DUK_TYPE_MASK_BUFFER

#define DUK_TYPE_MASK_BUFFER (1 << DUK_TYPE_BUFFER)

Definition at line 273 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__enc_value(), duk__vm_arith_add(), duk_bi_json_stringify_helper(), duk_bi_object_constructor(), and duk_get_type_mask().

◆ DUK_TYPE_MASK_LIGHTFUNC

#define DUK_TYPE_MASK_LIGHTFUNC (1 << DUK_TYPE_LIGHTFUNC)

Definition at line 275 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_json_stringify_helper(), duk_bi_object_constructor(), duk_def_prop(), duk_get_type_mask(), duk_js_in(), duk_to_boolean(), and duk_to_primitive().

◆ DUK_TYPE_MASK_NONE

#define DUK_TYPE_MASK_NONE (1 << DUK_TYPE_NONE)

Definition at line 266 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_get_type_mask().

◆ DUK_TYPE_MASK_NULL

#define DUK_TYPE_MASK_NULL (1 << DUK_TYPE_NULL)

Definition at line 268 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_object_setprototype_shared(), duk_get_type_mask(), and duk_to_object_class_string_top().

◆ DUK_TYPE_MASK_NUMBER

#define DUK_TYPE_MASK_NUMBER (1 << DUK_TYPE_NUMBER)

Definition at line 270 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_object_constructor(), and duk_get_type_mask().

◆ DUK_TYPE_MASK_OBJECT

#define DUK_TYPE_MASK_OBJECT (1 << DUK_TYPE_OBJECT)

Definition at line 272 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_object_setprototype_shared(), duk_def_prop(), duk_get_type_mask(), duk_js_in(), duk_set_prototype(), duk_to_boolean(), and duk_to_primitive().

◆ DUK_TYPE_MASK_POINTER

#define DUK_TYPE_MASK_POINTER (1 << DUK_TYPE_POINTER)

Definition at line 274 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_json_stringify_helper(), duk_bi_object_constructor(), and duk_get_type_mask().

◆ DUK_TYPE_MASK_STRING

#define DUK_TYPE_MASK_STRING (1 << DUK_TYPE_STRING)

Definition at line 271 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__vm_arith_add(), duk_bi_object_constructor(), and duk_get_type_mask().

◆ DUK_TYPE_MASK_THROW

#define DUK_TYPE_MASK_THROW (1 << 10) /* internal flag value: throw if mask doesn't match */

Definition at line 276 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_check_type_mask().

◆ DUK_TYPE_MASK_UNDEFINED

#define DUK_TYPE_MASK_UNDEFINED (1 << DUK_TYPE_UNDEFINED)

Definition at line 267 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_json_stringify_helper(), duk_def_prop(), duk_get_type_mask(), duk_set_prototype(), and duk_to_object_class_string_top().

◆ DUK_TYPE_MAX

#define DUK_TYPE_MAX 9

Definition at line 263 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_get_type_mask().

◆ DUK_TYPE_MIN

#define DUK_TYPE_MIN 0

Definition at line 252 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_get_type_mask().

◆ DUK_TYPE_NONE

#define DUK_TYPE_NONE 0 /* no value, e.g. invalid index */

Definition at line 253 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_buffer_constructor(), and duk_get_type().

◆ DUK_TYPE_NULL

#define DUK_TYPE_NULL 2 /* Ecmascript null */

Definition at line 255 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_get_type().

◆ DUK_TYPE_NUMBER

#define DUK_TYPE_NUMBER 4 /* Ecmascript number: double */

Definition at line 257 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_bi_buffer_constructor(), duk_bi_nodejs_buffer_constructor(), and duk_get_type().

◆ DUK_TYPE_OBJECT

#define DUK_TYPE_OBJECT 6 /* Ecmascript object: includes objects, arrays, functions, threads */

Definition at line 259 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__error_getter_helper(), duk_bi_buffer_constructor(), duk_bi_nodejs_buffer_constructor(), and duk_get_type().

◆ DUK_TYPE_POINTER

#define DUK_TYPE_POINTER 8 /* raw void pointer */

Definition at line 261 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_get_type().

◆ DUK_TYPE_STRING

#define DUK_TYPE_STRING 5 /* Ecmascript string: CESU-8 / extended UTF-8 encoded */

Definition at line 258 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__error_getter_helper(), duk_bi_buffer_constructor(), duk_bi_nodejs_buffer_constructor(), and duk_get_type().

◆ DUK_TYPE_UNDEFINED

#define DUK_TYPE_UNDEFINED 1 /* Ecmascript undefined */

Definition at line 254 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk_get_type().

◆ DUK_VARARGS

#define DUK_VARARGS ((duk_int_t) (-1))

Definition at line 244 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by duk__push_c_function_raw(), duk_hthread_create_builtin_objects(), duk_push_c_lightfunc(), duk_to_object(), and main().

◆ DUK_VERSION

#define DUK_VERSION 10502L

Definition at line 221 of file duktape-1.5.2/src-noline/duktape.h.

Referenced by mg_get_system_info().

◆ duk_xcopy_top

#define duk_xcopy_top	(	to_ctx,
		from_ctx,
		count ) duk_xcopymove_raw((to_ctx), (from_ctx), (count), 1 /is_copy/)

Definition at line 493 of file duktape-1.5.2/src-noline/duktape.h.

493#define duk_xmove_top(to_ctx,from_ctx,count) \

494 duk_xcopymove_raw((to_ctx), (from_ctx), (count), 0 /*is_copy*/)

◆ duk_xmove_top

#define duk_xmove_top	(	to_ctx,
		from_ctx,
		count ) duk_xcopymove_raw((to_ctx), (from_ctx), (count), 0 /is_copy/)

Definition at line 491 of file duktape-1.5.2/src-noline/duktape.h.

491DUK_EXTERNAL_DECL void duk_xcopymove_raw(duk_context *to_ctx, duk_context *from_ctx, duk_idx_t count, duk_bool_t is_copy);

492

duk_xcopymove_raw

DUK_EXTERNAL_DECL void duk_xcopymove_raw(duk_context *to_ctx, duk_context *from_ctx, duk_idx_t count, duk_bool_t is_copy)

Definition duktape-1.5.2/src-noline/duktape.c:15864

Typedef Documentation

◆ duk_alloc_function

typedef void *(* duk_alloc_function) (void *udata, duk_size_t size)

Definition at line 178 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_c_function

typedef duk_ret_t(* duk_c_function) (duk_context *ctx)

Definition at line 177 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_debug_detached_function

typedef void(* duk_debug_detached_function) (void *udata)

Definition at line 191 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_debug_peek_function

typedef duk_size_t(* duk_debug_peek_function) (void *udata)

Definition at line 187 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_debug_read_flush_function

typedef void(* duk_debug_read_flush_function) (void *udata)

Definition at line 188 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_debug_read_function

typedef duk_size_t(* duk_debug_read_function) (void *udata, char *buffer, duk_size_t length)

Definition at line 185 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_debug_request_function

typedef duk_idx_t(* duk_debug_request_function) (duk_context *ctx, void *udata, duk_idx_t nvalues)

Definition at line 190 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_debug_write_flush_function

typedef void(* duk_debug_write_flush_function) (void *udata)

Definition at line 189 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_debug_write_function

typedef duk_size_t(* duk_debug_write_function) (void *udata, const char *buffer, duk_size_t length)

Definition at line 186 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_decode_char_function

typedef void(* duk_decode_char_function) (void *udata, duk_codepoint_t codepoint)

Definition at line 182 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_double_union

typedef union duk_double_union duk_double_union

Definition at line 1257 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_fatal_function

typedef void(* duk_fatal_function) (duk_context *ctx, duk_errcode_t code, const char *msg)

Definition at line 181 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_free_function

typedef void(* duk_free_function) (void *udata, void *ptr)

Definition at line 180 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_function_list_entry

typedef struct duk_function_list_entry duk_function_list_entry

Definition at line 174 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_map_char_function

typedef duk_codepoint_t(* duk_map_char_function) (void *udata, duk_codepoint_t codepoint)

Definition at line 183 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_memory_functions

typedef struct duk_memory_functions duk_memory_functions

Definition at line 173 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_number_list_entry

typedef struct duk_number_list_entry duk_number_list_entry

Definition at line 175 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_realloc_function

typedef void *(* duk_realloc_function) (void *udata, void *ptr, duk_size_t size)

Definition at line 179 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_safe_call_function

typedef duk_ret_t(* duk_safe_call_function) (duk_context *ctx)

Definition at line 184 of file duktape-1.5.2/src-noline/duktape.h.

Function Documentation

◆ duk_alloc()

DUK_EXTERNAL_DECL void * duk_alloc	(	duk_context *	ctx,
		duk_size_t	size )

Definition at line 14191 of file duktape-1.5.2/src-noline/duktape.c.

                                                            {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    DUK_FREE_RAW(thr->heap, ptr);

◆ duk_alloc_raw()

DUK_EXTERNAL_DECL void * duk_alloc_raw	(	duk_context *	ctx,
		duk_size_t	size )

Definition at line 14167 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                   {
    va_list ap;
 
    DUK_ASSERT_CTX_VALID(ctx);
 

◆ DUK_API_NORETURN() [1/5]

DUK_API_NORETURN ( DUK_EXTERNAL_DECL void duk_error_rawduk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt,... )

◆ DUK_API_NORETURN() [2/5]

DUK_API_NORETURN ( DUK_EXTERNAL_DECL void duk_error_stashduk_context *ctx, duk_errcode_t err_code, const char *fmt,... )

◆ DUK_API_NORETURN() [3/5]

DUK_API_NORETURN ( DUK_EXTERNAL_DECL void duk_error_va_rawduk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, va_list ap )

◆ DUK_API_NORETURN() [4/5]

DUK_API_NORETURN ( DUK_EXTERNAL_DECL void duk_fatalduk_context *ctx, duk_errcode_t err_code, const char *err_msg )

◆ DUK_API_NORETURN() [5/5]

DUK_API_NORETURN ( DUK_EXTERNAL_DECL void duk_throwduk_context *ctx )

◆ duk_base64_decode()

DUK_EXTERNAL_DECL void duk_base64_decode	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 13289 of file duktape-1.5.2/src-noline/duktape.c.

                               {
        goto type_error;
    }
    dstlen = (srclen + 2) / 3 * 4;
    dst = (duk_uint8_t *) duk_push_fixed_buffer(ctx, dstlen);
 
    duk__base64_encode_helper((const duk_uint8_t *) src, srclen, dst);
 
    ret = duk_to_string(ctx, -1);
    duk_replace(ctx, index);
    return ret;
 
 type_error:
    DUK_ERROR_TYPE(thr, DUK_STR_ENCODE_FAILED);
    return NULL;  /* never here */
}
 
DUK_EXTERNAL void duk_base64_decode(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    const duk_uint8_t *src;
    duk_size_t srclen;
    duk_size_t dstlen;
    duk_uint8_t *dst;
    duk_uint8_t *dst_final;
    duk_bool_t retval;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* XXX: optimize for buffer inputs: no need to coerce to a string
     * which causes an unnecessary interning.
     */
 
    index = duk_require_normalize_index(ctx, index);
    src = duk__prep_codec_arg(ctx, index, &srclen);
 
    /* Computation must not wrap, only srclen + 3 is at risk of
     * wrapping because after that the number gets smaller.
     * This limit works for 32-bit size_t:
     * 0x100000000 - 3 - 1 = 4294967292
     */
    if (srclen > 4294967292UL) {
        goto type_error;
    }

◆ duk_base64_encode()

DUK_EXTERNAL_DECL const char * duk_base64_encode	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 13249 of file duktape-1.5.2/src-noline/duktape.c.

                        {
        /* Here we'd have the option of decoding unpadded base64
         * (e.g. "xxxxyy" instead of "xxxxyy==".  Currently not
         * accepted.
         */
        goto error;
    }
 
    *out_dst_final = dst;
    return 1;
 
 error:
    return 0;
}
#endif  /* DUK_USE_BASE64_FASTPATH */
 
DUK_EXTERNAL const char *duk_base64_encode(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    const duk_uint8_t *src;
    duk_size_t srclen;
    duk_size_t dstlen;
    duk_uint8_t *dst;
    const char *ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* XXX: optimize for string inputs: no need to coerce to a buffer
     * which makes a copy of the input.
     */
 
    index = duk_require_normalize_index(ctx, index);
    src = duk__prep_codec_arg(ctx, index, &srclen);
    /* Note: for srclen=0, src may be NULL */
 
    /* Computation must not wrap; this limit works for 32-bit size_t:
     * >>> srclen = 3221225469
     * >>> '%x' % ((srclen + 2) / 3 * 4)
     * 'fffffffc'

◆ duk_call()

DUK_EXTERNAL_DECL void duk_call	(	duk_context *	ctx,
		duk_idx_t	nargs )

Definition at line 12362 of file duktape-1.5.2/src-noline/duktape.c.

                              : %!T", (duk_tval *) duk_get_tval(ctx, -1)));
 
    /* [... key arg1 ... argN func] */
 
    duk_replace(ctx, -nargs - 2);
 
    /* [... func arg1 ... argN] */
 
    duk_dup(ctx, normalized_obj_index);
    duk_insert(ctx, -nargs - 1);
 
    /* [... func this arg1 ... argN] */
}
 
DUK_EXTERNAL void duk_call(duk_context *ctx, duk_idx_t nargs) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_small_uint_t call_flags;
    duk_idx_t idx_func;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
 
    idx_func = duk_get_top(ctx) - nargs - 1;

◆ duk_call_method()

DUK_EXTERNAL_DECL void duk_call_method	(	duk_context *	ctx,
		duk_idx_t	nargs )

Definition at line 12389 of file duktape-1.5.2/src-noline/duktape.c.

                                                                     {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_small_uint_t call_flags;

◆ duk_call_prop()

DUK_EXTERNAL_DECL void duk_call_prop	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_idx_t	nargs )

Definition at line 12410 of file duktape-1.5.2/src-noline/duktape.c.

                                   {
        /* note that we can't reliably pop anything here */
        DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS);
    }
 
    call_flags = 0;  /* not protected, respect reclimit, not constructor */
 
    duk_handle_call_unprotected(thr,           /* thread */
                                nargs,         /* num_stack_args */
                                call_flags);   /* call_flags */
}

◆ duk_char_code_at()

DUK_EXTERNAL_DECL duk_codepoint_t duk_char_code_at	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t	char_offset )

Definition at line 19844 of file duktape-1.5.2/src-noline/duktape.c.

                              : p_start=%p, p_end=%p, q_start=%p, q_end=%p",
                         (const void *) p_start, (const void *) p_end,
                         (const void *) q_start, (const void *) q_end));
 
    if (q_start == p_start && q_end == p_end) {
        DUK_DDD(DUK_DDDPRINT("nothing was trimmed: avoid interning (hashing etc)"));
        return;
    }
 
    duk_push_lstring(ctx, (const char *) q_start, (duk_size_t) (q_end - q_start));
    duk_replace(ctx, index);
}
 
DUK_EXTERNAL duk_codepoint_t duk_char_code_at(duk_context *ctx, duk_idx_t index, duk_size_t char_offset) {
    duk_hthread *thr = (duk_hthread *) ctx;

◆ duk_check_stack()

DUK_EXTERNAL_DECL duk_bool_t duk_check_stack	(	duk_context *	ctx,
		duk_idx_t	extra )

Definition at line 15590 of file duktape-1.5.2/src-noline/duktape.c.

                        {
            DUK_ERROR_ALLOC_DEFMSG(thr);
        } else {
            return 0;
        }
    }
 
    DUK_DDD(DUK_DDDPRINT("valstack resize successful"));
    return 1;
}
 
DUK_EXTERNAL duk_bool_t duk_check_stack(duk_context *ctx, duk_idx_t extra) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_size_t min_new_size;
 

◆ duk_check_stack_top()

DUK_EXTERNAL_DECL duk_bool_t duk_check_stack_top	(	duk_context *	ctx,
		duk_idx_t	top )

Definition at line 15634 of file duktape-1.5.2/src-noline/duktape.c.

                                 {
        /* Clamping to zero makes the API more robust to calling code
         * calculation errors.
         */
        extra = 0;
    }
 
    min_new_size = (thr->valstack_top - thr->valstack) + extra + DUK_VALSTACK_INTERNAL_EXTRA;
    (void) duk_valstack_resize_raw(ctx,
                                   min_new_size,  /* min_new_size */
                                   0 /* no shrink */ |   /* flags */
                                   0 /* no compact */ |
                                   DUK_VSRESIZE_FLAG_THROW);
}
 
DUK_EXTERNAL duk_bool_t duk_check_stack_top(duk_context *ctx, duk_idx_t top) {
    duk_size_t min_new_size;

◆ duk_check_type()

DUK_EXTERNAL_DECL duk_bool_t duk_check_type	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_int_t	type )

Definition at line 17541 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_check_type_mask()

DUK_EXTERNAL_DECL duk_bool_t duk_check_type_mask	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_uint_t	mask )

Definition at line 17585 of file duktape-1.5.2/src-noline/duktape.c.

                        :
        return DUK_TYPE_MASK_POINTER;
    case DUK_TAG_LIGHTFUNC:
        return DUK_TYPE_MASK_LIGHTFUNC;
#if defined(DUK_USE_FASTINT)
    case DUK_TAG_FASTINT:
#endif
    default:
        /* Note: number has no explicit tag (in 8-byte representation) */
        DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv));
        DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
        return DUK_TYPE_MASK_NUMBER;
    }

◆ duk_compact()

DUK_EXTERNAL_DECL void duk_compact	(	duk_context *	ctx,
		duk_idx_t	obj_index )

Definition at line 14704 of file duktape-1.5.2/src-noline/duktape.c.

                  :
    DUK_ERROR_TYPE(thr, DUK_STR_INVALID_DESCRIPTOR);
    return;
 
 fail_not_callable:
    DUK_ERROR_TYPE(thr, DUK_STR_NOT_CALLABLE);
    return;
}
 
/*
 *  Object related

◆ duk_compile_raw()

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 )

Definition at line 13668 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                                          {
    duk__compile_raw_args comp_args_alloc;
    duk__compile_raw_args *comp_args = &comp_args_alloc;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    if ((flags & DUK_COMPILE_STRLEN) && (src_buffer != NULL)) {
        /* String length is computed here to avoid multiple evaluation
         * of a macro argument in the calling side.
         */
        src_length = DUK_STRLEN(src_buffer);
    }
 
    comp_args->src_buffer = (const duk_uint8_t *) src_buffer;
    comp_args->src_length = src_length;
    comp_args->flags = flags;
    duk_push_pointer(ctx, (void *) comp_args);
 
    /* [ ... source? filename? &comp_args ] (depends on flags) */
 
    if (flags & DUK_COMPILE_SAFE) {
        duk_int_t rc;
        duk_int_t nargs;
        duk_int_t nrets = 1;
 
        /* Arguments can be: [ source? filename? &comp_args] so that
         * nargs is 1 to 3.  Call site encodes the correct nargs count

◆ duk_concat()

DUK_EXTERNAL_DECL void duk_concat	(	duk_context *	ctx,
		duk_idx_t	count )

Definition at line 19640 of file duktape-1.5.2/src-noline/duktape.c.

           {
        duk_replace(ctx, -((duk_idx_t) count) - 1);  /* overwrite str1 */
        duk_pop_n(ctx, count-1);
    }

◆ duk_config_buffer()

DUK_EXTERNAL_DECL void duk_config_buffer	(	duk_context *	ctx,
		duk_idx_t	index,
		void *	ptr,
		duk_size_t	len )

Definition at line 11581 of file duktape-1.5.2/src-noline/duktape.c.

                  {
        *out_size = sz;
    }
    DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(thr->heap, h);
    DUK_HBUFFER_DYNAMIC_SET_SIZE(h, 0);
 
    return ptr;
}
 

◆ duk_copy()

DUK_EXTERNAL_DECL void duk_copy	(	duk_context *	ctx,
		duk_idx_t	from_index,
		duk_idx_t	to_index )

Definition at line 15803 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_create_heap()

DUK_EXTERNAL_DECL duk_context * duk_create_heap	(	duk_alloc_function	alloc_func,
		duk_realloc_function	realloc_func,
		duk_free_function	free_func,
		void *	heap_udata,
		duk_fatal_function	fatal_handler )

Definition at line 13982 of file duktape-1.5.2/src-noline/duktape.c.

                                                       {
    /* Treat like debugger statement: nop */
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(ctx);
}
 
#endif  /* DUK_USE_DEBUGGER_SUPPORT */
/*
 *  Heap creation and destruction
 */
 
/* include removed: duk_internal.h */
 
DUK_EXTERNAL
duk_context *duk_create_heap(duk_alloc_function alloc_func,
                             duk_realloc_function realloc_func,
                             duk_free_function free_func,
                             void *heap_udata,
                             duk_fatal_function fatal_handler) {
    duk_heap *heap = NULL;
    duk_context *ctx;
 
    /* Assume that either all memory funcs are NULL or non-NULL, mixed
     * cases will now be unsafe.
     */
 
    /* XXX: just assert non-NULL values here and make caller arguments
     * do the defaulting to the default implementations (smaller code)?
     */
 
    if (!alloc_func) {
        DUK_ASSERT(realloc_func == NULL);
        DUK_ASSERT(free_func == NULL);
#if defined(DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS)
        alloc_func = duk_default_alloc_function;
        realloc_func = duk_default_realloc_function;
        free_func = duk_default_free_function;
#else
        DUK_D(DUK_DPRINT("no allocation functions given and no default providers"));
        return NULL;
#endif
    } else {
        DUK_ASSERT(realloc_func != NULL);
        DUK_ASSERT(free_func != NULL);
    }
 
    if (!fatal_handler) {

◆ duk_debugger_attach_custom()

DUK_EXTERNAL_DECL void duk_debugger_attach_custom	(	duk_context *	ctx,
		duk_debug_read_function	read_cb,
		duk_debug_write_function	write_cb,
		duk_debug_peek_function	peek_cb,
		duk_debug_read_flush_function	read_flush_cb,
		duk_debug_write_flush_function	write_flush_cb,
		duk_debug_request_function	request_cb,
		duk_debug_detached_function	detached_cb,
		void *	udata )

Definition at line 13920 of file duktape-1.5.2/src-noline/duktape.c.

                                                  {
        DUK_HEAP_SET_PAUSED(thr->heap);
 
        /* Pause on the next opcode executed.  This is always safe to do even
         * inside the debugger message loop: the interrupt counter will be reset
         * to its proper value when the message loop exits.
         */
        thr->interrupt_init = 1;
        thr->interrupt_counter = 0;
    }
}
 
#else  /* DUK_USE_DEBUGGER_SUPPORT */
 
DUK_EXTERNAL void duk_debugger_attach_custom(duk_context *ctx,
                                             duk_debug_read_function read_cb,
                                             duk_debug_write_function write_cb,

◆ duk_debugger_cooperate()

DUK_EXTERNAL_DECL void duk_debugger_cooperate ( duk_context * ctx )

Definition at line 13946 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_debugger_detach()

DUK_EXTERNAL_DECL void duk_debugger_detach ( duk_context * ctx )

Definition at line 13941 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_debugger_notify()

DUK_EXTERNAL_DECL duk_bool_t duk_debugger_notify	(	duk_context *	ctx,
		duk_idx_t	nvalues )

Definition at line 13952 of file duktape-1.5.2/src-noline/duktape.c.

                                                        {
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ERROR_API((duk_hthread *) ctx, "no debugger support");
}
 
DUK_EXTERNAL void duk_debugger_cooperate(duk_context *ctx) {
    /* nop */
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(ctx);

◆ duk_debugger_pause()

DUK_EXTERNAL_DECL void duk_debugger_pause ( duk_context * ctx )

Definition at line 13968 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                 {
    duk_idx_t top;
 
    DUK_ASSERT_CTX_VALID(ctx);

◆ duk_decode_string()

DUK_EXTERNAL_DECL void duk_decode_string	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_decode_char_function	callback,
		void *	udata )

Definition at line 19656 of file duktape-1.5.2/src-noline/duktape.c.

                                                                {
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk__concat_and_join_helper(ctx, count, 0 /*is_join*/);
}
 
DUK_EXTERNAL void duk_join(duk_context *ctx, duk_idx_t count) {
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk__concat_and_join_helper(ctx, count, 1 /*is_join*/);
}
 
/* XXX: could map/decode be unified with duk_unicode_support.c code?
 * Case conversion needs also the character surroundings though.
 */
 
DUK_EXTERNAL void duk_decode_string(duk_context *ctx, duk_idx_t index, duk_decode_char_function callback, void *udata) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hstring *h_input;
    const duk_uint8_t *p, *p_start, *p_end;
    duk_codepoint_t cp;
 

◆ duk_def_prop()

DUK_EXTERNAL_DECL void duk_def_prop	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_uint_t	flags )

Definition at line 14612 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                                                           {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *obj = duk_require_hobject(ctx, obj_index);
    duk_hobject *thrower = thr->builtins[DUK_BIDX_TYPE_ERROR_THROWER];
    duk_hobject_define_accessor_internal(thr, obj, DUK_HTHREAD_GET_STRING(thr, stridx), thrower, thrower, desc_flags);
}
 
/* Object.defineProperty() equivalent C binding. */
DUK_EXTERNAL void duk_def_prop(duk_context *ctx, duk_idx_t obj_index, duk_uint_t flags) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_idx_t idx_base;
    duk_hobject *obj;
    duk_hstring *key;
    duk_idx_t idx_value;
    duk_hobject *get;
    duk_hobject *set;
    duk_uint_t is_data_desc;
    duk_uint_t is_acc_desc;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    obj = duk_require_hobject(ctx, obj_index);
 
    is_data_desc = flags & (DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_HAVE_WRITABLE);
    is_acc_desc = flags & (DUK_DEFPROP_HAVE_GETTER | DUK_DEFPROP_HAVE_SETTER);
    if (is_data_desc && is_acc_desc) {
        /* "Have" flags must not be conflicting so that they would
         * apply to both a plain property and an accessor at the same
         * time.
         */
        goto fail_invalid_desc;
    }
 
    idx_base = duk_get_top_index(ctx);
    if (flags & DUK_DEFPROP_HAVE_SETTER) {
        duk_require_type_mask(ctx, idx_base, DUK_TYPE_MASK_UNDEFINED |
                                             DUK_TYPE_MASK_OBJECT |
                                             DUK_TYPE_MASK_LIGHTFUNC);
        set = duk_get_hobject_or_lfunc_coerce(ctx, idx_base);
        if (set != NULL && !DUK_HOBJECT_IS_CALLABLE(set)) {
            goto fail_not_callable;
        }
        idx_base--;
    } else {
        set = NULL;
    }
    if (flags & DUK_DEFPROP_HAVE_GETTER) {
        duk_require_type_mask(ctx, idx_base, DUK_TYPE_MASK_UNDEFINED |
                                             DUK_TYPE_MASK_OBJECT |
                                             DUK_TYPE_MASK_LIGHTFUNC);
        get = duk_get_hobject_or_lfunc_coerce(ctx, idx_base);
        if (get != NULL && !DUK_HOBJECT_IS_CALLABLE(get)) {
            goto fail_not_callable;
        }
        idx_base--;
    } else {
        get = NULL;
    }
    if (flags & DUK_DEFPROP_HAVE_VALUE) {
        idx_value = idx_base;
        idx_base--;
    } else {
        idx_value = (duk_idx_t) -1;
    }
    key = duk_require_hstring(ctx, idx_base);
 
    duk_require_valid_index(ctx, idx_base);
 
    duk_hobject_define_property_helper(ctx,
                                       flags /*defprop_flags*/,
                                       obj,
                                       key,
                                       idx_value,
                                       get,
                                       set);

◆ duk_del_prop()

DUK_EXTERNAL_DECL duk_bool_t duk_del_prop	(	duk_context *	ctx,
		duk_idx_t	obj_index )

Definition at line 14417 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                         {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT_DISABLE(stridx >= 0);
    DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS);
    DUK_UNREF(thr);
 
    obj_idx = duk_require_normalize_index(ctx, obj_idx);
    duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx));
    return duk__put_prop_shared(ctx, obj_idx, -1);
}
 
DUK_EXTERNAL duk_bool_t duk_del_prop(duk_context *ctx, duk_idx_t obj_index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv_obj;
    duk_tval *tv_key;
    duk_small_int_t throw_flag;
    duk_bool_t rc;

◆ duk_del_prop_index()

DUK_EXTERNAL_DECL duk_bool_t duk_del_prop_index	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_uarridx_t	arr_index )

Definition at line 14450 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_del_prop_string()

DUK_EXTERNAL_DECL duk_bool_t duk_del_prop_string	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		const char *	key )

Definition at line 14441 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_del_var()

DUK_EXTERNAL_DECL duk_bool_t duk_del_var ( duk_context * ctx )

Definition at line 19936 of file duktape-1.5.2/src-noline/duktape.c.

             {
        duk_js_putvar_activation(thr, act, h_varname, tv_val, throw_flag);  /* -> [ ... varname val this ] */
    } else {
        /* Outside any activation -> put to global. */
        DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL_ENV] != NULL);
        duk_js_putvar_envrec(thr, thr->builtins[DUK_BIDX_GLOBAL_ENV], h_varname, tv_val, throw_flag);

◆ duk_destroy_heap()

DUK_EXTERNAL_DECL void duk_destroy_heap ( duk_context * ctx )

Definition at line 14033 of file duktape-1.5.2/src-noline/duktape.c.

               {
        return NULL;
    }
    ctx = (duk_context *) heap->heap_thread;

◆ duk_dump_function()

DUK_EXTERNAL_DECL void duk_dump_function ( duk_context * ctx )

Definition at line 12234 of file duktape-1.5.2/src-noline/duktape.c.

                                             : %!iT", duk_get_tval(ctx, -1)));
    DUK_ASSERT_TOP(ctx, idx_base + 1);
    return p;
 
 format_error:
    return NULL;
}
 
DUK_EXTERNAL void duk_dump_function(duk_context *ctx) {
    duk_hthread *thr;
    duk_hcompiledfunction *func;
    duk_bufwriter_ctx bw_ctx_alloc;
    duk_bufwriter_ctx *bw_ctx = &bw_ctx_alloc;
    duk_uint8_t *p;
 
    DUK_ASSERT(ctx != NULL);
    thr = (duk_hthread *) ctx;
 
    /* Bound functions don't have all properties so we'd either need to
     * lookup the non-bound target function or reject bound functions.
     * For now, bound functions are rejected.
     */
    func = duk_require_hcompiledfunction(ctx, -1);
    DUK_ASSERT(func != NULL);

◆ duk_dup()

DUK_EXTERNAL_DECL void duk_dup	(	duk_context *	ctx,
		duk_idx_t	from_index )

Definition at line 15702 of file duktape-1.5.2/src-noline/duktape.c.

                                                                  {
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk_swap(ctx, index, -1);
}

◆ duk_dup_top()

DUK_EXTERNAL_DECL void duk_dup_top ( duk_context * ctx )

Definition at line 15719 of file duktape-1.5.2/src-noline/duktape.c.

                                                                  {
    duk_hthread *thr;
    duk_tval *tv_from;
    duk_tval *tv_to;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
 
    tv_from = duk_require_tval(ctx, from_index);
    tv_to = thr->valstack_top++;
    DUK_ASSERT(tv_from != NULL);
    DUK_ASSERT(tv_to != NULL);
    DUK_TVAL_SET_TVAL(tv_to, tv_from);
    DUK_TVAL_INCREF(thr, tv_to);  /* no side effects */
}
 
DUK_EXTERNAL void duk_dup_top(duk_context *ctx) {
    duk_hthread *thr;
    duk_tval *tv_from;

◆ duk_enum()

DUK_EXTERNAL_DECL void duk_enum	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_uint_t	enum_flags )

Definition at line 14719 of file duktape-1.5.2/src-noline/duktape.c.

                                                                     {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *obj;
 
    DUK_ASSERT_CTX_VALID(ctx);

◆ duk_equals()

DUK_EXTERNAL_DECL duk_bool_t duk_equals	(	duk_context *	ctx,
		duk_idx_t	index1,
		duk_idx_t	index2 )

Definition at line 19282 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_eval_raw()

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 )

Definition at line 13532 of file duktape-1.5.2/src-noline/duktape.c.

                             {
    duk_size_t src_length;  /* should be first on 64-bit platforms */
    const duk_uint8_t *src_buffer;
    duk_uint_t flags;
};
 
/* Eval is just a wrapper now. */
DUK_EXTERNAL duk_int_t duk_eval_raw(duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags) {
    duk_uint_t comp_flags;
    duk_int_t rc;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* Note: strictness is *not* inherited from the current Duktape/C.
     * This would be confusing because the current strictness state
     * depends on whether we're running inside a Duktape/C activation
     * (= strict mode) or outside of any activation (= non-strict mode).
     * See tests/api/test-eval-strictness.c for more discussion.
     */
 
    /* [ ... source? filename? ] (depends on flags) */
 
    comp_flags = flags;
    comp_flags |= DUK_COMPILE_EVAL;
    rc = duk_compile_raw(ctx, src_buffer, src_length, comp_flags);  /* may be safe, or non-safe depending on flags */
 
    /* [ ... closure/error ] */
 
    if (rc != DUK_EXEC_SUCCESS) {
        rc = DUK_EXEC_ERROR;
        goto got_rc;
    }
 
    duk_push_global_object(ctx);  /* explicit 'this' binding, see GH-164 */

◆ duk_free()

DUK_EXTERNAL_DECL void duk_free	(	duk_context *	ctx,
		void *	ptr )

Definition at line 14199 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                 {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    return DUK_REALLOC_RAW(thr->heap, ptr, size);

◆ duk_free_raw()

DUK_EXTERNAL_DECL void duk_free_raw	(	duk_context *	ctx,
		void *	ptr )

Definition at line 14175 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_gc()

DUK_EXTERNAL_DECL void duk_gc	(	duk_context *	ctx,
		duk_uint_t	flags )

Definition at line 14241 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                              {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_heap *heap;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(out_funcs != NULL);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
 
    heap = thr->heap;
    out_funcs->alloc_func = heap->alloc_func;
    out_funcs->realloc_func = heap->realloc_func;
    out_funcs->free_func = heap->free_func;
    out_funcs->udata = heap->heap_udata;
}
 
DUK_EXTERNAL void duk_gc(duk_context *ctx, duk_uint_t flags) {
#ifdef DUK_USE_MARK_AND_SWEEP
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_heap *heap;
 
    DUK_UNREF(flags);

◆ duk_get_boolean()

DUK_EXTERNAL_DECL duk_bool_t duk_get_boolean	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15965 of file duktape-1.5.2/src-noline/duktape.c.

                                                                      {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_NULL(tv)) {
        return;
    }
    DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "null", DUK_STR_NOT_NULL);

◆ duk_get_buffer()

DUK_EXTERNAL_DECL void * duk_get_buffer	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_size )

Definition at line 16197 of file duktape-1.5.2/src-noline/duktape.c.

16199 {

◆ duk_get_buffer_data()

DUK_EXTERNAL_DECL void * duk_get_buffer_data	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_size )

Definition at line 16259 of file duktape-1.5.2/src-noline/duktape.c.

16260 {

16261 *out_size = (duk_size_t) h_bufobj->length;

◆ duk_get_c_function()

DUK_EXTERNAL_DECL duk_c_function duk_get_c_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16378 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                             {
    duk_hobject *h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
    if (h != NULL && !DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
        h = NULL;
    }
    return (duk_hnativefunction *) h;
}
 
DUK_INTERNAL duk_hnativefunction *duk_require_hnativefunction(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
    if (!(h != NULL && DUK_HOBJECT_IS_NATIVEFUNCTION(h))) {
        DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "nativefunction", DUK_STR_NOT_NATIVEFUNCTION);
    }
    return (duk_hnativefunction *) h;
}
 
DUK_EXTERNAL duk_c_function duk_get_c_function(duk_context *ctx, duk_idx_t index) {
    duk_tval *tv;
    duk_hobject *h;
    duk_hnativefunction *f;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);

◆ duk_get_context()

DUK_EXTERNAL_DECL duk_context * duk_get_context	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16423 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_get_current_magic()

DUK_EXTERNAL_DECL duk_int_t duk_get_current_magic ( duk_context * ctx )

Definition at line 12817 of file duktape-1.5.2/src-noline/duktape.c.

                     {
        /* Strict by default. */
        return 1;
    }
    return ((act->flags & DUK_ACT_FLAG_STRICT) != 0 ? 1 : 0);
}
 
/*
 *  Duktape/C function magic
 */
 
DUK_EXTERNAL duk_int_t duk_get_current_magic(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_activation *act;
    duk_hobject *func;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(thr->callstack_top >= 0);
 
    act = duk_hthread_get_current_activation(thr);

◆ duk_get_error_code()

DUK_EXTERNAL_DECL duk_errcode_t duk_get_error_code	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17789 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                  {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_BUFFER(tv)) {
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
        DUK_ASSERT(h != NULL);
        return (DUK_HBUFFER_HAS_DYNAMIC(h) && DUK_HBUFFER_HAS_EXTERNAL(h) ? 1 : 0);
    }
    return 0;
}
 
DUK_EXTERNAL duk_errcode_t duk_get_error_code(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h;
    duk_uint_t sanity;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    h = duk_get_hobject(ctx, index);
 
    sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY;
    do {
        if (!h) {
            return DUK_ERR_NONE;
        }
        if (h == thr->builtins[DUK_BIDX_EVAL_ERROR_PROTOTYPE]) {
            return DUK_ERR_EVAL_ERROR;
        }
        if (h == thr->builtins[DUK_BIDX_RANGE_ERROR_PROTOTYPE]) {
            return DUK_ERR_RANGE_ERROR;
        }
        if (h == thr->builtins[DUK_BIDX_REFERENCE_ERROR_PROTOTYPE]) {
            return DUK_ERR_REFERENCE_ERROR;
        }
        if (h == thr->builtins[DUK_BIDX_SYNTAX_ERROR_PROTOTYPE]) {

◆ duk_get_finalizer()

DUK_EXTERNAL_DECL void duk_get_finalizer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 14863 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_get_global_string()

DUK_EXTERNAL_DECL duk_bool_t duk_get_global_string	(	duk_context *	ctx,
		const char *	key )

Definition at line 14773 of file duktape-1.5.2/src-noline/duktape.c.

                     {
        while (ent->key != NULL) {
            duk_push_number(ctx, ent->value);
            duk_put_prop_string(ctx, obj_index, ent->key);
            ent++;
        }
    }
}
 
/*

◆ duk_get_heapptr()

DUK_EXTERNAL_DECL void * duk_get_heapptr	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16435 of file duktape-1.5.2/src-noline/duktape.c.

                                      {
        DUK_ERROR_REQUIRE_TYPE_INDEX((duk_hthread *) ctx, index, "function", DUK_STR_NOT_FUNCTION);
    }
}
 
DUK_EXTERNAL duk_context *duk_get_context(duk_context *ctx, duk_idx_t index) {
    DUK_ASSERT_CTX_VALID(ctx);
 
    return (duk_context *) duk_get_hthread(ctx, index);
}
 
DUK_EXTERNAL duk_context *duk_require_context(duk_context *ctx, duk_idx_t index) {
    DUK_ASSERT_CTX_VALID(ctx);
 
    return (duk_context *) duk_require_hthread(ctx, index);

◆ duk_get_int()

DUK_EXTERNAL_DECL duk_int_t duk_get_int	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16040 of file duktape-1.5.2/src-noline/duktape.c.

                                      {
        duk_double_union ret;
        ret.d = DUK_TVAL_GET_NUMBER(tv);
 

◆ duk_get_length()

DUK_EXTERNAL_DECL duk_size_t duk_get_length	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16575 of file duktape-1.5.2/src-noline/duktape.c.

                                                                     {
        duk_hstring *h_class;
        h_class = DUK_HTHREAD_GET_STRING(thr, DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX(classnum));
        DUK_UNREF(h_class);
 
        DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, (const char *) DUK_HSTRING_GET_DATA(h_class), DUK_STR_UNEXPECTED_TYPE);
    }
    return h;
}
 
DUK_EXTERNAL duk_size_t duk_get_length(duk_context *ctx, duk_idx_t index) {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (!tv) {
        return 0;
    }
 
    switch (DUK_TVAL_GET_TAG(tv)) {
    case DUK_TAG_UNDEFINED:
    case DUK_TAG_NULL:
    case DUK_TAG_BOOLEAN:
    case DUK_TAG_POINTER:
        return 0;
    case DUK_TAG_STRING: {
        duk_hstring *h = DUK_TVAL_GET_STRING(tv);
        DUK_ASSERT(h != NULL);
        return (duk_size_t) DUK_HSTRING_GET_CHARLEN(h);
    }
    case DUK_TAG_OBJECT: {
        duk_hobject *h = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(h != NULL);
        return (duk_size_t) duk_hobject_get_length((duk_hthread *) ctx, h);
    }
    case DUK_TAG_BUFFER: {
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
        DUK_ASSERT(h != NULL);
        return (duk_size_t) DUK_HBUFFER_GET_SIZE(h);
    }

◆ duk_get_lstring()

DUK_EXTERNAL_DECL const char * duk_get_lstring	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_len )

Definition at line 16064 of file duktape-1.5.2/src-noline/duktape.c.

                                                                          {
    /* Custom coercion for API */
    DUK_ASSERT_CTX_VALID(ctx);
    return (duk_int_t) duk__api_coerce_d2i(ctx, index, 1 /*require*/);
}
 
DUK_EXTERNAL duk_uint_t duk_require_uint(duk_context *ctx, duk_idx_t index) {
    /* Custom coercion for API */
    DUK_ASSERT_CTX_VALID(ctx);
    return (duk_uint_t) duk__api_coerce_d2ui(ctx, index, 1 /*require*/);
}
 
DUK_EXTERNAL const char *duk_get_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len) {
    const char *ret;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* default: NULL, length 0 */
    ret = NULL;
    if (out_len) {
        *out_len = 0;

◆ duk_get_magic()

DUK_EXTERNAL_DECL duk_int_t duk_get_magic	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 12845 of file duktape-1.5.2/src-noline/duktape.c.

                   {
            duk_tval *tv = &act->tv_func;
            duk_small_uint_t lf_flags;
            lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv);
            return (duk_int_t) DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags);
        }
        DUK_ASSERT(func != NULL);
 
        if (DUK_HOBJECT_IS_NATIVEFUNCTION(func)) {
            duk_hnativefunction *nf = (duk_hnativefunction *) func;
            return (duk_int_t) nf->magic;
        }
    }
    return 0;
}
 
DUK_EXTERNAL duk_int_t duk_get_magic(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    duk_hobject *h;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_require_tval(ctx, index);

◆ duk_get_memory_functions()

DUK_EXTERNAL_DECL void duk_get_memory_functions	(	duk_context *	ctx,
		duk_memory_functions *	out_funcs )

Definition at line 14225 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_get_number()

DUK_EXTERNAL_DECL duk_double_t duk_get_number	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15996 of file duktape-1.5.2/src-noline/duktape.c.

                                                                               {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_BOOLEAN(tv)) {
        duk_bool_t ret = DUK_TVAL_GET_BOOLEAN(tv);
        DUK_ASSERT(ret == 0 || ret == 1);
        return ret;
    }
    DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "boolean", DUK_STR_NOT_BOOLEAN);
    return 0;  /* not reachable */
}
 
DUK_EXTERNAL duk_double_t duk_get_number(duk_context *ctx, duk_idx_t index) {
    duk_double_union ret;
    duk_tval *tv;

◆ duk_get_pointer()

DUK_EXTERNAL_DECL void * duk_get_pointer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16121 of file duktape-1.5.2/src-noline/duktape.c.

                                                                           {
    DUK_ASSERT_CTX_VALID(ctx);
 
    return duk_get_lstring(ctx, index, NULL);
}
 
DUK_EXTERNAL const char *duk_require_string(duk_context *ctx, duk_idx_t index) {
    DUK_ASSERT_CTX_VALID(ctx);

◆ duk_get_prop()

DUK_EXTERNAL_DECL duk_bool_t duk_get_prop	(	duk_context *	ctx,
		duk_idx_t	obj_index )

Definition at line 14278 of file duktape-1.5.2/src-noline/duktape.c.

                                                                            {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv_obj;
    duk_tval *tv_key;
    duk_bool_t rc;

◆ duk_get_prop_index()

DUK_EXTERNAL_DECL duk_bool_t duk_get_prop_index	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_uarridx_t	arr_index )

Definition at line 14310 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_get_prop_string()

DUK_EXTERNAL_DECL duk_bool_t duk_get_prop_string	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		const char *	key )

Definition at line 14301 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_get_prototype()

DUK_EXTERNAL_DECL void duk_get_prototype	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 14808 of file duktape-1.5.2/src-noline/duktape.c.

14825 {

14826 duk_hthread *thr = (duk_hthread *) ctx;

◆ duk_get_string()

DUK_EXTERNAL_DECL const char * duk_get_string	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16109 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                     {
    duk_hthread *thr = (duk_hthread *) ctx;
    const char *ret;
 
    DUK_ASSERT_CTX_VALID(ctx);

◆ duk_get_top()

DUK_EXTERNAL_DECL duk_idx_t duk_get_top ( duk_context * ctx )

Definition at line 15204 of file duktape-1.5.2/src-noline/duktape.c.

                                                                             {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(DUK_INVALID_INDEX < 0);
 

◆ duk_get_top_index()

DUK_EXTERNAL_DECL duk_idx_t duk_get_top_index ( duk_context * ctx )

Definition at line 15307 of file duktape-1.5.2/src-noline/duktape.c.

           {
            tv--;
            DUK_TVAL_SET_UNDEFINED(tv);
        } while (tv != tv_end);
        thr->valstack_top = tv_end;
#endif  /* DUK_USE_REFERENCE_COUNTING */
    }
}

◆ duk_get_type()

DUK_EXTERNAL_DECL duk_int_t duk_get_type	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17478 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                              {
    duk_hobject *obj;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    obj = duk_get_hobject(ctx, index);
    if (obj) {
        return (DUK_HEAPHDR_CHECK_FLAG_BITS((duk_heaphdr *) obj, flag_mask) ? 1 : 0);
    }
    return 0;
}
 
DUK_EXTERNAL duk_int_t duk_get_type(duk_context *ctx, duk_idx_t index) {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (!tv) {
        return DUK_TYPE_NONE;
    }
    switch (DUK_TVAL_GET_TAG(tv)) {
    case DUK_TAG_UNDEFINED:
        return DUK_TYPE_UNDEFINED;
    case DUK_TAG_NULL:
        return DUK_TYPE_NULL;
    case DUK_TAG_BOOLEAN:
        return DUK_TYPE_BOOLEAN;
    case DUK_TAG_STRING:
        return DUK_TYPE_STRING;
    case DUK_TAG_OBJECT:
        return DUK_TYPE_OBJECT;

◆ duk_get_type_mask()

DUK_EXTERNAL_DECL duk_uint_t duk_get_type_mask	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17547 of file duktape-1.5.2/src-noline/duktape.c.

                                                                              {
    duk_int_t type_tag;
 
    type_tag = duk_get_type(ctx, index);
    DUK_ASSERT(type_tag >= DUK_TYPE_MIN && type_tag <= DUK_TYPE_MAX);
    DUK_ASSERT(DUK_TYPE_MIN == 0 && sizeof(duk__type_names) / sizeof(const char *) == DUK_TYPE_MAX + 1);
 
    return duk__type_names[type_tag];
}
#endif
 
DUK_EXTERNAL duk_bool_t duk_check_type(duk_context *ctx, duk_idx_t index, duk_int_t type) {
    DUK_ASSERT_CTX_VALID(ctx);
 
    return (duk_get_type(ctx, index) == type) ? 1 : 0;
}
 
DUK_EXTERNAL duk_uint_t duk_get_type_mask(duk_context *ctx, duk_idx_t index) {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (!tv) {
        return DUK_TYPE_MASK_NONE;
    }
    switch (DUK_TVAL_GET_TAG(tv)) {
    case DUK_TAG_UNDEFINED:
        return DUK_TYPE_MASK_UNDEFINED;
    case DUK_TAG_NULL:
        return DUK_TYPE_MASK_NULL;
    case DUK_TAG_BOOLEAN:
        return DUK_TYPE_MASK_BOOLEAN;
    case DUK_TAG_STRING:
        return DUK_TYPE_MASK_STRING;
    case DUK_TAG_OBJECT:
        return DUK_TYPE_MASK_OBJECT;

◆ duk_get_uint()

DUK_EXTERNAL_DECL duk_uint_t duk_get_uint	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16046 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_get_var()

DUK_EXTERNAL_DECL void duk_get_var ( duk_context * ctx )

Definition at line 19869 of file duktape-1.5.2/src-noline/duktape.c.

                                                   {
        return 0;
    }
 
    DUK_ASSERT(char_offset <= DUK_UINT_MAX);  /* guaranteed by string limits */
    cp = duk_hstring_char_code_at_raw(thr, h, (duk_uint_t) char_offset);
    return (duk_codepoint_t) cp;
}
/*
 *  Variable access
 */
 
/* include removed: duk_internal.h */
 
DUK_EXTERNAL void duk_get_var(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_activation *act;
    duk_hstring *h_varname;
    duk_small_int_t throw_flag = 1;  /* always throw ReferenceError for unresolvable */
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    h_varname = duk_require_hstring(ctx, -1);  /* XXX: tostring? */
    DUK_ASSERT(h_varname != NULL);
 
    act = duk_hthread_get_current_activation(thr);
    if (act) {
        (void) duk_js_getvar_activation(thr, act, h_varname, throw_flag);  /* -> [ ... varname val this ] */
    } else {

◆ duk_has_prop()

DUK_EXTERNAL_DECL duk_bool_t duk_has_prop	(	duk_context *	ctx,
		duk_idx_t	obj_index )

Definition at line 14471 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                           {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT_DISABLE(stridx >= 0);
    DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS);
    DUK_UNREF(thr);
 
    obj_index = duk_require_normalize_index(ctx, obj_index);
    duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx));
    return duk_del_prop(ctx, obj_index);
}
 
DUK_EXTERNAL duk_bool_t duk_has_prop(duk_context *ctx, duk_idx_t obj_index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv_obj;
    duk_tval *tv_key;

◆ duk_has_prop_index()

DUK_EXTERNAL_DECL duk_bool_t duk_has_prop_index	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_uarridx_t	arr_index )

Definition at line 14502 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_has_prop_string()

DUK_EXTERNAL_DECL duk_bool_t duk_has_prop_string	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		const char *	key )

Definition at line 14493 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_has_var()

DUK_EXTERNAL_DECL duk_bool_t duk_has_var ( duk_context * ctx )

Definition at line 19943 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_hex_decode()

DUK_EXTERNAL_DECL void duk_hex_decode	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 13389 of file duktape-1.5.2/src-noline/duktape.c.

                                                                    {
    duk_hthread *thr = (duk_hthread *) ctx;
    const duk_uint8_t *inp;
    duk_size_t len;
    duk_size_t i;
    duk_int_t t;
    duk_uint8_t *buf;
#if defined(DUK_USE_HEX_FASTPATH)
    duk_int_t chk;
    duk_uint8_t *p;
    duk_size_t len_safe;
#endif
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    index = duk_require_normalize_index(ctx, index);
    inp = duk__prep_codec_arg(ctx, index, &len);
    DUK_ASSERT(inp != NULL || len == 0);
 
    if (len & 0x01) {
        goto type_error;
    }
 
    /* Fixed buffer, no zeroing because we'll fill all the data. */
    buf = (duk_uint8_t *) duk_push_buffer_raw(ctx, len / 2, DUK_BUF_FLAG_NOZERO /*flags*/);
    DUK_ASSERT(buf != NULL);
 
#if defined(DUK_USE_HEX_FASTPATH)
    p = buf;
    len_safe = len & ~0x07U;
    for (i = 0; i < len_safe; i += 8) {
        t = ((duk_int_t) duk_hex_dectab_shift4[inp[i]]) |
            ((duk_int_t) duk_hex_dectab[inp[i + 1]]);
        chk = t;
        p[0] = (duk_uint8_t) t;
        t = ((duk_int_t) duk_hex_dectab_shift4[inp[i + 2]]) |
            ((duk_int_t) duk_hex_dectab[inp[i + 3]]);
        chk |= t;
        p[1] = (duk_uint8_t) t;
        t = ((duk_int_t) duk_hex_dectab_shift4[inp[i + 4]]) |
            ((duk_int_t) duk_hex_dectab[inp[i + 5]]);
        chk |= t;
        p[2] = (duk_uint8_t) t;
        t = ((duk_int_t) duk_hex_dectab_shift4[inp[i + 6]]) |
            ((duk_int_t) duk_hex_dectab[inp[i + 7]]);
        chk |= t;
        p[3] = (duk_uint8_t) t;
        p += 4;
 
        /* Check if any lookup above had a negative result. */
        if (DUK_UNLIKELY(chk < 0)) {
            goto type_error;
        }
    }
    for (; i < len; i += 2) {
        t = (((duk_int_t) duk_hex_dectab[inp[i]]) << 4) |
            ((duk_int_t) duk_hex_dectab[inp[i + 1]]);
        if (DUK_UNLIKELY(t < 0)) {
            goto type_error;
        }
        *p++ = (duk_uint8_t) t;
    }
#else  /* DUK_USE_HEX_FASTPATH */
    for (i = 0; i < len; i += 2) {
        /* For invalid characters the value -1 gets extended to
         * at least 16 bits.  If either nybble is invalid, the

◆ duk_hex_encode()

DUK_EXTERNAL_DECL const char * duk_hex_encode	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 13333 of file duktape-1.5.2/src-noline/duktape.c.

                 {
        goto type_error;
    }
 
    /* XXX: convert to fixed buffer? */
    (void) duk_resize_buffer(ctx, -1, (duk_size_t) (dst_final - dst));
    duk_replace(ctx, index);
    return;
 
 type_error:
    DUK_ERROR_TYPE(thr, DUK_STR_DECODE_FAILED);
}
 
DUK_EXTERNAL const char *duk_hex_encode(duk_context *ctx, duk_idx_t index) {
    const duk_uint8_t *inp;
    duk_size_t len;
    duk_size_t i;
    duk_uint8_t *buf;
    const char *ret;
#if defined(DUK_USE_HEX_FASTPATH)
    duk_size_t len_safe;
    duk_uint16_t *p16;
#endif
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    index = duk_require_normalize_index(ctx, index);
    inp = duk__prep_codec_arg(ctx, index, &len);
    DUK_ASSERT(inp != NULL || len == 0);
 
    /* Fixed buffer, no zeroing because we'll fill all the data. */
    buf = (duk_uint8_t *) duk_push_buffer_raw(ctx, len * 2, DUK_BUF_FLAG_NOZERO /*flags*/);
    DUK_ASSERT(buf != NULL);
 
#if defined(DUK_USE_HEX_FASTPATH)
    DUK_ASSERT((((duk_size_t) buf) & 0x01U) == 0);   /* pointer is aligned, guaranteed for fixed buffer */
    p16 = (duk_uint16_t *) (void *) buf;
    len_safe = len & ~0x03U;
    for (i = 0; i < len_safe; i += 4) {
        p16[0] = duk_hex_enctab[inp[i]];
        p16[1] = duk_hex_enctab[inp[i + 1]];
        p16[2] = duk_hex_enctab[inp[i + 2]];
        p16[3] = duk_hex_enctab[inp[i + 3]];
        p16 += 4;
    }
    for (; i < len; i++) {
        *p16++ = duk_hex_enctab[inp[i]];
    }
#else  /* DUK_USE_HEX_FASTPATH */
    for (i = 0; i < len; i++) {
        duk_small_uint_t t;

◆ duk_insert()

DUK_EXTERNAL_DECL void duk_insert	(	duk_context *	ctx,
		duk_idx_t	to_index )

Definition at line 15740 of file duktape-1.5.2/src-noline/duktape.c.

                                                       {
        DUK_ERROR_API_INDEX(thr, -1);
        return;  /* unreachable */
    }
    tv_from = thr->valstack_top - 1;
    tv_to = thr->valstack_top++;
    DUK_ASSERT(tv_from != NULL);
    DUK_ASSERT(tv_to != NULL);
    DUK_TVAL_SET_TVAL(tv_to, tv_from);
    DUK_TVAL_INCREF(thr, tv_to);  /* no side effects */
}
 
DUK_EXTERNAL void duk_insert(duk_context *ctx, duk_idx_t to_index) {
    duk_tval *p;
    duk_tval *q;
    duk_tval tv_tmp;
    duk_size_t nbytes;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    p = duk_require_tval(ctx, to_index);
    DUK_ASSERT(p != NULL);
    q = duk_require_tval(ctx, -1);
    DUK_ASSERT(q != NULL);
 
    DUK_ASSERT(q >= p);
 
    /*              nbytes
     *           <--------->
     *    [ ... | p | x | x | q ]
     * => [ ... | q | p | x | x ]
     */
 
    nbytes = (duk_size_t) (((duk_uint8_t *) q) - ((duk_uint8_t *) p));  /* Note: 'q' is top-1 */

◆ duk_instanceof()

DUK_EXTERNAL_DECL duk_bool_t duk_instanceof	(	duk_context *	ctx,
		duk_idx_t	index1,
		duk_idx_t	index2 )

Definition at line 19319 of file duktape-1.5.2/src-noline/duktape.c.

                                        {
        return 0;
    }
 
    /* No coercions or other side effects, so safe */
    return duk_js_strict_equals(tv1, tv2);
}
 
/*
 *  instanceof
 */
 
DUK_EXTERNAL duk_bool_t duk_instanceof(duk_context *ctx, duk_idx_t index1, duk_idx_t index2) {

◆ duk_is_array()

DUK_EXTERNAL_DECL duk_bool_t duk_is_array	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17691 of file duktape-1.5.2/src-noline/duktape.c.

                                                                         {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_BUFFER);
}
 
DUK_EXTERNAL duk_bool_t duk_is_pointer(duk_context *ctx, duk_idx_t index) {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_POINTER);
}

◆ duk_is_boolean()

DUK_EXTERNAL_DECL duk_bool_t duk_is_boolean	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17624 of file duktape-1.5.2/src-noline/duktape.c.

17627 {

◆ duk_is_bound_function()

DUK_EXTERNAL_DECL duk_bool_t duk_is_bound_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17733 of file duktape-1.5.2/src-noline/duktape.c.

                                                                             {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__obj_flag_any_default_false(ctx,

◆ duk_is_buffer()

DUK_EXTERNAL_DECL duk_bool_t duk_is_buffer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17676 of file duktape-1.5.2/src-noline/duktape.c.

                                        {
        return 0;
    }

◆ duk_is_c_function()

DUK_EXTERNAL_DECL duk_bool_t duk_is_c_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17719 of file duktape-1.5.2/src-noline/duktape.c.

                                                                           {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 

◆ duk_is_constructor_call()

DUK_EXTERNAL_DECL duk_bool_t duk_is_constructor_call ( duk_context * ctx )

Definition at line 12775 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_is_dynamic_buffer()

DUK_EXTERNAL_DECL duk_bool_t duk_is_dynamic_buffer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17761 of file duktape-1.5.2/src-noline/duktape.c.

                                                                               {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_BUFFER(tv)) {
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
        DUK_ASSERT(h != NULL);
        return (DUK_HBUFFER_HAS_DYNAMIC(h) ? 0 : 1);

◆ duk_is_ecmascript_function()

DUK_EXTERNAL_DECL duk_bool_t duk_is_ecmascript_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17726 of file duktape-1.5.2/src-noline/duktape.c.

                                         {
        return 1;
    }
    return duk__obj_flag_any_default_false(ctx,
                                           index,
                                           DUK_HOBJECT_FLAG_COMPILEDFUNCTION |

◆ duk_is_external_buffer()

DUK_EXTERNAL_DECL duk_bool_t duk_is_external_buffer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17775 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                 {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_BUFFER(tv)) {
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
        DUK_ASSERT(h != NULL);
        return (DUK_HBUFFER_HAS_DYNAMIC(h) && !DUK_HBUFFER_HAS_EXTERNAL(h) ? 1 : 0);

◆ duk_is_fixed_buffer()

DUK_EXTERNAL_DECL duk_bool_t duk_is_fixed_buffer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17747 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                 {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__obj_flag_any_default_false(ctx,
                                           index,
                                           DUK_HOBJECT_FLAG_BOUND);
}
 
DUK_EXTERNAL duk_bool_t duk_is_thread(duk_context *ctx, duk_idx_t index) {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__obj_flag_any_default_false(ctx,

◆ duk_is_function()

DUK_EXTERNAL_DECL duk_bool_t duk_is_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17703 of file duktape-1.5.2/src-noline/duktape.c.

                                                                            {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_LIGHTFUNC);
}
 
DUK_EXTERNAL duk_bool_t duk_is_array(duk_context *ctx, duk_idx_t index) {
    duk_hobject *obj;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    obj = duk_get_hobject(ctx, index);
    if (obj) {
        return (DUK_HOBJECT_GET_CLASS_NUMBER(obj) == DUK_HOBJECT_CLASS_ARRAY ? 1 : 0);
    }
    return 0;

◆ duk_is_lightfunc()

DUK_EXTERNAL_DECL duk_bool_t duk_is_lightfunc	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17686 of file duktape-1.5.2/src-noline/duktape.c.

17688 {

17689 DUK_ASSERT_CTX_VALID(ctx);

◆ duk_is_nan()

DUK_EXTERNAL_DECL duk_bool_t duk_is_nan	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17648 of file duktape-1.5.2/src-noline/duktape.c.

             {
        return 0;
    }
    return DUK_TVAL_IS_NUMBER(tv);
}
 

◆ duk_is_null()

DUK_EXTERNAL_DECL duk_bool_t duk_is_null	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17605 of file duktape-1.5.2/src-noline/duktape.c.

17607 {

17608 return 1;

◆ duk_is_null_or_undefined()

DUK_EXTERNAL_DECL duk_bool_t duk_is_null_or_undefined	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17610 of file duktape-1.5.2/src-noline/duktape.c.

                                    {
        DUK_ERROR_TYPE(thr, DUK_STR_UNEXPECTED_TYPE);
        DUK_UNREACHABLE();
    }
    return 0;
}
 
DUK_EXTERNAL duk_bool_t duk_is_undefined(duk_context *ctx, duk_idx_t index) {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_UNDEFINED);
}
 
DUK_EXTERNAL duk_bool_t duk_is_null(duk_context *ctx, duk_idx_t index) {

◆ duk_is_number()

DUK_EXTERNAL_DECL duk_bool_t duk_is_number	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17629 of file duktape-1.5.2/src-noline/duktape.c.

             {
        return 0;
    }
    tag = DUK_TVAL_GET_TAG(tv);
    return (tag == DUK_TAG_UNDEFINED) || (tag == DUK_TAG_NULL);
}
 
DUK_EXTERNAL duk_bool_t duk_is_boolean(duk_context *ctx, duk_idx_t index) {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_BOOLEAN);
}
 
DUK_EXTERNAL duk_bool_t duk_is_number(duk_context *ctx, duk_idx_t index) {

◆ duk_is_object()

DUK_EXTERNAL_DECL duk_bool_t duk_is_object	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17671 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_is_pointer()

DUK_EXTERNAL_DECL duk_bool_t duk_is_pointer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17681 of file duktape-1.5.2/src-noline/duktape.c.

17683 {

17684 DUK_ASSERT_CTX_VALID(ctx);

◆ duk_is_strict_call()

DUK_EXTERNAL_DECL duk_bool_t duk_is_strict_call ( duk_context * ctx )

Definition at line 12788 of file duktape-1.5.2/src-noline/duktape.c.

                                                                  {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_activation *act;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(thr->callstack_top >= 0);
 
    act = duk_hthread_get_current_activation(thr);
    DUK_ASSERT(act != NULL);  /* because callstack_top > 0 */
    return ((act->flags & DUK_ACT_FLAG_CONSTRUCT) != 0 ? 1 : 0);
}
 
DUK_EXTERNAL duk_bool_t duk_is_strict_call(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_activation *act;
 
    /* For user code this could just return 1 (strict) always
     * because all Duktape/C functions are considered strict,
     * and strict is also the default when nothing is running.

◆ duk_is_string()

DUK_EXTERNAL_DECL duk_bool_t duk_is_string	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17666 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_is_thread()

DUK_EXTERNAL_DECL duk_bool_t duk_is_thread	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17740 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                      {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__obj_flag_any_default_false(ctx,

◆ duk_is_undefined()

DUK_EXTERNAL_DECL duk_bool_t duk_is_undefined	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17600 of file duktape-1.5.2/src-noline/duktape.c.

17602 {

17603 duk_hthread *thr = (duk_hthread *) ctx;

◆ duk_is_valid_index()

DUK_EXTERNAL_DECL duk_bool_t duk_is_valid_index	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15180 of file duktape-1.5.2/src-noline/duktape.c.

           {
        DUK_ASSERT(index != DUK_INVALID_INDEX);
        uindex = (duk_uidx_t) index;
    }
 

◆ duk_join()

DUK_EXTERNAL_DECL void duk_join	(	duk_context *	ctx,
		duk_idx_t	count )

Definition at line 19646 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_json_decode()

DUK_EXTERNAL_DECL void duk_json_decode	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 13499 of file duktape-1.5.2/src-noline/duktape.c.

13516 {

13517#ifdef DUK_USE_ASSERTIONS

◆ duk_json_encode()

DUK_EXTERNAL_DECL const char * duk_json_encode	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 13473 of file duktape-1.5.2/src-noline/duktape.c.

                                 {
            goto type_error;
        }
        buf[i >> 1] = (duk_uint8_t) t;
    }
#endif  /* DUK_USE_HEX_FASTPATH */
 
    duk_replace(ctx, index);
    return;
 
 type_error:
    DUK_ERROR_TYPE(thr, DUK_STR_DECODE_FAILED);
}
 
DUK_EXTERNAL const char *duk_json_encode(duk_context *ctx, duk_idx_t index) {
#ifdef DUK_USE_ASSERTIONS
    duk_idx_t top_at_entry;
#endif
    const char *ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
#ifdef DUK_USE_ASSERTIONS

◆ duk_load_function()

DUK_EXTERNAL_DECL void duk_load_function ( duk_context * ctx )

Definition at line 12268 of file duktape-1.5.2/src-noline/duktape.c.

                                         : %!T", duk_get_tval(ctx, -1)));
 
    duk_remove(ctx, -2);  /* [ ... func buf ] -> [ ... buf ] */
}
 
DUK_EXTERNAL void duk_load_function(duk_context *ctx) {
    duk_hthread *thr;
    duk_uint8_t *p_buf, *p, *p_end;
    duk_size_t sz;
 
    DUK_ASSERT(ctx != NULL);
    thr = (duk_hthread *) ctx;
    DUK_UNREF(ctx);
 
    p_buf = (duk_uint8_t *) duk_require_buffer(ctx, -1, &sz);
    DUK_ASSERT(p_buf != NULL);
 
    /* The caller is responsible for being sure that bytecode being loaded
     * is valid and trusted.  Invalid bytecode can cause memory unsafe
     * behavior directly during loading or later during bytecode execution
     * (instruction validation would be quite complex to implement).
     *
     * This signature check is the only sanity check for detecting
     * accidental invalid inputs.  The initial 0xFF byte ensures no
     * ordinary string will be accepted by accident.
     */
    p = p_buf;

◆ duk_log()

DUK_EXTERNAL_DECL void duk_log	(	duk_context *	ctx,
		duk_int_t	level,
		const char *	fmt,
			... )

Definition at line 14152 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_log_va()

DUK_EXTERNAL_DECL void duk_log_va	(	duk_context *	ctx,
		duk_int_t	level,
		const char *	fmt,
		va_list	ap )

Definition at line 14119 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                             {
    /* stridx_logfunc[] must be static to allow initializer with old compilers like BCC */
    static const duk_uint16_t stridx_logfunc[6] = {
        DUK_STRIDX_LC_TRACE, DUK_STRIDX_LC_DEBUG, DUK_STRIDX_LC_INFO,
        DUK_STRIDX_LC_WARN, DUK_STRIDX_LC_ERROR, DUK_STRIDX_LC_FATAL
    };
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    if (level < 0) {
        level = 0;
    } else if (level > (int) (sizeof(stridx_logfunc) / sizeof(duk_uint16_t)) - 1) {
        level = (int) (sizeof(stridx_logfunc) / sizeof(duk_uint16_t)) - 1;
    }
 

◆ duk_map_string()

DUK_EXTERNAL_DECL void duk_map_string	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_map_char_function	callback,
		void *	udata )

Definition at line 19680 of file duktape-1.5.2/src-noline/duktape.c.

             {
        if (p >= p_end) {
            break;
        }
        cp = (int) duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end);
        callback(udata, cp);
    }
}
 
DUK_EXTERNAL void duk_map_string(duk_context *ctx, duk_idx_t index, duk_map_char_function callback, void *udata) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hstring *h_input;
    duk_bufwriter_ctx bw_alloc;
    duk_bufwriter_ctx *bw;
    const duk_uint8_t *p, *p_start, *p_end;
    duk_codepoint_t cp;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    index = duk_normalize_index(ctx, index);
 
    h_input = duk_require_hstring(ctx, index);
    DUK_ASSERT(h_input != NULL);
 
    bw = &bw_alloc;
    DUK_BW_INIT_PUSHBUF(thr, bw, DUK_HSTRING_GET_BYTELEN(h_input));  /* reasonable output estimate */
 
    p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input);
    p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
    p = p_start;
 
    for (;;) {

◆ duk_new()

DUK_EXTERNAL_DECL void duk_new	(	duk_context *	ctx,
		duk_idx_t	nargs )

Definition at line 12549 of file duktape-1.5.2/src-noline/duktape.c.

                                               {
        /* See comments in duk_pcall(). */
        DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS);
        return DUK_EXEC_ERROR;  /* unreachable */
    }
 
    rc = duk_handle_safe_call(thr,           /* thread */
                              func,          /* func */
                              nargs,         /* num_stack_args */
                              nrets);        /* num_stack_res */
 
    return rc;
}
 
DUK_EXTERNAL void duk_new(duk_context *ctx, duk_idx_t nargs) {
    /*
     *  There are two [[Construct]] operations in the specification:
     *
     *    - E5 Section 13.2.2: for Function objects
     *    - E5 Section 15.3.4.5.2: for "bound" Function objects
     *
     *  The chain of bound functions is resolved in Section 15.3.4.5.2,
     *  with arguments "piling up" until the [[Construct]] internal
     *  method is called on the final, actual Function object.  Note
     *  that the "prototype" property is looked up *only* from the
     *  final object, *before* calling the constructor.
     *
     *  Currently we follow the bound function chain here to get the
     *  "prototype" property value from the final, non-bound function.
     *  However, we let duk_handle_call() handle the argument "piling"
     *  when the constructor is called.  The bound function chain is
     *  thus now processed twice.
     *
     *  When constructing new Array instances, an unnecessary object is
     *  created and discarded now: the standard [[Construct]] creates an
     *  object, and calls the Array constructor.  The Array constructor
     *  returns an Array instance, which is used as the result value for
     *  the "new" operation; the object created before the Array constructor
     *  call is discarded.
     *
     *  This would be easy to fix, e.g. by knowing that the Array constructor
     *  will always create a replacement object and skip creating the fallback
     *  object in that case.
     *
     *  Note: functions called via "new" need to know they are called as a
     *  constructor.  For instance, built-in constructors behave differently
     *  depending on how they are called.
     */
 
    /* XXX: merge this with duk_js_call.c, as this function implements
     * core semantics (or perhaps merge the two files altogether).
     */
 
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *proto;
    duk_hobject *cons;
    duk_hobject *fallback;
    duk_idx_t idx_cons;
    duk_small_uint_t call_flags;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* [... constructor arg1 ... argN] */
 
    idx_cons = duk_require_normalize_index(ctx, -nargs - 1);
 
    DUK_DDD(DUK_DDDPRINT("top=%ld, nargs=%ld, idx_cons=%ld",
                         (long) duk_get_top(ctx), (long) nargs, (long) idx_cons));
 
    /* XXX: code duplication */
 
    /*
     *  Figure out the final, non-bound constructor, to get "prototype"
     *  property.
     */
 
    duk_dup(ctx, idx_cons);
    for (;;) {
        duk_tval *tv;
        tv = DUK_GET_TVAL_NEGIDX(ctx, -1);
        DUK_ASSERT(tv != NULL);
 
        if (DUK_TVAL_IS_OBJECT(tv)) {
            cons = DUK_TVAL_GET_OBJECT(tv);
            DUK_ASSERT(cons != NULL);
            if (!DUK_HOBJECT_IS_CALLABLE(cons) || !DUK_HOBJECT_HAS_CONSTRUCTABLE(cons)) {
                /* Checking callability of the immediate target
                 * is important, same for constructability.
                 * Checking it for functions down the bound
                 * function chain is not strictly necessary
                 * because .bind() should normally reject them.
                 * But it's good to check anyway because it's
                 * technically possible to edit the bound function
                 * chain via internal keys.
                 */
                goto not_constructable;
            }
            if (!DUK_HOBJECT_HAS_BOUND(cons)) {
                break;
            }
        } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
            /* Lightfuncs cannot be bound. */
            break;
        } else {
            /* Anything else is not constructable. */
            goto not_constructable;
        }
        duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_TARGET);  /* -> [... cons target] */
        duk_remove(ctx, -2);                                  /* -> [... target] */
    }
    DUK_ASSERT(duk_is_callable(ctx, -1));
    DUK_ASSERT(duk_is_lightfunc(ctx, -1) ||
               (duk_get_hobject(ctx, -1) != NULL && !DUK_HOBJECT_HAS_BOUND(duk_get_hobject(ctx, -1))));
 
    /* [... constructor arg1 ... argN final_cons] */
 
    /*
     *  Create "fallback" object to be used as the object instance,
     *  unless the constructor returns a replacement value.
     *  Its internal prototype needs to be set based on "prototype"
     *  property of the constructor.
     */
 
    duk_push_object(ctx);  /* class Object, extensible */
 
    /* [... constructor arg1 ... argN final_cons fallback] */
 
    duk_get_prop_stridx(ctx, -2, DUK_STRIDX_PROTOTYPE);
    proto = duk_get_hobject(ctx, -1);
    if (!proto) {
        DUK_DDD(DUK_DDDPRINT("constructor has no 'prototype' property, or value not an object "
                             "-> leave standard Object prototype as fallback prototype"));
    } else {
        DUK_DDD(DUK_DDDPRINT("constructor has 'prototype' property with object value "
                             "-> set fallback prototype to that value: %!iO", (duk_heaphdr *) proto));
        fallback = duk_get_hobject(ctx, -2);
        DUK_ASSERT(fallback != NULL);
        DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, fallback, proto);
    }
    duk_pop(ctx);
 
    /* [... constructor arg1 ... argN final_cons fallback] */
 
    /*
     *  Manipulate callstack for the call.
     */
 
    duk_dup_top(ctx);
    duk_insert(ctx, idx_cons + 1);  /* use fallback as 'this' value */
    duk_insert(ctx, idx_cons);      /* also stash it before constructor,
                                     * in case we need it (as the fallback value)
                                     */
    duk_pop(ctx);                   /* pop final_cons */
 
 
    /* [... fallback constructor fallback(this) arg1 ... argN];
     * Note: idx_cons points to first 'fallback', not 'constructor'.
     */
 
    DUK_DDD(DUK_DDDPRINT("before call, idx_cons+1 (constructor) -> %!T, idx_cons+2 (fallback/this) -> %!T, "
                         "nargs=%ld, top=%ld",
                         (duk_tval *) duk_get_tval(ctx, idx_cons + 1),
                         (duk_tval *) duk_get_tval(ctx, idx_cons + 2),
                         (long) nargs,
                         (long) duk_get_top(ctx)));
 
    /*
     *  Call the constructor function (called in "constructor mode").
     */
 
    call_flags = DUK_CALL_FLAG_CONSTRUCTOR_CALL;  /* not protected, respect reclimit, is a constructor call */
 
    duk_handle_call_unprotected(thr,           /* thread */
                                nargs,         /* num_stack_args */
                                call_flags);   /* call_flags */
 
    /* [... fallback retval] */
 
    DUK_DDD(DUK_DDDPRINT("constructor call finished, fallback=%!iT, retval=%!iT",
                         (duk_tval *) duk_get_tval(ctx, -2),
                         (duk_tval *) duk_get_tval(ctx, -1)));
 
    /*
     *  Determine whether to use the constructor return value as the created
     *  object instance or not.
     */
 
    if (duk_is_object(ctx, -1)) {
        duk_remove(ctx, -2);
    } else {
        duk_pop(ctx);
    }
 
    /*

◆ duk_next()

DUK_EXTERNAL_DECL duk_bool_t duk_next	(	duk_context *	ctx,
		duk_idx_t	enum_index,
		duk_bool_t	get_value )

Definition at line 14727 of file duktape-1.5.2/src-noline/duktape.c.

             {
        /* Note: this may fail, caller should protect the call if necessary */
        duk_hobject_compact_props(thr, obj);
    }
}
 

◆ duk_normalize_index()

DUK_EXTERNAL_DECL duk_idx_t duk_normalize_index	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15056 of file duktape-1.5.2/src-noline/duktape.c.

                 {
        DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "number", DUK_STR_NOT_NUMBER);
        /* not reachable */
    }
    return 0;
}
 
/*
 *  Stack index validation/normalization and getting a stack duk_tval ptr.
 *
 *  These are called by many API entrypoints so the implementations must be
 *  fast and "inlined".
 *
 *  There's some repetition because of this; keep the functions in sync.
 */
 
DUK_EXTERNAL duk_idx_t duk_normalize_index(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_uidx_t vs_size;
    duk_uidx_t uindex;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(DUK_INVALID_INDEX < 0);
 
    /* Care must be taken to avoid pointer wrapping in the index
     * validation.  For instance, on a 32-bit platform with 8-byte
     * duk_tval the index 0x20000000UL would wrap the memory space
     * once.
     */
 
    /* Assume value stack sizes (in elements) fits into duk_idx_t. */
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    vs_size = (duk_uidx_t) (thr->valstack_top - thr->valstack_bottom);
    DUK_ASSERT_DISABLE(vs_size >= 0);  /* unsigned */

◆ duk_pcall()

DUK_EXTERNAL_DECL duk_int_t duk_pcall	(	duk_context *	ctx,
		duk_idx_t	nargs )

Definition at line 12427 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                        {
    /*
     *  XXX: if duk_handle_call() took values through indices, this could be
     *  made much more sensible.  However, duk_handle_call() needs to fudge
     *  the 'this' and 'func' values to handle bound function chains, which
     *  is now done "in-place", so this is not a trivial change.
     */
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    obj_index = duk_require_normalize_index(ctx, obj_index);  /* make absolute */
 
    duk__call_prop_prep_stack(ctx, obj_index, nargs);
 
    duk_call_method(ctx, nargs);
}
 
DUK_EXTERNAL duk_int_t duk_pcall(duk_context *ctx, duk_idx_t nargs) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_small_uint_t call_flags;
    duk_idx_t idx_func;
    duk_int_t rc;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
 
    idx_func = duk_get_top(ctx) - nargs - 1;  /* must work for nargs <= 0 */
    if (idx_func < 0 || nargs < 0) {
        /* We can't reliably pop anything here because the stack input
         * shape is incorrect.  So we throw an error; if the caller has
         * no catch point for this, a fatal error will occur.  Another
         * alternative would be to just return an error.  But then the
         * stack would be in an unknown state which might cause some
         * very hard to diagnose problems later on.  Also note that even
         * if we did not throw an error here, the underlying call handler
         * might STILL throw an out-of-memory error or some other internal
         * fatal error.

◆ duk_pcall_method()

DUK_EXTERNAL_DECL duk_int_t duk_pcall_method	(	duk_context *	ctx,
		duk_idx_t	nargs )

Definition at line 12465 of file duktape-1.5.2/src-noline/duktape.c.

                                                                           {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_small_uint_t call_flags;
    duk_idx_t idx_func;
    duk_int_t rc;
 
    DUK_ASSERT_CTX_VALID(ctx);

◆ duk_pcall_prop()

DUK_EXTERNAL_DECL duk_int_t duk_pcall_prop	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_idx_t	nargs )

Definition at line 12510 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_pnew()

DUK_EXTERNAL_DECL duk_int_t duk_pnew	(	duk_context *	ctx,
		duk_idx_t	nargs )

Definition at line 12757 of file duktape-1.5.2/src-noline/duktape.c.

                  :
    DUK_ERROR_TYPE(thr, DUK_STR_NOT_CONSTRUCTABLE);
}
 
DUK_LOCAL duk_ret_t duk__pnew_helper(duk_context *ctx) {
    duk_uint_t nargs;
 
    nargs = duk_to_uint(ctx, -1);
    duk_pop(ctx);
 
    duk_new(ctx, nargs);
    return 1;
}
 

◆ duk_pop()

DUK_EXTERNAL_DECL void duk_pop ( duk_context * ctx )

Definition at line 19146 of file duktape-1.5.2/src-noline/duktape.c.

                                            {
    DUK_ASSERT_CTX_VALID(ctx);
    duk_pop_n(ctx, 1);
}
#else
DUK_EXTERNAL void duk_pop(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;

◆ duk_pop_2()

DUK_EXTERNAL_DECL void duk_pop_2 ( duk_context * ctx )

Definition at line 19167 of file duktape-1.5.2/src-noline/duktape.c.

19169 {

19170 DUK_ERROR_API(thr, DUK_STR_POP_TOO_MANY);

DUK_STR_POP_TOO_MANY

#define DUK_STR_POP_TOO_MANY

Definition duktape-1.5.2/src-noline/duktape.c:2322

◆ duk_pop_3()

DUK_EXTERNAL_DECL void duk_pop_3 ( duk_context * ctx )

Definition at line 19172 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_pop_n()

DUK_EXTERNAL_DECL void duk_pop_n	(	duk_context *	ctx,
		duk_idx_t	count )

Definition at line 19088 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                       {
    duk_hthread *thr = (duk_hthread *) ctx;
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(builtin_idx >= 0 && builtin_idx < DUK_NUM_BUILTINS);
    DUK_ASSERT(thr->builtins[builtin_idx] != NULL);
    duk_push_hobject(ctx, thr->builtins[builtin_idx]);
}
 
/*
 *  Poppers
 */
 
DUK_EXTERNAL void duk_pop_n(duk_context *ctx, duk_idx_t count) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    if (DUK_UNLIKELY(count < 0)) {
        DUK_ERROR_API(thr, DUK_STR_INVALID_COUNT);
        return;
    }
 
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    if (DUK_UNLIKELY((duk_size_t) (thr->valstack_top - thr->valstack_bottom) < (duk_size_t) count)) {
        DUK_ERROR_API(thr, DUK_STR_POP_TOO_MANY);
    }
 
    /*
     *  Must be very careful here, every DECREF may cause reallocation
     *  of our valstack.
     */
 
    /* XXX: inlined DECREF macro would be nice here: no NULL check,
     * refzero queueing but no refzero algorithm run (= no pointer
     * instability), inline code.
     */
 
    /* XXX: optimize loops */
 
#if defined(DUK_USE_REFERENCE_COUNTING)
    while (count > 0) {
        count--;

◆ duk_push_array()

DUK_EXTERNAL_DECL duk_idx_t duk_push_array ( duk_context * ctx )

Definition at line 18458 of file duktape-1.5.2/src-noline/duktape.c.

                                                         {
    DUK_ASSERT_CTX_VALID(ctx);
 
    return duk_push_object_helper(ctx,
                                  DUK_HOBJECT_FLAG_EXTENSIBLE |
                                  DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
                                  DUK_BIDX_OBJECT_PROTOTYPE);
}
 
DUK_EXTERNAL duk_idx_t duk_push_array(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *obj;
    duk_idx_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    ret = duk_push_object_helper(ctx,
                                 DUK_HOBJECT_FLAG_EXTENSIBLE |
                                 DUK_HOBJECT_FLAG_ARRAY_PART |
                                 DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ARRAY),
                                 DUK_BIDX_ARRAY_PROTOTYPE);
 
    obj = duk_require_hobject(ctx, ret);
 
    /*
     *  An array must have a 'length' property (E5 Section 15.4.5.2).
     *  The special array behavior flag must only be enabled once the
     *  length property has been added.
     *

◆ duk_push_boolean()

DUK_EXTERNAL_DECL void duk_push_boolean	(	duk_context *	ctx,
		duk_bool_t	val )

Definition at line 17873 of file duktape-1.5.2/src-noline/duktape.c.

                                                  {
    duk_hthread *thr;
    duk_tval *tv_slot;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;

◆ duk_push_buffer_object()

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 )

Definition at line 18794 of file duktape-1.5.2/src-noline/duktape.c.

                                                       {
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_BUFFER,            DUK_BIDX_BUFFER_PROTOTYPE,            DUK_HBUFFEROBJECT_ELEM_UINT8,        0, 0)   /* DUK_BUFOBJ_DUKTAPE_BUFFER */
};
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
#undef DUK__PACK_ARGS
 
DUK_EXTERNAL 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) {
    duk_hthread *thr;
    duk_hbufferobject *h_bufobj;
    duk_hbuffer *h_val;
    duk_uint32_t tmp;
    duk_uint_t classnum;
    duk_uint_t protobidx;
    duk_uint_t lookupidx;
    duk_uint_t uint_offset, uint_length, uint_added;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    /* The underlying types for offset/length in duk_hbufferobject is
     * duk_uint_t; make sure argument values fit and that offset + length
     * does not wrap.
     */
    uint_offset = (duk_uint_t) byte_offset;
    uint_length = (duk_uint_t) byte_length;
    if (sizeof(duk_size_t) != sizeof(duk_uint_t)) {
        if ((duk_size_t) uint_offset != byte_offset || (duk_size_t) uint_length != byte_length) {
            goto range_error;
        }
    }
    uint_added = uint_offset + uint_length;
    if (uint_added < uint_offset) {
        goto range_error;
    }
    DUK_ASSERT(uint_added >= uint_offset && uint_added >= uint_length);
 
    DUK_ASSERT_DISABLE(flags >= 0);  /* flags is unsigned */
    lookupidx = flags & 0x0f;  /* 4 low bits */
    if (lookupidx >= sizeof(duk__bufobj_flags_lookup) / sizeof(duk_uint32_t)) {
        goto arg_error;
    }
    tmp = duk__bufobj_flags_lookup[lookupidx];
    classnum = tmp >> 24;
    protobidx = (tmp >> 16) & 0xff;
 
    h_val = duk_require_hbuffer(ctx, idx_buffer);
    DUK_ASSERT(h_val != NULL);
 
    h_bufobj = duk_push_bufferobject_raw(ctx,
                                         DUK_HOBJECT_FLAG_EXTENSIBLE |
                                         DUK_HOBJECT_FLAG_BUFFEROBJECT |
                                         DUK_HOBJECT_CLASS_AS_FLAGS(classnum),
                                         protobidx);
    DUK_ASSERT(h_bufobj != NULL);
 
    h_bufobj->buf = h_val;
    DUK_HBUFFER_INCREF(thr, h_val);
    h_bufobj->offset = uint_offset;
    h_bufobj->length = uint_length;
    h_bufobj->shift = (tmp >> 4) & 0x0f;
    h_bufobj->elem_type = (tmp >> 8) & 0xff;
    h_bufobj->is_view = tmp & 0x0f;
    DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj);
 
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
    /* TypedArray views need an automatic ArrayBuffer which must be
     * provided as .buffer property of the view.  Just create a new
     * ArrayBuffer sharing the same underlying buffer.
     */
    if (flags & DUK_BUFOBJ_CREATE_ARRBUF) {
        h_bufobj = duk_push_bufferobject_raw(ctx,
                                             DUK_HOBJECT_FLAG_EXTENSIBLE |
                                             DUK_HOBJECT_FLAG_BUFFEROBJECT |
                                             DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ARRAYBUFFER),
                                             DUK_BIDX_ARRAYBUFFER_PROTOTYPE);
 
        DUK_ASSERT(h_bufobj != NULL);
 
        h_bufobj->buf = h_val;
        DUK_HBUFFER_INCREF(thr, h_val);
        h_bufobj->offset = uint_offset;
        h_bufobj->length = uint_length;
        DUK_ASSERT(h_bufobj->shift == 0);
        h_bufobj->elem_type = DUK_HBUFFEROBJECT_ELEM_UINT8;
        DUK_ASSERT(h_bufobj->is_view == 0);

◆ duk_push_buffer_raw()

DUK_EXTERNAL_DECL void * duk_push_buffer_raw	(	duk_context *	ctx,
		duk_size_t	size,
		duk_small_uint_t	flags )

Definition at line 18974 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                                   {
    const char *filename = duk_api_global_filename;
    duk_int_t line = duk_api_global_line;
    va_list ap;
    duk_idx_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk_api_global_filename = NULL;
    duk_api_global_line = 0;
    va_start(ap, fmt);
    ret = duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap);
    va_end(ap);
    return ret;
}
#endif  /* DUK_USE_VARIADIC_MACROS */
 
DUK_EXTERNAL void *duk_push_buffer_raw(duk_context *ctx, duk_size_t size, duk_small_uint_t flags) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv_slot;
    duk_hbuffer *h;
    void *buf_data;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* check stack first */
    if (thr->valstack_top >= thr->valstack_end) {
        DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
    }
 

◆ duk_push_c_function()

DUK_EXTERNAL_DECL duk_idx_t duk_push_c_function	(	duk_context *	ctx,
		duk_c_function	func,
		duk_idx_t	nargs )

Definition at line 18650 of file duktape-1.5.2/src-noline/duktape.c.

          :
    DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS);
    return 0;  /* not reached */
}

◆ duk_push_c_lightfunc()

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 )

Definition at line 18698 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                                   {
    duk_uint_t flags;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
            DUK_HOBJECT_FLAG_NATIVEFUNCTION |
            DUK_HOBJECT_FLAG_NEWENV |
            DUK_HOBJECT_FLAG_STRICT |
            DUK_HOBJECT_FLAG_NOTAIL |
            DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION);
 
    (void) duk__push_c_function_raw(ctx, func, nargs, flags);
}
 
DUK_EXTERNAL 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) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval tv_tmp;
    duk_small_uint_t lf_flags;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* check stack first */
    if (thr->valstack_top >= thr->valstack_end) {
        DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
    }
 
    if (nargs >= DUK_LFUNC_NARGS_MIN && nargs <= DUK_LFUNC_NARGS_MAX) {
        /* as is */
    } else if (nargs == DUK_VARARGS) {
        nargs = DUK_LFUNC_NARGS_VARARGS;
    } else {
        goto api_error;
    }

◆ duk_push_context_dump()

DUK_EXTERNAL_DECL void duk_push_context_dump ( duk_context * ctx )

Definition at line 13718 of file duktape-1.5.2/src-noline/duktape.c.

                                                          {
    duk_idx_t idx;
    duk_idx_t top;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* We don't duk_require_stack() here now, but rely on the caller having
     * enough space.
     */
 
    top = duk_get_top(ctx);
    duk_push_array(ctx);
    for (idx = 0; idx < top; idx++) {
        duk_dup(ctx, idx);
        duk_put_prop_index(ctx, -2, idx);
    }

◆ duk_push_current_function()

DUK_EXTERNAL_DECL void duk_push_current_function ( duk_context * ctx )

Definition at line 18220 of file duktape-1.5.2/src-noline/duktape.c.

                                                                    {
    duk_hthread *thr;
 
    DUK_ASSERT(ctx != NULL);
    thr = (duk_hthread *) ctx;
 
    DUK_ASSERT(thr->callstack_top > 0);  /* caller required to know */
    DUK_ASSERT(thr->valstack_bottom > thr->valstack);  /* consequence of above */
    DUK_ASSERT(thr->valstack_bottom - 1 >= thr->valstack);  /* 'this' binding exists */
 
    return thr->valstack_bottom - 1;
}

◆ duk_push_current_thread()

DUK_EXTERNAL_DECL void duk_push_current_thread ( duk_context * ctx )

Definition at line 18237 of file duktape-1.5.2/src-noline/duktape.c.

                                                              {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_activation *act;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(thr->callstack_top >= 0);
    DUK_ASSERT(thr->callstack_top <= thr->callstack_size);
 
    act = duk_hthread_get_current_activation(thr);
    if (act) {
        duk_push_tval(ctx, &act->tv_func);

◆ duk_push_error_object_raw()

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,
			... )

Definition at line 18944 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_push_error_object_stash()

DUK_EXTERNAL_DECL duk_idx_t duk_push_error_object_stash	(	duk_context *	ctx,
		duk_errcode_t	err_code,
		const char *	fmt,
			... )

Definition at line 18957 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                                                                       {
    va_list ap;
    duk_idx_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    va_start(ap, fmt);
    ret = duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap);
    va_end(ap);
    return ret;
}

◆ duk_push_error_object_va_raw()

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 )

Definition at line 18892 of file duktape-1.5.2/src-noline/duktape.c.

            :
    DUK_ERROR_RANGE(thr, DUK_STR_INVALID_CALL_ARGS);
    return;  /* not reached */
 
 arg_error:
    DUK_ERROR_TYPE(thr, DUK_STR_INVALID_CALL_ARGS);
    return;  /* not reached */
}
 
DUK_EXTERNAL 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) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_idx_t ret;
    duk_hobject *proto;
#ifdef DUK_USE_AUGMENT_ERROR_CREATE
    duk_bool_t noblame_fileline;
#endif
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
    DUK_UNREF(filename);
    DUK_UNREF(line);
 
    /* Error code also packs a tracedata related flag. */
#ifdef DUK_USE_AUGMENT_ERROR_CREATE
    noblame_fileline = err_code & DUK_ERRCODE_FLAG_NOBLAME_FILELINE;
#endif
    err_code = err_code & (~DUK_ERRCODE_FLAG_NOBLAME_FILELINE);
 
    /* error gets its 'name' from the prototype */
    proto = duk_error_prototype_from_code(thr, err_code);
    ret = duk_push_object_helper_proto(ctx,
                                       DUK_HOBJECT_FLAG_EXTENSIBLE |
                                       DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ERROR),
                                       proto);
 
    /* ... and its 'message' from an instance property */
    if (fmt) {
        duk_push_vsprintf(ctx, fmt, ap);
        duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE, DUK_PROPDESC_FLAGS_WC);
    } else {
        /* If no explicit message given, put error code into message field
         * (as a number).  This is not fully in keeping with the Ecmascript
         * error model because messages are supposed to be strings (Error

◆ duk_push_false()

DUK_EXTERNAL_DECL void duk_push_false ( duk_context * ctx )

Definition at line 17897 of file duktape-1.5.2/src-noline/duktape.c.

                 : 0);  /* ensure value is 1 or 0 (not other non-zero) */
    tv_slot = thr->valstack_top++;
    DUK_TVAL_SET_BOOLEAN(tv_slot, b);
}
 
DUK_EXTERNAL void duk_push_true(duk_context *ctx) {
    duk_hthread *thr;
    duk_tval *tv_slot;
 

◆ duk_push_global_object()

DUK_EXTERNAL_DECL void duk_push_global_object ( duk_context * ctx )

Definition at line 18250 of file duktape-1.5.2/src-noline/duktape.c.

18254 {

◆ duk_push_global_stash()

DUK_EXTERNAL_DECL void duk_push_global_stash ( duk_context * ctx )

Definition at line 18279 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_push_heap_stash()

DUK_EXTERNAL_DECL void duk_push_heap_stash ( duk_context * ctx )

Definition at line 18269 of file duktape-1.5.2/src-noline/duktape.c.

                                                 {
    DUK_ASSERT_CTX_VALID(ctx);
    if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE)) {
        DUK_DDD(DUK_DDDPRINT("creating heap/global/thread stash on first use"));

◆ duk_push_heapptr()

DUK_EXTERNAL_DECL duk_idx_t duk_push_heapptr	(	duk_context *	ctx,
		void *	ptr )

Definition at line 19005 of file duktape-1.5.2/src-noline/duktape.c.

                                        {
        DUK_ERROR_RANGE(thr, DUK_STR_BUFFER_TOO_LONG);
    }
 
    h = duk_hbuffer_alloc(thr->heap, size, flags, &buf_data);
    if (!h) {
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
 
    tv_slot = thr->valstack_top;
    DUK_TVAL_SET_BUFFER(tv_slot, h);
    DUK_HBUFFER_INCREF(thr, h);
    thr->valstack_top++;
 
    return (void *) buf_data;
}
 
DUK_EXTERNAL duk_idx_t duk_push_heapptr(duk_context *ctx, void *ptr) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_idx_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
 
    if (ptr == NULL) {
        goto push_undefined;
    }
 
    switch ((int) DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) ptr)) {
    case DUK_HTYPE_STRING:

◆ duk_push_int()

DUK_EXTERNAL_DECL void duk_push_int	(	duk_context *	ctx,
		duk_int_t	val )

Definition at line 17923 of file duktape-1.5.2/src-noline/duktape.c.

                                                                      {
    duk_hthread *thr;
    duk_tval *tv_slot;
    duk_double_union du;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
    du.d = val;
    DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du);
    tv_slot = thr->valstack_top++;
    DUK_TVAL_SET_NUMBER(tv_slot, du.d);
}
 
DUK_EXTERNAL void duk_push_int(duk_context *ctx, duk_int_t val) {
#if defined(DUK_USE_FASTINT)
    duk_hthread *thr;
    duk_tval *tv_slot;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
    tv_slot = thr->valstack_top++;
#if DUK_INT_MAX <= 0x7fffffffL
    DUK_TVAL_SET_FASTINT_I32(tv_slot, (duk_int32_t) val);
#else
    if (val >= DUK_FASTINT_MIN && val <= DUK_FASTINT_MAX) {
        DUK_TVAL_SET_FASTINT(tv_slot, (duk_int64_t) val);
    } else {

◆ duk_push_lstring()

DUK_EXTERNAL_DECL const char * duk_push_lstring	(	duk_context *	ctx,
		const char *	str,
		duk_size_t	len )

Definition at line 18004 of file duktape-1.5.2/src-noline/duktape.c.

                                                 {
    duk_hthread *thr;
    duk_tval *tv_slot;
    duk_double_union du;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
    DUK_DBLUNION_SET_NAN(&du);
    DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du));
    tv_slot = thr->valstack_top++;
    DUK_TVAL_SET_NUMBER(tv_slot, du.d);
}
 
DUK_EXTERNAL const char *duk_push_lstring(duk_context *ctx, const char *str, duk_size_t len) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hstring *h;
    duk_tval *tv_slot;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* check stack before interning (avoid hanging temp) */
    if (thr->valstack_top >= thr->valstack_end) {
        DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
    }
 
    /* NULL with zero length represents an empty string; NULL with higher
     * length is also now trated like an empty string although it is
     * a bit dubious.  This is unlike duk_push_string() which pushes a
     * 'null' if the input string is a NULL.
     */
    if (!str) {

◆ duk_push_nan()

DUK_EXTERNAL_DECL void duk_push_nan ( duk_context * ctx )

Definition at line 17990 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_push_null()

DUK_EXTERNAL_DECL void duk_push_null ( duk_context * ctx )

Definition at line 17862 of file duktape-1.5.2/src-noline/duktape.c.

                                                       {
    duk_hthread *thr;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
 

◆ duk_push_number()

DUK_EXTERNAL_DECL void duk_push_number	(	duk_context *	ctx,
		duk_double_t	val )

Definition at line 17909 of file duktape-1.5.2/src-noline/duktape.c.

                                                   {
    duk_hthread *thr;
    duk_tval *tv_slot;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
    tv_slot = thr->valstack_top++;

◆ duk_push_object()

DUK_EXTERNAL_DECL duk_idx_t duk_push_object ( duk_context * ctx )

Definition at line 18449 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                                              {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_idx_t ret;
    duk_hobject *h;
 
    DUK_ASSERT_CTX_VALID(ctx);

◆ duk_push_pointer()

DUK_EXTERNAL_DECL void duk_push_pointer	(	duk_context *	ctx,
		void *	p )

Definition at line 18121 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                        {
    duk_hthread *thr = (duk_hthread *) ctx;
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(path);
 
    if (flags != 0) {
        DUK_ASSERT(flags == DUK_STRING_PUSH_SAFE);  /* only flag now */
        duk_push_undefined(ctx);
    } else {

◆ duk_push_sprintf()

DUK_EXTERNAL_DECL const char * duk_push_sprintf	(	duk_context *	ctx,
		const char *	fmt,
			... )

Definition at line 18380 of file duktape-1.5.2/src-noline/duktape.c.

                                                 {
            DUK_ERROR_API(thr, DUK_STR_SPRINTF_TOO_LONG);
        }
    }
 
    /* Cannot use duk_to_string() on the buffer because it is usually
     * larger than 'len'.  Also, 'buf' is usually a stack buffer.
     */
    res = duk_push_lstring(ctx, (const char *) buf, (duk_size_t) len);  /* [ buf? res ] */
    if (pushed_buf) {
        duk_remove(ctx, -2);

◆ duk_push_string()

DUK_EXTERNAL_DECL const char * duk_push_string	(	duk_context *	ctx,
		const char *	str )

Definition at line 18040 of file duktape-1.5.2/src-noline/duktape.c.

                                       {
        DUK_ERROR_RANGE(thr, DUK_STR_STRING_TOO_LONG);
    }
 
    h = duk_heap_string_intern_checked(thr, (const duk_uint8_t *) str, (duk_uint32_t) len);
    DUK_ASSERT(h != NULL);
 

◆ duk_push_string_file_raw()

DUK_EXTERNAL_DECL const char * duk_push_string_file_raw	(	duk_context *	ctx,
		const char *	path,
		duk_uint_t	flags )

Definition at line 18056 of file duktape-1.5.2/src-noline/duktape.c.

                                                                            {
    DUK_ASSERT_CTX_VALID(ctx);
 
    if (str) {
        return duk_push_lstring(ctx, str, DUK_STRLEN(str));
    } else {
        duk_push_null(ctx);
        return NULL;
    }
}
 
#ifdef DUK_USE_FILE_IO
/* This is a bit clunky because it is ANSI C portable.  Should perhaps
 * relocate to another file because this is potentially platform
 * dependent.
 */
DUK_EXTERNAL const char *duk_push_string_file_raw(duk_context *ctx, const char *path, duk_uint_t flags) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_file *f = NULL;
    char *buf;
    long sz;  /* ANSI C typing */
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    if (!path) {
        goto fail;
    }
    f = DUK_FOPEN(path, "rb");
    if (!f) {
        goto fail;
    }
    if (DUK_FSEEK(f, 0, SEEK_END) < 0) {
        goto fail;
    }
    sz = DUK_FTELL(f);
    if (sz < 0) {
        goto fail;
    }
    if (DUK_FSEEK(f, 0, SEEK_SET) < 0) {
        goto fail;
    }
    buf = (char *) duk_push_fixed_buffer(ctx, (duk_size_t) sz);
    DUK_ASSERT(buf != NULL);
    if ((duk_size_t) DUK_FREAD(buf, 1, (size_t) sz, f) != (duk_size_t) sz) {
        goto fail;
    }
    (void) DUK_FCLOSE(f);  /* ignore fclose() error */

◆ duk_push_this()

DUK_EXTERNAL_DECL void duk_push_this ( duk_context * ctx )

Definition at line 18171 of file duktape-1.5.2/src-noline/duktape.c.

18174 {

18175 /* XXX: better macro for DUK_TVAL_IS_UNDEFINED_OR_NULL(tv) */

◆ duk_push_thread_raw()

DUK_EXTERNAL_DECL duk_idx_t duk_push_thread_raw	(	duk_context *	ctx,
		duk_uint_t	flags )

Definition at line 18496 of file duktape-1.5.2/src-noline/duktape.c.

                                                                               {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hthread *obj;
    duk_idx_t ret;
    duk_tval *tv_slot;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* check stack first */
    if (thr->valstack_top >= thr->valstack_end) {
        DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
    }
 
    obj = duk_hthread_alloc(thr->heap,
                            DUK_HOBJECT_FLAG_EXTENSIBLE |
                            DUK_HOBJECT_FLAG_THREAD |
                            DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_THREAD));
    if (!obj) {
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
    obj->state = DUK_HTHREAD_STATE_INACTIVE;
#if defined(DUK_USE_ROM_STRINGS)
    /* Nothing to initialize, strs[] is in ROM. */
#else
#if defined(DUK_USE_HEAPPTR16)
    obj->strs16 = thr->strs16;
#else
    obj->strs = thr->strs;
#endif
#endif
    DUK_DDD(DUK_DDDPRINT("created thread object with flags: 0x%08lx", (unsigned long) obj->obj.hdr.h_flags));
 
    /* make the new thread reachable */
    tv_slot = thr->valstack_top;
    DUK_TVAL_SET_OBJECT(tv_slot, (duk_hobject *) obj);
    DUK_HTHREAD_INCREF(thr, obj);
    ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
    thr->valstack_top++;
 
    /* important to do this *after* pushing, to make the thread reachable for gc */
    if (!duk_hthread_init_stacks(thr->heap, obj)) {
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
 
    /* initialize built-ins - either by copying or creating new ones */

◆ duk_push_thread_stash()

DUK_EXTERNAL_DECL void duk_push_thread_stash	(	duk_context *	ctx,
		duk_context *	target_ctx )

Definition at line 18285 of file duktape-1.5.2/src-noline/duktape.c.

                                                        {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_heap *heap;
    DUK_ASSERT_CTX_VALID(ctx);
    heap = thr->heap;
    DUK_ASSERT(heap->heap_object != NULL);
    duk_push_hobject(ctx, heap->heap_object);
    duk__push_stash(ctx);
}

◆ duk_push_true()

DUK_EXTERNAL_DECL void duk_push_true ( duk_context * ctx )

Definition at line 17886 of file duktape-1.5.2/src-noline/duktape.c.

                                                                     {
    duk_hthread *thr;
    duk_tval *tv_slot;
    duk_small_int_t b;
 
    DUK_ASSERT_CTX_VALID(ctx);

◆ duk_push_uint()

DUK_EXTERNAL_DECL void duk_push_uint	(	duk_context *	ctx,
		duk_uint_t	val )

Definition at line 17956 of file duktape-1.5.2/src-noline/duktape.c.

                                                                  {
#if defined(DUK_USE_FASTINT)
    duk_hthread *thr;
    duk_tval *tv_slot;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
    tv_slot = thr->valstack_top++;
#if DUK_UINT_MAX <= 0xffffffffUL
    DUK_TVAL_SET_FASTINT_U32(tv_slot, (duk_uint32_t) val);
#else
    if (val <= DUK_FASTINT_MAX) {  /* val is unsigned so >= 0 */
        /* XXX: take advantage of val being unsigned, no need to mask */
        DUK_TVAL_SET_FASTINT(tv_slot, (duk_int64_t) val);
    } else {

◆ duk_push_undefined()

DUK_EXTERNAL_DECL void duk_push_undefined ( duk_context * ctx )

Definition at line 17848 of file duktape-1.5.2/src-noline/duktape.c.

                                                                {
    duk_hthread *thr;
    duk_tval *tv_slot;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(tv != NULL);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
    tv_slot = thr->valstack_top++;

◆ duk_push_vsprintf()

DUK_EXTERNAL_DECL const char * duk_push_vsprintf	(	duk_context *	ctx,
		const char *	fmt,
		va_list	ap )

Definition at line 18314 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                                    {
    duk_int_t len;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(ctx);
 
    /* NUL terminator handling doesn't matter here */
    len = DUK_VSNPRINTF((char *) buf, sz, fmt, ap);
    if (len < (duk_int_t) sz) {
        /* Return value of 'sz' or more indicates output was (potentially)
         * truncated.
         */
        return (duk_int_t) len;
    }
    return -1;
}
 
DUK_EXTERNAL const char *duk_push_vsprintf(duk_context *ctx, const char *fmt, va_list ap) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_uint8_t stack_buf[DUK_PUSH_SPRINTF_INITIAL_SIZE];
    duk_size_t sz = DUK_PUSH_SPRINTF_INITIAL_SIZE;
    duk_bool_t pushed_buf = 0;
    void *buf;
    duk_int_t len;  /* XXX: duk_ssize_t */
    const char *res;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* special handling of fmt==NULL */
    if (!fmt) {
        duk_hstring *h_str;
        duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING);
        h_str = DUK_HTHREAD_STRING_EMPTY_STRING(thr);  /* rely on interning, must be this string */
        return (const char *) DUK_HSTRING_GET_DATA(h_str);
    }
 
    /* initial estimate based on format string */
    sz = DUK_STRLEN(fmt) + 16;  /* format plus something to avoid just missing */
    if (sz < DUK_PUSH_SPRINTF_INITIAL_SIZE) {
        sz = DUK_PUSH_SPRINTF_INITIAL_SIZE;
    }
    DUK_ASSERT(sz > 0);
 
    /* Try to make do with a stack buffer to avoid allocating a temporary buffer.
     * This works 99% of the time which is quite nice.
     */
    for (;;) {
        va_list ap_copy;  /* copied so that 'ap' can be reused */
 
        if (sz <= sizeof(stack_buf)) {
            buf = stack_buf;
        } else if (!pushed_buf) {
            pushed_buf = 1;
            buf = duk_push_dynamic_buffer(ctx, sz);
        } else {
            buf = duk_resize_buffer(ctx, -1, sz);
        }
        DUK_ASSERT(buf != NULL);
 
        DUK_VA_COPY(ap_copy, ap);
        len = duk__try_push_vsprintf(ctx, buf, sz, fmt, ap_copy);
        va_end(ap_copy);
        if (len >= 0) {
            break;
        }

◆ duk_put_function_list()

DUK_EXTERNAL_DECL void duk_put_function_list	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		const duk_function_list_entry *	funcs )

Definition at line 14739 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                               {
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk_require_hobject(ctx, enum_index);
    duk_dup(ctx, enum_index);
    return duk_hobject_enumerator_next(ctx, get_value);
}
 
/*

◆ duk_put_global_string()

DUK_EXTERNAL_DECL duk_bool_t duk_put_global_string	(	duk_context *	ctx,
		const char *	key )

Definition at line 14788 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                 {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_bool_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL] != NULL);
 
    /* XXX: direct implementation */
 
    duk_push_hobject(ctx, thr->builtins[DUK_BIDX_GLOBAL]);
    ret = duk_get_prop_string(ctx, -1, key);
    duk_remove(ctx, -2);
    return ret;

◆ duk_put_number_list()

DUK_EXTERNAL_DECL void duk_put_number_list	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		const duk_number_list_entry *	numbers )

Definition at line 14754 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                                     {
    const duk_function_list_entry *ent = funcs;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    obj_index = duk_require_normalize_index(ctx, obj_index);
    if (ent != NULL) {
        while (ent->key != NULL) {
            duk_push_c_function(ctx, ent->value, ent->nargs);
            duk_put_prop_string(ctx, obj_index, ent->key);
            ent++;
        }

◆ duk_put_prop()

DUK_EXTERNAL_DECL duk_bool_t duk_put_prop	(	duk_context *	ctx,
		duk_idx_t	obj_index )

Definition at line 14378 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_put_prop_index()

DUK_EXTERNAL_DECL duk_bool_t duk_put_prop_index	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		duk_uarridx_t	arr_index )

Definition at line 14396 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                  {
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(key != NULL);

◆ duk_put_prop_string()

DUK_EXTERNAL_DECL duk_bool_t duk_put_prop_string	(	duk_context *	ctx,
		duk_idx_t	obj_index,
		const char *	key )

Definition at line 14383 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_put_var()

DUK_EXTERNAL_DECL void duk_put_var ( duk_context * ctx )

Definition at line 19902 of file duktape-1.5.2/src-noline/duktape.c.

                                                {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_activation *act;
    duk_hstring *h_varname;
    duk_tval *tv_val;
    duk_small_int_t throw_flag;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    h_varname = duk_require_hstring(ctx, -2);  /* XXX: tostring? */
    DUK_ASSERT(h_varname != NULL);
 
    tv_val = duk_require_tval(ctx, -1);
 
    throw_flag = duk_is_strict_call(ctx);
 

◆ duk_realloc()

DUK_EXTERNAL_DECL void * duk_realloc	(	duk_context *	ctx,
		void *	ptr,
		duk_size_t	size )

Definition at line 14207 of file duktape-1.5.2/src-noline/duktape.c.

                                                                {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    return DUK_ALLOC(thr->heap, size);
}
 
DUK_EXTERNAL void duk_free(duk_context *ctx, void *ptr) {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    DUK_FREE(thr->heap, ptr);
}
 

◆ duk_realloc_raw()

DUK_EXTERNAL_DECL void * duk_realloc_raw	(	duk_context *	ctx,
		void *	ptr,
		duk_size_t	size )

Definition at line 14183 of file duktape-1.5.2/src-noline/duktape.c.

                                                                    {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    return DUK_ALLOC_RAW(thr->heap, size);

◆ duk_remove()

DUK_EXTERNAL_DECL void duk_remove	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15820 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                       {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv1;
    duk_tval *tv2;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(thr);  /* w/o refcounting */
 
    tv1 = duk_require_tval(ctx, from_index);
    DUK_ASSERT(tv1 != NULL);
    tv2 = duk_require_tval(ctx, to_index);
    DUK_ASSERT(tv2 != NULL);
 
    /* For tv1 == tv2, this is a no-op (no explicit check needed). */
    DUK_TVAL_SET_TVAL_UPDREF(thr, tv2, tv1);  /* side effects */
}
 
DUK_EXTERNAL void duk_remove(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *p;
    duk_tval *q;
#ifdef DUK_USE_REFERENCE_COUNTING
    duk_tval tv_tmp;
#endif
    duk_size_t nbytes;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    p = duk_require_tval(ctx, index);
    DUK_ASSERT(p != NULL);
    q = duk_require_tval(ctx, -1);
    DUK_ASSERT(q != NULL);
 
    DUK_ASSERT(q >= p);
 
    /*              nbytes            zero size case
     *           <--------->
     *    [ ... | p | x | x | q ]     [ ... | p==q ]
     * => [ ... | x | x | q ]         [ ... ]

◆ duk_replace()

DUK_EXTERNAL_DECL void duk_replace	(	duk_context *	ctx,
		duk_idx_t	to_index )

Definition at line 15780 of file duktape-1.5.2/src-noline/duktape.c.

                                    : to_index=%ld, p=%p, q=%p, nbytes=%lu",
                         (long) to_index, (void *) p, (void *) q, (unsigned long) nbytes));
 
    /* No net refcount changes. */
 
    if (nbytes > 0) {
        DUK_TVAL_SET_TVAL(&tv_tmp, q);
        DUK_ASSERT(nbytes > 0);
        DUK_MEMMOVE((void *) (p + 1), (const void *) p, (size_t) nbytes);
        DUK_TVAL_SET_TVAL(p, &tv_tmp);
    } else {
        /* nop: insert top to top */
        DUK_ASSERT(nbytes == 0);
        DUK_ASSERT(p == q);
    }
}
 
DUK_EXTERNAL void duk_replace(duk_context *ctx, duk_idx_t to_index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv1;
    duk_tval *tv2;
    duk_tval tv_tmp;

◆ duk_require_boolean()

DUK_EXTERNAL_DECL duk_bool_t duk_require_boolean	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15980 of file duktape-1.5.2/src-noline/duktape.c.

                                                                           {
    duk_bool_t ret = 0;  /* default: false */
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_BOOLEAN(tv)) {
        ret = DUK_TVAL_GET_BOOLEAN(tv);
    }
 
    DUK_ASSERT(ret == 0 || ret == 1);
    return ret;

◆ duk_require_buffer()

DUK_EXTERNAL_DECL void * duk_require_buffer	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_size )

Definition at line 16201 of file duktape-1.5.2/src-noline/duktape.c.

16202 {

16203 *out_size = DUK_HBUFFER_GET_SIZE(h);

◆ duk_require_buffer_data()

DUK_EXTERNAL_DECL void * duk_require_buffer_data	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_size )

Definition at line 16263 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_require_c_function()

DUK_EXTERNAL_DECL duk_c_function duk_require_c_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16404 of file duktape-1.5.2/src-noline/duktape.c.

                                 {
        return NULL;
    }
    h = DUK_TVAL_GET_OBJECT(tv);
    DUK_ASSERT(h != NULL);
 
    if (!DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
        return NULL;
    }
    DUK_ASSERT(DUK_HOBJECT_HAS_NATIVEFUNCTION(h));

◆ duk_require_context()

DUK_EXTERNAL_DECL duk_context * duk_require_context	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16429 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_require_function()

DUK_EXTERNAL_DECL void duk_require_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16417 of file duktape-1.5.2/src-noline/duktape.c.

16421 {

◆ duk_require_heapptr()

DUK_EXTERNAL_DECL void * duk_require_heapptr	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16451 of file duktape-1.5.2/src-noline/duktape.c.

                                                                      {
    duk_tval *tv;
    void *ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
        ret = (void *) DUK_TVAL_GET_HEAPHDR(tv);
        DUK_ASSERT(ret != NULL);
        return ret;
    }
 
    return (void *) NULL;
}
 
DUK_EXTERNAL void *duk_require_heapptr(duk_context *ctx, duk_idx_t index) {

◆ duk_require_int()

DUK_EXTERNAL_DECL duk_int_t duk_require_int	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16052 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_require_lstring()

DUK_EXTERNAL_DECL const char * duk_require_lstring	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_len )

Definition at line 16092 of file duktape-1.5.2/src-noline/duktape.c.

                                      {
        /* Here we rely on duk_hstring instances always being zero
         * terminated even if the actual string is not.
         */
        duk_hstring *h = DUK_TVAL_GET_STRING(tv);
        DUK_ASSERT(h != NULL);
        ret = (const char *) DUK_HSTRING_GET_DATA(h);
        if (out_len) {
            *out_len = DUK_HSTRING_GET_BYTELEN(h);
        }
    }
 
    return ret;
}

◆ duk_require_normalize_index()

DUK_EXTERNAL_DECL duk_idx_t duk_require_normalize_index	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15092 of file duktape-1.5.2/src-noline/duktape.c.

                   {
        uindex = vs_size + (duk_uidx_t) index;
    } else {
        /* since index non-negative */
        DUK_ASSERT(index != DUK_INVALID_INDEX);
        uindex = (duk_uidx_t) index;
    }
 
    /* DUK_INVALID_INDEX won't be accepted as a valid index. */
    DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_size);
 
    if (DUK_LIKELY(uindex < vs_size)) {
        return (duk_idx_t) uindex;
    }
    return DUK_INVALID_INDEX;
}
 
DUK_EXTERNAL duk_idx_t duk_require_normalize_index(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_uidx_t vs_size;
    duk_uidx_t uindex;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(DUK_INVALID_INDEX < 0);
 
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    vs_size = (duk_uidx_t) (thr->valstack_top - thr->valstack_bottom);
    DUK_ASSERT_DISABLE(vs_size >= 0);  /* unsigned */

◆ duk_require_null()

DUK_EXTERNAL_DECL void duk_require_null	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15951 of file duktape-1.5.2/src-noline/duktape.c.

                                                                           {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_UNDEFINED(tv)) {
        return;
    }

◆ duk_require_number()

DUK_EXTERNAL_DECL duk_double_t duk_require_number	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16017 of file duktape-1.5.2/src-noline/duktape.c.

                                      {
        ret.d = DUK_TVAL_GET_NUMBER(tv);
    }
 
    /*
     *  Number should already be in NaN-normalized form, but let's
     *  normalize anyway.
     */
 
    DUK_DBLUNION_NORMALIZE_NAN_CHECK(&ret);
    return ret.d;
}
 
DUK_EXTERNAL duk_double_t duk_require_number(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);

◆ duk_require_pointer()

DUK_EXTERNAL_DECL void * duk_require_pointer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16135 of file duktape-1.5.2/src-noline/duktape.c.

                                                                      {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_POINTER(tv)) {
        void *p = DUK_TVAL_GET_POINTER(tv);  /* may be NULL */
        return (void *) p;
    }
 
    return NULL;
}
 

◆ duk_require_stack()

DUK_EXTERNAL_DECL void duk_require_stack	(	duk_context *	ctx,
		duk_idx_t	extra )

Definition at line 15612 of file duktape-1.5.2/src-noline/duktape.c.

                                 {
        /* Clamping to zero makes the API more robust to calling code
         * calculation errors.
         */
        extra = 0;
    }
 
    min_new_size = (thr->valstack_top - thr->valstack) + extra + DUK_VALSTACK_INTERNAL_EXTRA;
    return duk_valstack_resize_raw(ctx,
                                   min_new_size,         /* min_new_size */
                                   0 /* no shrink */ |   /* flags */
                                   0 /* no compact */ |
                                   0 /* no throw */);
}
 
DUK_EXTERNAL void duk_require_stack(duk_context *ctx, duk_idx_t extra) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_size_t min_new_size;
 

◆ duk_require_stack_top()

DUK_EXTERNAL_DECL void duk_require_stack_top	(	duk_context *	ctx,
		duk_idx_t	top )

Definition at line 15654 of file duktape-1.5.2/src-noline/duktape.c.

                               {
        /* Clamping to zero makes the API more robust to calling code
         * calculation errors.
         */
        top = 0;
    }
 
    min_new_size = top + DUK_VALSTACK_INTERNAL_EXTRA;
    return duk_valstack_resize_raw(ctx,
                                   min_new_size,  /* min_new_size */
                                   0 /* no shrink */ |   /* flags */
                                   0 /* no compact */ |
                                   0 /* no throw */);
}
 
DUK_EXTERNAL void duk_require_stack_top(duk_context *ctx, duk_idx_t top) {
    duk_size_t min_new_size;

◆ duk_require_string()

DUK_EXTERNAL_DECL const char * duk_require_string	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16115 of file duktape-1.5.2/src-noline/duktape.c.

16119 {

◆ duk_require_top_index()

DUK_EXTERNAL_DECL duk_idx_t duk_require_top_index ( duk_context * ctx )

Definition at line 15324 of file duktape-1.5.2/src-noline/duktape.c.

                                                           {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_idx_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    ret = ((duk_idx_t) (thr->valstack_top - thr->valstack_bottom)) - 1;
    if (DUK_UNLIKELY(ret < 0)) {
        /* Return invalid index; if caller uses this without checking
         * in another API call, the index won't map to a valid stack
         * entry.
         */
        return DUK_INVALID_INDEX;

◆ duk_require_uint()

DUK_EXTERNAL_DECL duk_uint_t duk_require_uint	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16058 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_require_undefined()

DUK_EXTERNAL_DECL void duk_require_undefined	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15937 of file duktape-1.5.2/src-noline/duktape.c.

                      {
            p--;
            DUK_TVAL_SET_UNDEFINED(p);
            /* XXX: fast primitive to set a bunch of values to UNDEFINED */
        }
    }
}
 

◆ duk_require_valid_index()

DUK_EXTERNAL_DECL void duk_require_valid_index	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15188 of file duktape-1.5.2/src-noline/duktape.c.

                                      {
        return thr->valstack_bottom + uindex;
    }
    DUK_ERROR_API_INDEX(thr, index);
    return NULL;
}
 
/* Non-critical. */
DUK_EXTERNAL duk_bool_t duk_is_valid_index(duk_context *ctx, duk_idx_t index) {
    DUK_ASSERT_CTX_VALID(ctx);

◆ duk_resize_buffer()

DUK_EXTERNAL_DECL void * duk_resize_buffer	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t	new_size )

Definition at line 11531 of file duktape-1.5.2/src-noline/duktape.c.

                                                  : %p %lu -> %p",
                         (void *) ptr, (unsigned long) newsize, (void *) res));
    return res;
}
 
DUK_INTERNAL void duk_default_free_function(void *udata, void *ptr) {
    DUK_DDD(DUK_DDDPRINT("default free function: %p", (void *) ptr));
    DUK_UNREF(udata);
    DUK_ANSI_FREE(ptr);
}
#endif  /* DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS */
/*
 *  Buffer
 */
 
/* include removed: duk_internal.h */
 
DUK_EXTERNAL void *duk_resize_buffer(duk_context *ctx, duk_idx_t index, duk_size_t new_size) {

◆ duk_safe_call()

DUK_EXTERNAL_DECL duk_int_t duk_safe_call	(	duk_context *	ctx,
		duk_safe_call_function	func,
		duk_idx_t	nargs,
		duk_idx_t	nrets )

Definition at line 12528 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                                      {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_int_t rc;

◆ duk_safe_to_lstring()

DUK_EXTERNAL_DECL const char * duk_safe_to_lstring	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_len )

Definition at line 16929 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                {
    DUK_ASSERT_CTX_VALID(ctx);
 
    (void) duk_to_string(ctx, index);
    return duk_require_lstring(ctx, index, out_len);
}
 
DUK_LOCAL duk_ret_t duk__safe_to_string_raw(duk_context *ctx) {
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk_to_string(ctx, -1);
    return 1;
}
 
DUK_EXTERNAL const char *duk_safe_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len) {
    DUK_ASSERT_CTX_VALID(ctx);
 
    index = duk_require_normalize_index(ctx, index);
 
    /* We intentionally ignore the duk_safe_call() return value and only
     * check the output type.  This way we don't also need to check that
     * the returned value is indeed a string in the success case.
     */
 
    duk_dup(ctx, index);
    (void) duk_safe_call(ctx, duk__safe_to_string_raw, 1 /*nargs*/, 1 /*nrets*/);
    if (!duk_is_string(ctx, -1)) {
        /* Error: try coercing error to string once. */

◆ duk_set_finalizer()

DUK_EXTERNAL_DECL void duk_set_finalizer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 14869 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_set_global_object()

DUK_EXTERNAL_DECL void duk_set_global_object ( duk_context * ctx )

Definition at line 14047 of file duktape-1.5.2/src-noline/duktape.c.

                                                     {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_heap *heap;
 
    if (!ctx) {
        return;
    }
    heap = thr->heap;
    DUK_ASSERT(heap != NULL);
 
    duk_heap_free(heap);
}
 
/* XXX: better place for this */
DUK_EXTERNAL void duk_set_global_object(duk_context *ctx) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h_glob;
    duk_hobject *h_prev_glob;
    duk_hobject *h_env;
    duk_hobject *h_prev_env;
 
    DUK_D(DUK_DPRINT("replace global object with: %!T", duk_get_tval(ctx, -1)));
 
    h_glob = duk_require_hobject(ctx, -1);
    DUK_ASSERT(h_glob != NULL);
 
    /*
     *  Replace global object.
     */
 
    h_prev_glob = thr->builtins[DUK_BIDX_GLOBAL];
    DUK_UNREF(h_prev_glob);
    thr->builtins[DUK_BIDX_GLOBAL] = h_glob;
    DUK_HOBJECT_INCREF(thr, h_glob);
    DUK_HOBJECT_DECREF_ALLOWNULL(thr, h_prev_glob);  /* side effects, in theory (referenced by global env) */
 
    /*
     *  Replace lexical environment for global scope
     *
     *  Create a new object environment for the global lexical scope.
     *  We can't just reset the _Target property of the current one,
     *  because the lexical scope is shared by other threads with the
     *  same (initial) built-ins.
     */
 
    (void) duk_push_object_helper(ctx,
                                  DUK_HOBJECT_FLAG_EXTENSIBLE |
                                  DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJENV),
                                  -1);  /* no prototype, updated below */
 
    duk_dup(ctx, -2);
    duk_dup(ctx, -3);
 
    /* [ ... new_glob new_env new_glob new_glob ] */
 
    duk_xdef_prop_stridx(thr, -3, DUK_STRIDX_INT_TARGET, DUK_PROPDESC_FLAGS_NONE);
    duk_xdef_prop_stridx(thr, -2, DUK_STRIDX_INT_THIS, DUK_PROPDESC_FLAGS_NONE);
 
    /* [ ... new_glob new_env ] */

◆ duk_set_magic()

DUK_EXTERNAL_DECL void duk_set_magic	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_int_t	magic )

Definition at line 12871 of file duktape-1.5.2/src-noline/duktape.c.

                                                {
            goto type_error;
        }
        return (duk_int_t) ((duk_hnativefunction *) h)->magic;
    } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
        duk_small_uint_t lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv);
        return (duk_int_t) DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags);

◆ duk_set_prototype()

DUK_EXTERNAL_DECL void duk_set_prototype	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 14828 of file duktape-1.5.2/src-noline/duktape.c.

               {
        duk_push_hobject(ctx, proto);
    } else {
        duk_push_undefined(ctx);
    }
}
 
DUK_EXTERNAL void duk_set_prototype(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *obj;
    duk_hobject *proto;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    obj = duk_require_hobject(ctx, index);

◆ duk_set_top()

DUK_EXTERNAL_DECL void duk_set_top	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15216 of file duktape-1.5.2/src-noline/duktape.c.

                                                     {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    return (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
}
 
/* Set stack top within currently allocated range, but don't reallocate.
 * This is performance critical especially for call handling, so whenever
 * changing, profile and look at generated code.
 */
DUK_EXTERNAL void duk_set_top(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_uidx_t vs_size;
    duk_uidx_t vs_limit;
    duk_uidx_t uindex;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(DUK_INVALID_INDEX < 0);
 
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    DUK_ASSERT(thr->valstack_end >= thr->valstack_bottom);
    vs_size = (duk_uidx_t) (thr->valstack_top - thr->valstack_bottom);
    vs_limit = (duk_uidx_t) (thr->valstack_end - thr->valstack_bottom);
 
    if (index < 0) {
        /* Negative indices are always within allocated stack but
         * must not go below zero index.
         */
        uindex = vs_size + (duk_uidx_t) index;
    } else {
        /* Positive index can be higher than valstack top but must
         * not go above allocated stack (equality is OK).
         */
        uindex = (duk_uidx_t) index;
    }
 
    /* DUK_INVALID_INDEX won't be accepted as a valid index. */
    DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_size);
    DUK_ASSERT(vs_size + (duk_uidx_t) DUK_INVALID_INDEX >= vs_limit);
 
#if defined(DUK_USE_VALSTACK_UNSAFE)
    DUK_ASSERT(uindex <= vs_limit);
    DUK_UNREF(vs_limit);
#else
    if (DUK_UNLIKELY(uindex > vs_limit)) {
        DUK_ERROR_API_INDEX(thr, index);
        return;  /* unreachable */
    }
#endif
    DUK_ASSERT(uindex <= vs_limit);
 
    /* Handle change in value stack top.  Respect value stack
     * initialization policy: 'undefined' above top.  Note that
     * DECREF may cause a side effect that reallocates valstack,
     * so must relookup after DECREF.
     */
 
    if (uindex >= vs_size) {
        /* Stack size increases or stays the same. */
#if defined(DUK_USE_ASSERTIONS)
        duk_uidx_t count;
 
        count = uindex - vs_size;
        while (count != 0) {
            count--;
            tv = thr->valstack_top + count;
            DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(tv));
        }
#endif
        thr->valstack_top = thr->valstack_bottom + uindex;
    } else {
        /* Stack size decreases. */
#if defined(DUK_USE_REFERENCE_COUNTING)
        duk_uidx_t count;
 
        count = vs_size - uindex;
        DUK_ASSERT(count > 0);
        while (count > 0) {
            count--;
            tv = --thr->valstack_top;  /* tv -> value just before prev top value; must relookup */
            DUK_ASSERT(tv >= thr->valstack_bottom);
            DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv);  /* side effects */

◆ duk_steal_buffer()

DUK_EXTERNAL_DECL void * duk_steal_buffer	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_size )

Definition at line 11550 of file duktape-1.5.2/src-noline/duktape.c.

                                                                       {
        DUK_ERROR_TYPE(thr, DUK_STR_WRONG_BUFFER_TYPE);
    }
 
    /* maximum size check is handled by callee */
    duk_hbuffer_resize(thr, h, new_size);
 
    return DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h);
}
 
DUK_EXTERNAL void *duk_steal_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hbuffer_dynamic *h;
    void *ptr;
    duk_size_t sz;
 
    DUK_ASSERT(ctx != NULL);
 
    h = (duk_hbuffer_dynamic *) duk_require_hbuffer(ctx, index);
    DUK_ASSERT(h != NULL);
 
    if (!(DUK_HBUFFER_HAS_DYNAMIC(h) && !DUK_HBUFFER_HAS_EXTERNAL(h))) {
        DUK_ERROR_TYPE(thr, DUK_STR_WRONG_BUFFER_TYPE);

◆ duk_strict_equals()

DUK_EXTERNAL_DECL duk_bool_t duk_strict_equals	(	duk_context *	ctx,
		duk_idx_t	index1,
		duk_idx_t	index2 )

Definition at line 19300 of file duktape-1.5.2/src-noline/duktape.c.

                                        {
        return 0;
    }
 
    /* Coercion may be needed, the helper handles that by pushing the
     * tagged values to the stack.
     */

◆ duk_substring()

DUK_EXTERNAL_DECL void duk_substring	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t	start_char_offset,
		duk_size_t	end_char_offset )

Definition at line 19721 of file duktape-1.5.2/src-noline/duktape.c.

                        {
            break;
        }
        cp = (int) duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end);
        cp = callback(udata, cp);
 
        DUK_BW_WRITE_ENSURE_XUTF8(thr, bw, cp);
    }
 
    DUK_BW_COMPACT(thr, bw);
    duk_to_string(ctx, -1);
    duk_replace(ctx, index);
}
 
DUK_EXTERNAL void duk_substring(duk_context *ctx, duk_idx_t index, duk_size_t start_offset, duk_size_t end_offset) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hstring *h;
    duk_hstring *res;
    duk_size_t start_byte_offset;
    duk_size_t end_byte_offset;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    index = duk_require_normalize_index(ctx, index);
    h = duk_require_hstring(ctx, index);
    DUK_ASSERT(h != NULL);
 
    if (end_offset >= DUK_HSTRING_GET_CHARLEN(h)) {
        end_offset = DUK_HSTRING_GET_CHARLEN(h);
    }
    if (start_offset > end_offset) {
        start_offset = end_offset;
    }
 
    DUK_ASSERT_DISABLE(start_offset >= 0);
    DUK_ASSERT(start_offset <= end_offset && start_offset <= DUK_HSTRING_GET_CHARLEN(h));
    DUK_ASSERT_DISABLE(end_offset >= 0);
    DUK_ASSERT(end_offset >= start_offset && end_offset <= DUK_HSTRING_GET_CHARLEN(h));
 
    /* guaranteed by string limits */

◆ duk_swap()

DUK_EXTERNAL_DECL void duk_swap	(	duk_context *	ctx,
		duk_idx_t	index1,
		duk_idx_t	index2 )

Definition at line 15678 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_swap_top()

DUK_EXTERNAL_DECL void duk_swap_top	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 15696 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_to_boolean()

DUK_EXTERNAL_DECL duk_bool_t duk_to_boolean	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16744 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                      {
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(hint == DUK_HINT_NONE || hint == DUK_HINT_NUMBER || hint == DUK_HINT_STRING);
 
    index = duk_require_normalize_index(ctx, index);
 
    if (!duk_check_type_mask(ctx, index, DUK_TYPE_MASK_OBJECT |
                                         DUK_TYPE_MASK_LIGHTFUNC)) {
        /* everything except object stay as is */
        return;
    }
    duk_to_defaultvalue(ctx, index, hint);
}
 
/* E5 Section 9.2 */
DUK_EXTERNAL duk_bool_t duk_to_boolean(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    duk_bool_t val;

◆ duk_to_buffer_raw()

DUK_EXTERNAL_DECL void * duk_to_buffer_raw	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_size,
		duk_uint_t	flags )

Definition at line 17186 of file duktape-1.5.2/src-noline/duktape.c.

             :
    return duk_require_string(ctx, index);
}
 
DUK_INTERNAL duk_hstring *duk_to_hstring(duk_context *ctx, duk_idx_t index) {
    duk_hstring *ret;
    DUK_ASSERT_CTX_VALID(ctx);
    duk_to_string(ctx, index);
    ret = duk_get_hstring(ctx, index);
    DUK_ASSERT(ret != NULL);
    return ret;
}
 
DUK_EXTERNAL void *duk_to_buffer_raw(duk_context *ctx, duk_idx_t index, duk_size_t *out_size, duk_uint_t mode) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hbuffer *h_buf;
    const duk_uint8_t *src_data;
    duk_size_t src_size;
    duk_uint8_t *dst_data;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(thr);
 
    index = duk_require_normalize_index(ctx, index);
 
    h_buf = duk_get_hbuffer(ctx, index);
    if (h_buf != NULL) {
        /* Buffer is kept as is, with the fixed/dynamic nature of the
         * buffer only changed if requested.  An external buffer
         * is converted into a non-external dynamic buffer in a
         * duk_to_dynamic_buffer() call.
         */
        duk_uint_t tmp;
        duk_uint8_t *tmp_ptr;
 
        tmp_ptr = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_buf);
        src_data = (const duk_uint8_t *) tmp_ptr;
        src_size = DUK_HBUFFER_GET_SIZE(h_buf);
 
        tmp = (DUK_HBUFFER_HAS_DYNAMIC(h_buf) ? DUK_BUF_MODE_DYNAMIC : DUK_BUF_MODE_FIXED);
        if ((tmp == mode && !DUK_HBUFFER_HAS_EXTERNAL(h_buf)) ||
            mode == DUK_BUF_MODE_DONTCARE) {
            /* Note: src_data may be NULL if input is a zero-size
             * dynamic buffer.
             */
            dst_data = tmp_ptr;
            goto skip_copy;
        }
    } else {
        /* Non-buffer value is first ToString() coerced, then converted
         * to a buffer (fixed buffer is used unless a dynamic buffer is
         * explicitly requested).
         */
 
        src_data = (const duk_uint8_t *) duk_to_lstring(ctx, index, &src_size);
    }
 

◆ duk_to_defaultvalue()

DUK_EXTERNAL_DECL void duk_to_defaultvalue	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_int_t	hint )

Definition at line 16665 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                                      {
    if (duk_get_prop_stridx(ctx, index, func_stridx)) {
        /* [ ... func ] */
        if (duk_is_callable(ctx, -1)) {
            duk_dup(ctx, index);         /* -> [ ... func this ] */
            duk_call_method(ctx, 0);     /* -> [ ... retval ] */
            if (duk_is_primitive(ctx, -1)) {
                duk_replace(ctx, index);
                return 1;
            }
            /* [ ... retval ]; popped below */
        }
    }
    duk_pop(ctx);  /* [ ... func/retval ] -> [ ... ] */
    return 0;
}
 
DUK_EXTERNAL void duk_to_defaultvalue(duk_context *ctx, duk_idx_t index, duk_int_t hint) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *obj;
    /* inline initializer for coercers[] is not allowed by old compilers like BCC */
    duk_small_int_t coercers[2];
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
 
    coercers[0] = DUK_STRIDX_VALUE_OF;
    coercers[1] = DUK_STRIDX_TO_STRING;
 
    index = duk_require_normalize_index(ctx, index);
    obj = duk_require_hobject_or_lfunc(ctx, index);
 
    if (hint == DUK_HINT_NONE) {
        if (obj != NULL && DUK_HOBJECT_GET_CLASS_NUMBER(obj) == DUK_HOBJECT_CLASS_DATE) {
            hint = DUK_HINT_STRING;
        } else {
            hint = DUK_HINT_NUMBER;
        }

◆ duk_to_int()

DUK_EXTERNAL_DECL duk_int_t duk_to_int	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16809 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_to_int32()

DUK_EXTERNAL_DECL duk_int32_t duk_to_int32	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16827 of file duktape-1.5.2/src-noline/duktape.c.

                                                                       {
    /* Value coercion (in stack): ToInteger(), E5 Section 9.4
     * API return value coercion: custom
     */
    DUK_ASSERT_CTX_VALID(ctx);
    (void) duk__to_int_uint_helper(ctx, index, duk_js_tointeger);
    return (duk_uint_t) duk__api_coerce_d2ui(ctx, index, 0 /*require*/);
}

◆ duk_to_lstring()

DUK_EXTERNAL_DECL const char * duk_to_lstring	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_len )

Definition at line 16915 of file duktape-1.5.2/src-noline/duktape.c.

                  {
        /* Exact halfway, round to even. */
        ret = (duk_uint8_t) d;

◆ duk_to_null()

DUK_EXTERNAL_DECL void duk_to_null	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16716 of file duktape-1.5.2/src-noline/duktape.c.

                                                                      {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(thr);

◆ duk_to_number()

DUK_EXTERNAL_DECL duk_double_t duk_to_number	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16766 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_to_object()

DUK_EXTERNAL_DECL void duk_to_object	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17299 of file duktape-1.5.2/src-noline/duktape.c.

                        :
#endif
    default:
        /* number */
        DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv));
        DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
        res = NULL;
        break;
    }
 
    duk_push_pointer(ctx, res);
    duk_replace(ctx, index);
    return res;
}
 
DUK_EXTERNAL void duk_to_object(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    duk_uint_t flags = 0;   /* shared flags for a subset of types */
    duk_small_int_t proto = 0;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    index = duk_require_normalize_index(ctx, index);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);
 
    switch (DUK_TVAL_GET_TAG(tv)) {
    case DUK_TAG_UNDEFINED:
    case DUK_TAG_NULL: {
        DUK_ERROR_TYPE(thr, DUK_STR_NOT_OBJECT_COERCIBLE);
        break;
    }
    case DUK_TAG_BOOLEAN: {
        flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
                DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BOOLEAN);
        proto = DUK_BIDX_BOOLEAN_PROTOTYPE;
        goto create_object;
    }
    case DUK_TAG_STRING: {
        flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
                DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ |
                DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_STRING);
        proto = DUK_BIDX_STRING_PROTOTYPE;
        goto create_object;
    }
    case DUK_TAG_OBJECT: {
        /* nop */
        break;
    }
    case DUK_TAG_BUFFER: {
        /* A plain buffer coerces to a Duktape.Buffer because it's the
         * object counterpart of the plain buffer value.  But it might
         * still make more sense to produce an ArrayBuffer here?
         */
 
        duk_hbufferobject *h_bufobj;
        duk_hbuffer *h_val;
 
        h_val = DUK_TVAL_GET_BUFFER(tv);
        DUK_ASSERT(h_val != NULL);
 
        h_bufobj = duk_push_bufferobject_raw(ctx,
                                             DUK_HOBJECT_FLAG_EXTENSIBLE |
                                             DUK_HOBJECT_FLAG_BUFFEROBJECT |
                                             DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BUFFER),
                                             DUK_BIDX_BUFFER_PROTOTYPE);
        DUK_ASSERT(h_bufobj != NULL);
        DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE((duk_hobject *) h_bufobj));
        DUK_ASSERT(DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) h_bufobj));
 
        h_bufobj->buf = h_val;
        DUK_HBUFFER_INCREF(thr, h_val);
        DUK_ASSERT(h_bufobj->offset == 0);
        h_bufobj->length = (duk_uint_t) DUK_HBUFFER_GET_SIZE(h_val);
        DUK_ASSERT(h_bufobj->shift == 0);
        DUK_ASSERT(h_bufobj->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8);
 
        DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj);
        goto replace_value;
    }
    case DUK_TAG_POINTER: {
        flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
                DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_POINTER);
        proto = DUK_BIDX_POINTER_PROTOTYPE;
        goto create_object;
    }
    case DUK_TAG_LIGHTFUNC: {
        /* Lightfunc coerces to a Function instance with concrete
         * properties.  Since 'length' is virtual for Duktape/C
         * functions, don't need to define that.
         *
         * The result is made extensible to mimic what happens to
         * strings:
         *   > Object.isExtensible(Object('foo'))
         *   true
         */
        duk_small_uint_t lf_flags;
        duk_idx_t nargs;
        duk_small_uint_t lf_len;
        duk_c_function func;
        duk_hnativefunction *nf;
 
        DUK_TVAL_GET_LIGHTFUNC(tv, func, lf_flags);
 
        nargs = (duk_idx_t) DUK_LFUNC_FLAGS_GET_NARGS(lf_flags);
        if (nargs == DUK_LFUNC_NARGS_VARARGS) {
            nargs = (duk_idx_t) DUK_VARARGS;
        }
        flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
                DUK_HOBJECT_FLAG_CONSTRUCTABLE |
                DUK_HOBJECT_FLAG_NATIVEFUNCTION |
                    DUK_HOBJECT_FLAG_NEWENV |
                    DUK_HOBJECT_FLAG_STRICT |
                    DUK_HOBJECT_FLAG_NOTAIL |
            /* DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC: omitted here intentionally */
                    DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION);
        (void) duk__push_c_function_raw(ctx, func, nargs, flags);
 
        lf_len = DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags);
        if ((duk_idx_t) lf_len != nargs) {
            /* Explicit length is only needed if it differs from 'nargs'. */
            duk_push_int(ctx, (duk_int_t) lf_len);
            duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE);
        }
        duk_push_lightfunc_name(ctx, tv);
        duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
 
        nf = duk_get_hnativefunction(ctx, -1);
        DUK_ASSERT(nf != NULL);
        nf->magic = (duk_int16_t) DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags);
 
        /* Enable DUKFUNC exotic behavior once properties are set up. */
        DUK_HOBJECT_SET_EXOTIC_DUKFUNC((duk_hobject *) nf);
        goto replace_value;
    }
#if defined(DUK_USE_FASTINT)
    case DUK_TAG_FASTINT:
#endif
    default: {
        DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv));
        DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
        flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
                       DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_NUMBER);
        proto = DUK_BIDX_NUMBER_PROTOTYPE;
        goto create_object;
    }
    }
    return;

◆ duk_to_pointer()

DUK_EXTERNAL_DECL void * duk_to_pointer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17248 of file duktape-1.5.2/src-noline/duktape.c.

                                  {
        /* When src_size == 0, src_data may be NULL (if source
         * buffer is dynamic), and dst_data may be NULL (if
         * target buffer is dynamic).  Avoid zero-size memcpy()
         * with an invalid pointer.
         */
        DUK_MEMCPY((void *) dst_data, (const void *) src_data, (size_t) src_size);
    }
    duk_replace(ctx, index);
 skip_copy:
 
    if (out_size) {
        *out_size = src_size;
    }
    return dst_data;
}
 
DUK_EXTERNAL void *duk_to_pointer(duk_context *ctx, duk_idx_t index) {
    duk_tval *tv;
    void *res;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    index = duk_require_normalize_index(ctx, index);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);
 
    switch (DUK_TVAL_GET_TAG(tv)) {
    case DUK_TAG_UNDEFINED:
    case DUK_TAG_NULL:
    case DUK_TAG_BOOLEAN:
        res = NULL;
        break;
    case DUK_TAG_POINTER:
        res = DUK_TVAL_GET_POINTER(tv);
        break;
    case DUK_TAG_STRING:
    case DUK_TAG_OBJECT:
    case DUK_TAG_BUFFER:
        /* Heap allocated: return heap pointer which is NOT useful
         * for the caller, except for debugging.
         */
        res = (void *) DUK_TVAL_GET_HEAPHDR(tv);
        break;
    case DUK_TAG_LIGHTFUNC:
        /* Function pointers do not always cast correctly to void *
         * (depends on memory and segmentation model for instance),
         * so they coerce to NULL.
         */

◆ duk_to_primitive()

DUK_EXTERNAL_DECL void duk_to_primitive	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_int_t	hint )

Definition at line 16729 of file duktape-1.5.2/src-noline/duktape.c.

                                                                 {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(thr);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);

◆ duk_to_string()

DUK_EXTERNAL_DECL const char * duk_to_string	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 17089 of file duktape-1.5.2/src-noline/duktape.c.

                     {
            DUK_ERROR_RANGE(thr, DUK_STR_NUMBER_OUTSIDE_RANGE);
        }
    }
 
    return res;
}
 
DUK_INTERNAL duk_int_t duk_to_int_clamped(duk_context *ctx, duk_idx_t index, duk_idx_t minval, duk_idx_t maxval) {
    duk_bool_t dummy;
    return duk_to_int_clamped_raw(ctx, index, minval, maxval, &dummy);
}
 
DUK_INTERNAL duk_int_t duk_to_int_check_range(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval) {
    return duk_to_int_clamped_raw(ctx, index, minval, maxval, NULL);  /* out_clamped==NULL -> RangeError if outside range */
}
 
DUK_EXTERNAL const char *duk_to_string(duk_context *ctx, duk_idx_t index) {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(thr);
 
    index = duk_require_normalize_index(ctx, index);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);
 
    switch (DUK_TVAL_GET_TAG(tv)) {
    case DUK_TAG_UNDEFINED: {
        duk_push_hstring_stridx(ctx, DUK_STRIDX_LC_UNDEFINED);
        break;
    }
    case DUK_TAG_NULL: {
        duk_push_hstring_stridx(ctx, DUK_STRIDX_LC_NULL);
        break;
    }
    case DUK_TAG_BOOLEAN: {
        if (DUK_TVAL_GET_BOOLEAN(tv)) {
            duk_push_hstring_stridx(ctx, DUK_STRIDX_TRUE);
        } else {
            duk_push_hstring_stridx(ctx, DUK_STRIDX_FALSE);
        }
        break;
    }
    case DUK_TAG_STRING: {
        /* nop */
        goto skip_replace;
    }
    case DUK_TAG_OBJECT: {
        duk_to_primitive(ctx, index, DUK_HINT_STRING);
        return duk_to_string(ctx, index);  /* Note: recursive call */
    }
    case DUK_TAG_BUFFER: {
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
 
        /* Note: this allows creation of internal strings. */
 
        DUK_ASSERT(h != NULL);
        duk_push_lstring(ctx,
                         (const char *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h),
                         (duk_size_t) DUK_HBUFFER_GET_SIZE(h));
        break;
    }
    case DUK_TAG_POINTER: {
        void *ptr = DUK_TVAL_GET_POINTER(tv);
        if (ptr != NULL) {
            duk_push_sprintf(ctx, DUK_STR_FMT_PTR, (void *) ptr);
        } else {
            /* Represent a null pointer as 'null' to be consistent with
             * the JX format variant.  Native '%p' format for a NULL
             * pointer may be e.g. '(nil)'.
             */
            duk_push_hstring_stridx(ctx, DUK_STRIDX_LC_NULL);
        }
        break;
    }
    case DUK_TAG_LIGHTFUNC: {
        /* Should match Function.prototype.toString() */
        duk_push_lightfunc_tostring(ctx, tv);
        break;
    }
#if defined(DUK_USE_FASTINT)
    case DUK_TAG_FASTINT:
#endif
    default: {

◆ duk_to_uint()

DUK_EXTERNAL_DECL duk_uint_t duk_to_uint	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16818 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_to_uint16()

DUK_EXTERNAL_DECL duk_uint16_t duk_to_uint16	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16861 of file duktape-1.5.2/src-noline/duktape.c.

                                                                           {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    duk_uint32_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);
    ret = duk_js_touint32(thr, tv);
 
    /* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */
    tv = duk_require_tval(ctx, index);
    DUK_TVAL_SET_FASTINT_U32_UPDREF(thr, tv, ret);  /* side effects */
    return ret;
}

◆ duk_to_uint32()

DUK_EXTERNAL_DECL duk_uint32_t duk_to_uint32	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16844 of file duktape-1.5.2/src-noline/duktape.c.

                                                                         {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    duk_int32_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);
    ret = duk_js_toint32(thr, tv);
 
    /* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */
    tv = duk_require_tval(ctx, index);
    DUK_TVAL_SET_FASTINT_I32_UPDREF(thr, tv, ret);  /* side effects */
    return ret;
}

◆ duk_to_undefined()

DUK_EXTERNAL_DECL void duk_to_undefined	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 16704 of file duktape-1.5.2/src-noline/duktape.c.

                                 {
        coercers[0] = DUK_STRIDX_TO_STRING;
        coercers[1] = DUK_STRIDX_VALUE_OF;
    }
 
    if (duk__defaultvalue_coerce_attempt(ctx, index, coercers[0])) {
        return;
    }
 
    if (duk__defaultvalue_coerce_attempt(ctx, index, coercers[1])) {

◆ duk_trim()

DUK_EXTERNAL_DECL void duk_trim	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 19768 of file duktape-1.5.2/src-noline/duktape.c.

                                                              {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hstring *h;
    const duk_uint8_t *p, *p_start, *p_end, *p_tmp1, *p_tmp2;  /* pointers for scanning */
    const duk_uint8_t *q_start, *q_end;  /* start (incl) and end (excl) of trimmed part */
    duk_codepoint_t cp;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    index = duk_require_normalize_index(ctx, index);
    h = duk_require_hstring(ctx, index);
    DUK_ASSERT(h != NULL);
 
    p_start = DUK_HSTRING_GET_DATA(h);
    p_end = p_start + DUK_HSTRING_GET_BYTELEN(h);
 
    p = p_start;
    while (p < p_end) {
        p_tmp1 = p;
        cp = (duk_codepoint_t) duk_unicode_decode_xutf8_checked(thr, &p_tmp1, p_start, p_end);
        if (!(duk_unicode_is_whitespace(cp) || duk_unicode_is_line_terminator(cp))) {
            break;
        }
        p = p_tmp1;
    }
    q_start = p;
    if (p == p_end) {
        /* entire string is whitespace */
        q_end = p;
        goto scan_done;
    }
 
    p = p_end;
    while (p > p_start) {
        p_tmp1 = p;
        while (p > p_start) {
            p--;
            if (((*p) & 0xc0) != 0x80) {
                break;
            }
        }
        p_tmp2 = p;
 
        cp = (duk_codepoint_t) duk_unicode_decode_xutf8_checked(thr, &p_tmp2, p_start, p_end);
        if (!(duk_unicode_is_whitespace(cp) || duk_unicode_is_line_terminator(cp))) {
            p = p_tmp1;
            break;
        }
    }
    q_end = p;
 
 scan_done:
    /* This may happen when forward and backward scanning disagree
     * (possible for non-extended-UTF-8 strings).
     */
    if (q_end < q_start) {
        q_end = q_start;
    }

◆ duk_xcopymove_raw()

DUK_EXTERNAL_DECL void duk_xcopymove_raw	(	duk_context *	to_ctx,
		duk_context *	from_ctx,
		duk_idx_t	count,
		duk_bool_t	is_copy )

Definition at line 15864 of file duktape-1.5.2/src-noline/duktape.c.

                                                                                                                     {
    duk_hthread *to_thr = (duk_hthread *) to_ctx;
    duk_hthread *from_thr = (duk_hthread *) from_ctx;
    void *src;
    duk_size_t nbytes;
    duk_tval *p;
    duk_tval *q;
 
    /* XXX: several pointer comparison issues here */
 
    DUK_ASSERT_CTX_VALID(to_ctx);
    DUK_ASSERT_CTX_VALID(from_ctx);
    DUK_ASSERT(to_ctx != NULL);
    DUK_ASSERT(from_ctx != NULL);
 
    if (to_ctx == from_ctx) {
        DUK_ERROR_API(to_thr, DUK_STR_INVALID_CONTEXT);
        return;
    }
    if ((count < 0) ||
        (count > (duk_idx_t) to_thr->valstack_max)) {
        /* Maximum value check ensures 'nbytes' won't wrap below. */
        DUK_ERROR_API(to_thr, DUK_STR_INVALID_COUNT);
        return;
    }
 
    nbytes = sizeof(duk_tval) * count;
    if (nbytes == 0) {
        return;
    }
    DUK_ASSERT(to_thr->valstack_top <= to_thr->valstack_end);
    if ((duk_size_t) ((duk_uint8_t *) to_thr->valstack_end - (duk_uint8_t *) to_thr->valstack_top) < nbytes) {
        DUK_ERROR_API(to_thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
    }
    src = (void *) ((duk_uint8_t *) from_thr->valstack_top - nbytes);
    if (src < (void *) from_thr->valstack_bottom) {
        DUK_ERROR_API(to_thr, DUK_STR_INVALID_COUNT);
    }
 
    /* copy values (no overlap even if to_ctx == from_ctx; that's not
     * allowed now anyway)
     */
    DUK_ASSERT(nbytes > 0);
    DUK_MEMCPY((void *) to_thr->valstack_top, (const void *) src, (size_t) nbytes);
 
    p = to_thr->valstack_top;
    to_thr->valstack_top = (duk_tval *) (void *) (((duk_uint8_t *) p) + nbytes);
 
    if (is_copy) {
        /* Incref copies, keep originals. */
        q = to_thr->valstack_top;

Variable Documentation

◆ duk_api_global_filename

DUK_EXTERNAL_DECL const char* duk_api_global_filename

Definition at line 382 of file duktape-1.5.2/src-noline/duktape.h.

◆ duk_api_global_line

DUK_EXTERNAL_DECL duk_int_t duk_api_global_line

Definition at line 383 of file duktape-1.5.2/src-noline/duktape.h.

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ DUK__DBLUNION_IS_NAN_FULL

◆ DUK__DBLUNION_IS_NAN_NOTFULL

◆ DUK__DBLUNION_IS_NORMALIZED_NAN_FULL

◆ DUK__DBLUNION_IS_NORMALIZED_NAN_NOTFULL

◆ DUK__DBLUNION_NORMALIZE_NAN_CHECK_FULL

◆ DUK__DBLUNION_NORMALIZE_NAN_CHECK_NOTFULL

◆ DUK__DBLUNION_SET_NAN_FULL

◆ DUK__DBLUNION_SET_NAN_NOTFULL

◆ DUK_API_ENTRY_STACK

◆ DUK_API_NORETURN

◆ DUK_API_PUBLIC_H_INCLUDED

◆ DUK_BUF_FLAG_DYNAMIC

◆ DUK_BUF_FLAG_EXTERNAL

◆ DUK_BUF_FLAG_NOZERO

◆ DUK_BUF_MODE_DONTCARE

◆ DUK_BUF_MODE_DYNAMIC

◆ DUK_BUF_MODE_FIXED

◆ DUK_BUFOBJ_ARRAYBUFFER

◆ DUK_BUFOBJ_CREATE_ARRBUF

◆ DUK_BUFOBJ_DATAVIEW

◆ DUK_BUFOBJ_DUKTAPE_BUFFER

◆ DUK_BUFOBJ_FLOAT32ARRAY

◆ DUK_BUFOBJ_FLOAT64ARRAY

◆ DUK_BUFOBJ_INT16ARRAY

◆ DUK_BUFOBJ_INT32ARRAY

◆ DUK_BUFOBJ_INT8ARRAY

◆ DUK_BUFOBJ_NODEJS_BUFFER

◆ DUK_BUFOBJ_UINT16ARRAY

◆ DUK_BUFOBJ_UINT32ARRAY

◆ DUK_BUFOBJ_UINT8ARRAY

◆ DUK_BUFOBJ_UINT8CLAMPEDARRAY

◆ duk_compile

◆ DUK_COMPILE_EVAL

◆ duk_compile_file

◆ DUK_COMPILE_FUNCTION

◆ duk_compile_lstring

◆ duk_compile_lstring_filename

◆ DUK_COMPILE_NOFILENAME

◆ DUK_COMPILE_NORESULT

◆ DUK_COMPILE_NOSOURCE

◆ DUK_COMPILE_SAFE

◆ DUK_COMPILE_STRICT

◆ duk_compile_string

◆ duk_compile_string_filename

◆ DUK_COMPILE_STRLEN

◆ duk_create_heap_default

◆ DUK_DATE_FLAG_EQUIVYEAR

◆ DUK_DATE_FLAG_LOCALTIME

◆ DUK_DATE_FLAG_NAN_TO_RANGE_ERROR

◆ DUK_DATE_FLAG_NAN_TO_ZERO

◆ DUK_DATE_FLAG_ONEBASED

◆ DUK_DATE_FLAG_SEP_T

◆ DUK_DATE_FLAG_SUB1900

◆ DUK_DATE_FLAG_TIMESETTER

◆ DUK_DATE_FLAG_TOSTRING_DATE

◆ DUK_DATE_FLAG_TOSTRING_LOCALE

◆ DUK_DATE_FLAG_TOSTRING_TIME

◆ DUK_DATE_FLAG_VALUE_SHIFT

◆ DUK_DATE_FLAG_YEAR_FIXUP

◆ DUK_DATE_IDX_DAY

◆ DUK_DATE_IDX_HOUR

◆ DUK_DATE_IDX_MILLISECOND

◆ DUK_DATE_IDX_MINUTE

◆ DUK_DATE_IDX_MONTH

◆ DUK_DATE_IDX_NUM_PARTS

◆ DUK_DATE_IDX_SECOND

◆ DUK_DATE_IDX_WEEKDAY

◆ DUK_DATE_IDX_YEAR

◆ DUK_DATE_MAX_ECMA_YEAR

◆ DUK_DATE_MIN_ECMA_YEAR

◆ DUK_DATE_MSEC_100M_DAYS

◆ DUK_DATE_MSEC_100M_DAYS_LEEWAY

◆ DUK_DATE_MSEC_DAY

◆ DUK_DATE_MSEC_HOUR