duk_api_stack.c File Reference

#include "duk_internal.h"

Go to the source code of this file.

Macros
#define	DUK__CHECK_SPACE()
#define	DUK__PACK_ARGS(classnum, protobidx, elemtype, elemshift, isview)    (((classnum) << 24) | ((protobidx) << 16) | ((elemtype) << 8) | ((elemshift) << 4) | (isview))
#define	DUK__READABLE_STRING_MAXCHARS   32

Typedefs
typedef duk_double_t(*	duk__toint_coercer) (duk_hthread *thr, duk_tval *tv)

Functions
DUK_LOCAL_DECL duk_idx_t	duk__push_c_function_raw (duk_context *ctx, duk_c_function func, duk_idx_t nargs, duk_uint_t flags)
DUK_LOCAL_DECL duk_heaphdr *	duk__get_tagged_heaphdr_raw (duk_context *ctx, duk_idx_t index, duk_uint_t tag)
DUK_LOCAL duk_int_t	duk__api_coerce_d2i (duk_context *ctx, duk_idx_t index, duk_bool_t require)
DUK_LOCAL duk_uint_t	duk__api_coerce_d2ui (duk_context *ctx, duk_idx_t index, duk_bool_t require)
DUK_EXTERNAL duk_idx_t	duk_normalize_index (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_idx_t	duk_require_normalize_index (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_tval *	duk_get_tval (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_tval *	duk_require_tval (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_valid_index (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL void	duk_require_valid_index (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_idx_t	duk_get_top (duk_context *ctx)
DUK_EXTERNAL void	duk_set_top (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_idx_t	duk_get_top_index (duk_context *ctx)
DUK_EXTERNAL duk_idx_t	duk_require_top_index (duk_context *ctx)
DUK_LOCAL duk_bool_t	duk__resize_valstack (duk_context *ctx, duk_size_t new_size)
DUK_INTERNAL duk_bool_t	duk_valstack_resize_raw (duk_context *ctx, duk_size_t min_new_size, duk_small_uint_t flags)
DUK_EXTERNAL duk_bool_t	duk_check_stack (duk_context *ctx, duk_idx_t extra)
DUK_EXTERNAL void	duk_require_stack (duk_context *ctx, duk_idx_t extra)
DUK_EXTERNAL duk_bool_t	duk_check_stack_top (duk_context *ctx, duk_idx_t top)
DUK_EXTERNAL void	duk_require_stack_top (duk_context *ctx, duk_idx_t top)
DUK_EXTERNAL void	duk_swap (duk_context *ctx, duk_idx_t index1, duk_idx_t index2)
DUK_EXTERNAL void	duk_swap_top (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL void	duk_dup (duk_context *ctx, duk_idx_t from_index)
DUK_EXTERNAL void	duk_dup_top (duk_context *ctx)
DUK_EXTERNAL void	duk_insert (duk_context *ctx, duk_idx_t to_index)
DUK_EXTERNAL void	duk_replace (duk_context *ctx, duk_idx_t to_index)
DUK_EXTERNAL void	duk_copy (duk_context *ctx, duk_idx_t from_index, duk_idx_t to_index)
DUK_EXTERNAL void	duk_remove (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL void	duk_xcopymove_raw (duk_context *to_ctx, duk_context *from_ctx, duk_idx_t count, duk_bool_t is_copy)
DUK_EXTERNAL void	duk_require_undefined (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL void	duk_require_null (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_get_boolean (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_require_boolean (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_double_t	duk_get_number (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_double_t	duk_require_number (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_int_t	duk_get_int (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_uint_t	duk_get_uint (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_int_t	duk_require_int (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_uint_t	duk_require_uint (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL const char *	duk_get_lstring (duk_context *ctx, duk_idx_t index, duk_size_t *out_len)
DUK_EXTERNAL const char *	duk_require_lstring (duk_context *ctx, duk_idx_t index, duk_size_t *out_len)
DUK_EXTERNAL const char *	duk_get_string (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL const char *	duk_require_string (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL void *	duk_get_pointer (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL void *	duk_require_pointer (duk_context *ctx, duk_idx_t index)
DUK_LOCAL void *	duk__get_buffer_helper (duk_context *ctx, duk_idx_t index, duk_size_t *out_size, duk_bool_t throw_flag)
DUK_EXTERNAL void *	duk_get_buffer (duk_context *ctx, duk_idx_t index, duk_size_t *out_size)
DUK_EXTERNAL void *	duk_require_buffer (duk_context *ctx, duk_idx_t index, duk_size_t *out_size)
DUK_LOCAL void *	duk__get_buffer_data_helper (duk_context *ctx, duk_idx_t index, duk_size_t *out_size, duk_bool_t throw_flag)
DUK_EXTERNAL void *	duk_get_buffer_data (duk_context *ctx, duk_idx_t index, duk_size_t *out_size)
DUK_EXTERNAL void *	duk_require_buffer_data (duk_context *ctx, duk_idx_t index, duk_size_t *out_size)
DUK_INTERNAL duk_hstring *	duk_get_hstring (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_hstring *	duk_require_hstring (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_hobject *	duk_get_hobject (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_hobject *	duk_require_hobject (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_hbuffer *	duk_get_hbuffer (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_hbuffer *	duk_require_hbuffer (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_hthread *	duk_get_hthread (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_hthread *	duk_require_hthread (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_hcompiledfunction *	duk_get_hcompiledfunction (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_hcompiledfunction *	duk_require_hcompiledfunction (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_hnativefunction *	duk_get_hnativefunction (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_hnativefunction *	duk_require_hnativefunction (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_c_function	duk_get_c_function (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_c_function	duk_require_c_function (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL void	duk_require_function (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_context *	duk_get_context (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_context *	duk_require_context (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL void *	duk_get_heapptr (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL void *	duk_require_heapptr (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_hobject *	duk_get_hobject_or_lfunc_coerce (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_hobject *	duk_require_hobject_or_lfunc (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_hobject *	duk_require_hobject_or_lfunc_coerce (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_hobject *	duk_get_hobject_with_class (duk_context *ctx, duk_idx_t index, duk_small_uint_t classnum)
DUK_INTERNAL duk_hobject *	duk_require_hobject_with_class (duk_context *ctx, duk_idx_t index, duk_small_uint_t classnum)
DUK_EXTERNAL duk_size_t	duk_get_length (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL void	duk_set_length (duk_context *ctx, duk_idx_t index, duk_size_t length)
DUK_LOCAL duk_bool_t	duk__defaultvalue_coerce_attempt (duk_context *ctx, duk_idx_t index, duk_small_int_t func_stridx)
DUK_EXTERNAL void	duk_to_defaultvalue (duk_context *ctx, duk_idx_t index, duk_int_t hint)
DUK_EXTERNAL void	duk_to_undefined (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL void	duk_to_null (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL void	duk_to_primitive (duk_context *ctx, duk_idx_t index, duk_int_t hint)
DUK_EXTERNAL duk_bool_t	duk_to_boolean (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_double_t	duk_to_number (duk_context *ctx, duk_idx_t index)
DUK_LOCAL duk_double_t	duk__to_int_uint_helper (duk_context *ctx, duk_idx_t index, duk__toint_coercer coerce_func)
DUK_EXTERNAL duk_int_t	duk_to_int (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_uint_t	duk_to_uint (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_int32_t	duk_to_int32 (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_uint32_t	duk_to_uint32 (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_uint16_t	duk_to_uint16 (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_uint8_t	duk_to_uint8clamped (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL const char *	duk_to_lstring (duk_context *ctx, duk_idx_t index, duk_size_t *out_len)
DUK_LOCAL duk_ret_t	duk__safe_to_string_raw (duk_context *ctx)
DUK_EXTERNAL const char *	duk_safe_to_lstring (duk_context *ctx, duk_idx_t index, duk_size_t *out_len)
DUK_INTERNAL void	duk_to_object_class_string_top (duk_context *ctx)
DUK_INTERNAL void	duk_push_hobject_class_string (duk_context *ctx, duk_hobject *h)
DUK_INTERNAL duk_int_t	duk_to_int_clamped_raw (duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval, duk_bool_t *out_clamped)
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_INTERNAL duk_int_t	duk_to_int_check_range (duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval)
DUK_EXTERNAL const char *	duk_to_string (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL duk_hstring *	duk_to_hstring (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL void *	duk_to_buffer_raw (duk_context *ctx, duk_idx_t index, duk_size_t *out_size, duk_uint_t mode)
DUK_EXTERNAL void *	duk_to_pointer (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL void	duk_to_object (duk_context *ctx, duk_idx_t index)
DUK_LOCAL duk_bool_t	duk__tag_check (duk_context *ctx, duk_idx_t index, duk_small_uint_t tag)
DUK_LOCAL duk_bool_t	duk__obj_flag_any_default_false (duk_context *ctx, duk_idx_t index, duk_uint_t flag_mask)
DUK_EXTERNAL duk_int_t	duk_get_type (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_check_type (duk_context *ctx, duk_idx_t index, duk_int_t type)
DUK_EXTERNAL duk_uint_t	duk_get_type_mask (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_check_type_mask (duk_context *ctx, duk_idx_t index, duk_uint_t mask)
DUK_EXTERNAL duk_bool_t	duk_is_undefined (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_null (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_null_or_undefined (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_boolean (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_number (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_nan (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_string (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_object (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_buffer (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_pointer (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_lightfunc (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_array (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_function (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_c_function (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_ecmascript_function (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_bound_function (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_thread (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_fixed_buffer (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_dynamic_buffer (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_bool_t	duk_is_external_buffer (duk_context *ctx, duk_idx_t index)
DUK_EXTERNAL duk_errcode_t	duk_get_error_code (duk_context *ctx, duk_idx_t index)
DUK_INTERNAL void	duk_push_tval (duk_context *ctx, duk_tval *tv)
DUK_EXTERNAL void	duk_push_undefined (duk_context *ctx)
DUK_EXTERNAL void	duk_push_null (duk_context *ctx)
DUK_EXTERNAL void	duk_push_boolean (duk_context *ctx, duk_bool_t val)
DUK_EXTERNAL void	duk_push_true (duk_context *ctx)
DUK_EXTERNAL void	duk_push_false (duk_context *ctx)
DUK_EXTERNAL void	duk_push_number (duk_context *ctx, duk_double_t val)
DUK_EXTERNAL void	duk_push_int (duk_context *ctx, duk_int_t val)
DUK_EXTERNAL void	duk_push_uint (duk_context *ctx, duk_uint_t val)
DUK_EXTERNAL void	duk_push_nan (duk_context *ctx)
DUK_EXTERNAL const char *	duk_push_lstring (duk_context *ctx, const char *str, duk_size_t len)
DUK_EXTERNAL const char *	duk_push_string (duk_context *ctx, const char *str)
DUK_EXTERNAL const char *	duk_push_string_file_raw (duk_context *ctx, const char *path, duk_uint_t flags)
DUK_EXTERNAL void	duk_push_pointer (duk_context *ctx, void *val)
DUK_LOCAL void	duk__push_this_helper (duk_context *ctx, duk_small_uint_t check_object_coercible)
DUK_EXTERNAL void	duk_push_this (duk_context *ctx)
DUK_INTERNAL void	duk_push_this_check_object_coercible (duk_context *ctx)
DUK_INTERNAL duk_hobject *	duk_push_this_coercible_to_object (duk_context *ctx)
DUK_INTERNAL duk_hstring *	duk_push_this_coercible_to_string (duk_context *ctx)
DUK_INTERNAL duk_tval *	duk_get_borrowed_this_tval (duk_context *ctx)
DUK_EXTERNAL void	duk_push_current_function (duk_context *ctx)
DUK_EXTERNAL void	duk_push_current_thread (duk_context *ctx)
DUK_EXTERNAL void	duk_push_global_object (duk_context *ctx)
DUK_LOCAL void	duk__push_stash (duk_context *ctx)
DUK_EXTERNAL void	duk_push_heap_stash (duk_context *ctx)
DUK_EXTERNAL void	duk_push_global_stash (duk_context *ctx)
DUK_EXTERNAL void	duk_push_thread_stash (duk_context *ctx, duk_context *target_ctx)
DUK_LOCAL duk_int_t	duk__try_push_vsprintf (duk_context *ctx, void *buf, duk_size_t sz, const char *fmt, va_list ap)
DUK_EXTERNAL const char *	duk_push_vsprintf (duk_context *ctx, const char *fmt, va_list ap)
DUK_EXTERNAL const char *	duk_push_sprintf (duk_context *ctx, const char *fmt,...)
DUK_INTERNAL duk_idx_t	duk_push_object_helper (duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx)
DUK_INTERNAL duk_idx_t	duk_push_object_helper_proto (duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_hobject *proto)
DUK_EXTERNAL duk_idx_t	duk_push_object (duk_context *ctx)
DUK_EXTERNAL duk_idx_t	duk_push_array (duk_context *ctx)
DUK_EXTERNAL duk_idx_t	duk_push_thread_raw (duk_context *ctx, duk_uint_t flags)
DUK_INTERNAL duk_idx_t	duk_push_compiledfunction (duk_context *ctx)
DUK_EXTERNAL duk_idx_t	duk_push_c_function (duk_context *ctx, duk_c_function func, duk_int_t nargs)
DUK_INTERNAL void	duk_push_c_function_noexotic (duk_context *ctx, duk_c_function func, duk_int_t nargs)
DUK_INTERNAL void	duk_push_c_function_noconstruct_noexotic (duk_context *ctx, duk_c_function func, duk_int_t nargs)
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_INTERNAL duk_hbufferobject *	duk_push_bufferobject_raw (duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx)
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_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_EXTERNAL 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 duk_idx_t	duk_push_error_object_stash (duk_context *ctx, duk_errcode_t err_code, const char *fmt,...)
DUK_EXTERNAL void *	duk_push_buffer_raw (duk_context *ctx, duk_size_t size, duk_small_uint_t flags)
DUK_EXTERNAL duk_idx_t	duk_push_heapptr (duk_context *ctx, void *ptr)
DUK_INTERNAL duk_idx_t	duk_push_object_internal (duk_context *ctx)
DUK_INTERNAL void	duk_push_hstring (duk_context *ctx, duk_hstring *h)
DUK_INTERNAL void	duk_push_hstring_stridx (duk_context *ctx, duk_small_int_t stridx)
DUK_INTERNAL void	duk_push_hobject (duk_context *ctx, duk_hobject *h)
DUK_INTERNAL void	duk_push_hbuffer (duk_context *ctx, duk_hbuffer *h)
DUK_INTERNAL void	duk_push_hobject_bidx (duk_context *ctx, duk_small_int_t builtin_idx)
DUK_EXTERNAL void	duk_pop_n (duk_context *ctx, duk_idx_t count)
DUK_EXTERNAL void	duk_pop (duk_context *ctx)
DUK_EXTERNAL void	duk_pop_2 (duk_context *ctx)
DUK_EXTERNAL void	duk_pop_3 (duk_context *ctx)
DUK_EXTERNAL void	duk_throw (duk_context *ctx)
DUK_EXTERNAL void	duk_fatal (duk_context *ctx, duk_errcode_t err_code, const char *err_msg)
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)
DUK_EXTERNAL void	duk_error_raw (duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt,...)
DUK_EXTERNAL void	duk_error_stash (duk_context *ctx, duk_errcode_t err_code, const char *fmt,...)
DUK_EXTERNAL duk_bool_t	duk_equals (duk_context *ctx, duk_idx_t index1, duk_idx_t index2)
DUK_EXTERNAL duk_bool_t	duk_strict_equals (duk_context *ctx, duk_idx_t index1, duk_idx_t index2)
DUK_EXTERNAL duk_bool_t	duk_instanceof (duk_context *ctx, duk_idx_t index1, duk_idx_t index2)
DUK_INTERNAL void	duk_push_lightfunc_name (duk_context *ctx, duk_tval *tv)
DUK_INTERNAL void	duk_push_lightfunc_tostring (duk_context *ctx, duk_tval *tv)
DUK_INTERNAL void	duk_push_string_funcptr (duk_context *ctx, duk_uint8_t *ptr, duk_size_t sz)
DUK_LOCAL void	duk__push_hstring_readable_unicode (duk_context *ctx, duk_hstring *h_input)
DUK_INTERNAL const char *	duk_push_string_tval_readable (duk_context *ctx, duk_tval *tv)
DUK_INTERNAL const char *	duk_push_string_readable (duk_context *ctx, duk_idx_t index)

Variables
DUK_EXTERNAL const char *	duk_api_global_filename = NULL
DUK_EXTERNAL duk_int_t	duk_api_global_line = 0
static const duk_uint32_t	duk__bufobj_flags_lookup []

Macro Definition Documentation

DUK__CHECK_SPACE

#define DUK__CHECK_SPACE

(

)

Value:

        do { \
        if (DUK_UNLIKELY(thr->valstack_top >= thr->valstack_end)) { \
            DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK); \
        } \
    } while (0)

Definition at line 41 of file duktape-1.5.2/src-separate/duk_api_stack.c.

#define DUK__CHECK_SPACE() do { \
        if (DUK_UNLIKELY(thr->valstack_top >= thr->valstack_end)) { \
            DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK); \
        } \
    } while (0)

Referenced by duk__push_this_helper(), duk_dup(), duk_dup_top(), duk_push_boolean(), duk_push_false(), duk_push_int(), duk_push_nan(), duk_push_null(), duk_push_number(), duk_push_pointer(), duk_push_true(), duk_push_tval(), duk_push_uint(), and duk_push_undefined().

DUK__PACK_ARGS

#define DUK__PACK_ARGS	(		classnum,
			protobidx,
			elemtype,
			elemshift,
			isview )    (((classnum) << 24) | ((protobidx) << 16) | ((elemtype) << 8) | ((elemshift) << 4) | (isview))

Definition at line 3894 of file duktape-1.5.2/src-separate/duk_api_stack.c.

#define DUK__PACK_ARGS(classnum,protobidx,elemtype,elemshift,isview) \
    (((classnum) << 24) | ((protobidx) << 16) | ((elemtype) << 8) | ((elemshift) << 4) | (isview))

DUK__READABLE_STRING_MAXCHARS

#define DUK__READABLE_STRING_MAXCHARS   32

Definition at line 4544 of file duktape-1.5.2/src-separate/duk_api_stack.c.

Referenced by duk__push_hstring_readable_unicode().

Typedef Documentation

duk__toint_coercer

typedef duk_double_t(* duk__toint_coercer) (duk_hthread *thr, duk_tval *tv)

Definition at line 1915 of file duktape-1.5.2/src-separate/duk_api_stack.c.

Function Documentation

duk__api_coerce_d2i()

DUK_LOCAL duk_int_t duk__api_coerce_d2i	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_bool_t	require )

Definition at line 50 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                               {
    duk_hthread *thr;
    duk_tval *tv;
    duk_small_int_t c;
    duk_double_t d;
 
    thr = (duk_hthread *) ctx;
 
    tv = duk_get_tval(ctx, index);
    if (tv == NULL) {
        goto error_notnumber;
    }
 
    /*
     *  Special cases like NaN and +/- Infinity are handled explicitly
     *  because a plain C coercion from double to int handles these cases
     *  in undesirable ways.  For instance, NaN may coerce to INT_MIN
     *  (not zero), and INT_MAX + 1 may coerce to INT_MIN (not INT_MAX).
     *
     *  This double-to-int coercion differs from ToInteger() because it
     *  has a finite range (ToInteger() allows e.g. +/- Infinity).  It
     *  also differs from ToInt32() because the INT_MIN/INT_MAX clamping
     *  depends on the size of the int type on the platform.  In particular,
     *  on platforms with a 64-bit int type, the full range is allowed.
     */
 
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv)) {
        duk_int64_t t = DUK_TVAL_GET_FASTINT(tv);
#if (DUK_INT_MAX <= 0x7fffffffL)
        /* Clamping only necessary for 32-bit ints. */
        if (t < DUK_INT_MIN) {
            t = DUK_INT_MIN;
        } else if (t > DUK_INT_MAX) {
            t = DUK_INT_MAX;
        }
#endif
        return (duk_int_t) t;
    }
#endif
 
    if (DUK_TVAL_IS_NUMBER(tv)) {
        d = DUK_TVAL_GET_NUMBER(tv);
        c = (duk_small_int_t) DUK_FPCLASSIFY(d);
        if (c == DUK_FP_NAN) {
            return 0;
        } else if (d < (duk_double_t) DUK_INT_MIN) {
            /* covers -Infinity */
            return DUK_INT_MIN;
        } else if (d > (duk_double_t) DUK_INT_MAX) {
            /* covers +Infinity */
            return DUK_INT_MAX;
        } else {
            /* coerce towards zero */
            return (duk_int_t) d;
        }
    }
 
 error_notnumber:
 
    if (require) {
        DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "number", DUK_STR_NOT_NUMBER);
        /* not reachable */
    }
    return 0;
}

References DUK_ERROR_REQUIRE_TYPE_INDEX, DUK_FP_NAN, DUK_FPCLASSIFY, duk_get_tval(), DUK_INT_MAX, DUK_INT_MIN, DUK_STR_NOT_NUMBER, DUK_TVAL_GET_NUMBER, DUK_TVAL_IS_NUMBER, index, and NULL.

Referenced by duk_get_int(), duk_require_int(), and duk_to_int().

duk__api_coerce_d2ui()

DUK_LOCAL duk_uint_t duk__api_coerce_d2ui	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_bool_t	require )

Definition at line 117 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                 {
    duk_hthread *thr;
    duk_tval *tv;
    duk_small_int_t c;
    duk_double_t d;
 
    /* Same as above but for unsigned int range. */
 
    thr = (duk_hthread *) ctx;
 
    tv = duk_get_tval(ctx, index);
    if (tv == NULL) {
        goto error_notnumber;
    }
 
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv)) {
        duk_int64_t t = DUK_TVAL_GET_FASTINT(tv);
        if (t < 0) {
            t = 0;
        }
#if (DUK_UINT_MAX <= 0xffffffffUL)
        /* Clamping only necessary for 32-bit ints. */
        else if (t > DUK_UINT_MAX) {
            t = DUK_UINT_MAX;
        }
#endif
        return (duk_uint_t) t;
    }
#endif
 
    if (DUK_TVAL_IS_NUMBER(tv)) {
        d = DUK_TVAL_GET_NUMBER(tv);
        c = (duk_small_int_t) DUK_FPCLASSIFY(d);
        if (c == DUK_FP_NAN) {
            return 0;
        } else if (d < 0.0) {
            /* covers -Infinity */
            return (duk_uint_t) 0;
        } else if (d > (duk_double_t) DUK_UINT_MAX) {
            /* covers +Infinity */
            return (duk_uint_t) DUK_UINT_MAX;
        } else {
            /* coerce towards zero */
            return (duk_uint_t) d;
        }
    }
 
 error_notnumber:
 
    if (require) {
        DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "number", DUK_STR_NOT_NUMBER);
        /* not reachable */
    }
    return 0;
}

References DUK_ERROR_REQUIRE_TYPE_INDEX, DUK_FP_NAN, DUK_FPCLASSIFY, duk_get_tval(), DUK_STR_NOT_NUMBER, DUK_TVAL_GET_NUMBER, DUK_TVAL_IS_NUMBER, DUK_UINT_MAX, index, and NULL.

Referenced by duk_get_uint(), duk_require_uint(), and duk_to_uint().

duk__defaultvalue_coerce_attempt()

DUK_LOCAL duk_bool_t duk__defaultvalue_coerce_attempt	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_small_int_t	func_stridx )

Definition at line 1775 of file duktape-1.5.2/src-separate/duk_api_stack.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;
}

References duk_call_method(), duk_dup(), duk_get_prop_stridx(), duk_is_callable, duk_is_primitive, duk_pop(), duk_replace(), and index.

Referenced by duk_to_defaultvalue().

duk__get_buffer_data_helper()

DUK_LOCAL void * duk__get_buffer_data_helper	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_size,
		duk_bool_t	throw_flag )

Definition at line 1332 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                                            {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(thr);
 
    if (out_size != NULL) {
        *out_size = 0;
    }
 
    tv = duk_get_tval(ctx, index);
    if (tv == NULL) {
        goto fail;
    }
 
    if (DUK_TVAL_IS_BUFFER(tv)) {
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
        DUK_ASSERT(h != NULL);
        if (out_size) {
            *out_size = DUK_HBUFFER_GET_SIZE(h);
        }
        return (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h);  /* may be NULL (but only if size is 0) */
    } else if (DUK_TVAL_IS_OBJECT(tv)) {
        duk_hobject *h = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(h != NULL);
        if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) {
            /* XXX: this is probably a useful shared helper: for a
             * duk_hbufferobject, get a validated buffer pointer/length.
             */
            duk_hbufferobject *h_bufobj = (duk_hbufferobject *) h;
            DUK_ASSERT_HBUFFEROBJECT_VALID(h_bufobj);
 
            if (h_bufobj->buf != NULL &&
                DUK_HBUFFEROBJECT_VALID_SLICE(h_bufobj)) {
                duk_uint8_t *p;
 
                p = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_bufobj->buf);
                if (out_size != NULL) {
                    *out_size = (duk_size_t) h_bufobj->length;
                }
                return (void *) (p + h_bufobj->offset);
            }
            /* if slice not fully valid, treat as error */
        }
    }
 
 fail:
    if (throw_flag) {
        DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "buffer", DUK_STR_NOT_BUFFER);
    }
    return NULL;
}

References duk_hbufferobject::buf, DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ASSERT_HBUFFEROBJECT_VALID, DUK_ERROR_REQUIRE_TYPE_INDEX, duk_get_tval(), DUK_HBUFFER_GET_DATA_PTR, DUK_HBUFFER_GET_SIZE, DUK_HBUFFEROBJECT_VALID_SLICE, DUK_HOBJECT_IS_BUFFEROBJECT, DUK_STR_NOT_BUFFER, DUK_TVAL_GET_BUFFER, DUK_TVAL_GET_OBJECT, DUK_TVAL_IS_BUFFER, DUK_TVAL_IS_OBJECT, DUK_UNREF, duk_hthread::heap, index, duk_hbufferobject::length, NULL, and duk_hbufferobject::offset.

Referenced by duk_get_buffer_data(), and duk_require_buffer_data().

duk__get_buffer_helper()

DUK_LOCAL void * duk__get_buffer_helper	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_size,
		duk_bool_t	throw_flag )

Definition at line 1297 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                                       {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_UNREF(thr);
 
    if (out_size != NULL) {
        *out_size = 0;
    }
 
    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);
        if (out_size) {
            *out_size = DUK_HBUFFER_GET_SIZE(h);
        }
        return (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h);  /* may be NULL (but only if size is 0) */
    }
 
    if (throw_flag) {
        DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "buffer", DUK_STR_NOT_BUFFER);
    }
    return NULL;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ERROR_REQUIRE_TYPE_INDEX, duk_get_tval(), DUK_HBUFFER_GET_DATA_PTR, DUK_HBUFFER_GET_SIZE, DUK_STR_NOT_BUFFER, DUK_TVAL_GET_BUFFER, DUK_TVAL_IS_BUFFER, DUK_UNREF, duk_hthread::heap, index, and NULL.

Referenced by duk_get_buffer(), and duk_require_buffer().

duk__get_tagged_heaphdr_raw()

DUK_LOCAL_DECL duk_heaphdr * duk__get_tagged_heaphdr_raw	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_uint_t	tag )

Definition at line 1399 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                      {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && (DUK_TVAL_GET_TAG(tv) == tag)) {
        duk_heaphdr *ret;
        ret = DUK_TVAL_GET_HEAPHDR(tv);
        DUK_ASSERT(ret != NULL);  /* tagged null pointers should never occur */
        return ret;
    }
 
    return (duk_heaphdr *) NULL;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_tval(), DUK_TVAL_GET_HEAPHDR, DUK_TVAL_GET_TAG, index, and NULL.

Referenced by duk_get_hbuffer(), duk_get_hcompiledfunction(), duk_get_hnativefunction(), duk_get_hobject(), duk_get_hobject_with_class(), duk_get_hstring(), duk_get_hthread(), duk_require_hbuffer(), duk_require_hcompiledfunction(), duk_require_hnativefunction(), duk_require_hobject(), duk_require_hobject_with_class(), duk_require_hstring(), and duk_require_hthread().

duk__obj_flag_any_default_false()

DUK_LOCAL duk_bool_t duk__obj_flag_any_default_false	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_uint_t	flag_mask )

Definition at line 2593 of file duktape-1.5.2/src-separate/duk_api_stack.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;
}

References DUK_ASSERT_CTX_VALID, duk_get_hobject(), DUK_HEAPHDR_CHECK_FLAG_BITS, and index.

Referenced by duk_is_bound_function(), duk_is_c_function(), duk_is_ecmascript_function(), duk_is_function(), and duk_is_thread().

duk__push_c_function_raw()

DUK_LOCAL_DECL duk_idx_t duk__push_c_function_raw	(	duk_context *	ctx,
		duk_c_function	func,
		duk_idx_t	nargs,
		duk_uint_t	flags )

Definition at line 3726 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                                       {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hnativefunction *obj;
    duk_idx_t ret;
    duk_tval *tv_slot;
    duk_int16_t func_nargs;
 
    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 (func == NULL) {
        goto api_error;
    }
    if (nargs >= 0 && nargs < DUK_HNATIVEFUNCTION_NARGS_MAX) {
        func_nargs = (duk_int16_t) nargs;
    } else if (nargs == DUK_VARARGS) {
        func_nargs = DUK_HNATIVEFUNCTION_NARGS_VARARGS;
    } else {
        goto api_error;
    }
 
    obj = duk_hnativefunction_alloc(thr->heap, flags);
    if (!obj) {
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
 
    obj->func = func;
    obj->nargs = func_nargs;
 
    DUK_DDD(DUK_DDDPRINT("created native function object with flags: 0x%08lx, nargs=%ld",
                         (unsigned long) obj->obj.hdr.h_flags, (long) obj->nargs));
 
    tv_slot = thr->valstack_top;
    DUK_TVAL_SET_OBJECT(tv_slot, (duk_hobject *) obj);
    DUK_HOBJECT_INCREF(thr, obj);
    ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
    thr->valstack_top++;
 
    /* default prototype (Note: 'obj' must be reachable) */
    DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) obj, thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]);
 
    return ret;
 
 api_error:
    DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS);
    return 0;  /* not reached */
}

References duk_hthread::builtins, DUK_ASSERT_CTX_VALID, DUK_BIDX_FUNCTION_PROTOTYPE, DUK_DDD, DUK_DDDPRINT, DUK_ERROR_ALLOC_DEFMSG, DUK_ERROR_API, duk_hnativefunction_alloc(), DUK_HNATIVEFUNCTION_NARGS_MAX, DUK_HNATIVEFUNCTION_NARGS_VARARGS, DUK_HOBJECT_INCREF, DUK_HOBJECT_SET_PROTOTYPE_UPDREF, DUK_STR_INVALID_CALL_ARGS, DUK_STR_PUSH_BEYOND_ALLOC_STACK, DUK_TVAL_SET_OBJECT, DUK_VARARGS, duk_hnativefunction::func, duk_heaphdr::h_flags, duk_hobject::hdr, duk_hthread::heap, duk_hnativefunction::nargs, NULL, duk_hnativefunction::obj, duk_hthread::valstack_bottom, duk_hthread::valstack_end, and duk_hthread::valstack_top.

Referenced by duk_push_c_function(), duk_push_c_function_noconstruct_noexotic(), duk_push_c_function_noexotic(), and duk_to_object().

duk__push_hstring_readable_unicode()

DUK_LOCAL void duk__push_hstring_readable_unicode	(	duk_context *	ctx,
		duk_hstring *	h_input )

Definition at line 4551 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                          {
    duk_hthread *thr;
    const duk_uint8_t *p, *p_start, *p_end;
    duk_uint8_t buf[DUK_UNICODE_MAX_XUTF8_LENGTH * DUK__READABLE_STRING_MAXCHARS +
                    2 /*quotes*/ + 3 /*periods*/];
    duk_uint8_t *q;
    duk_ucodepoint_t cp;
    duk_small_uint_t nchars;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(h_input != NULL);
    thr = (duk_hthread *) ctx;
 
    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;
    q = buf;
 
    nchars = 0;
    *q++ = (duk_uint8_t) DUK_ASC_SINGLEQUOTE;
    for (;;) {
        if (p >= p_end) {
            break;
        }
        if (nchars == DUK__READABLE_STRING_MAXCHARS) {
            *q++ = (duk_uint8_t) DUK_ASC_PERIOD;
            *q++ = (duk_uint8_t) DUK_ASC_PERIOD;
            *q++ = (duk_uint8_t) DUK_ASC_PERIOD;
            break;
        }
        if (duk_unicode_decode_xutf8(thr, &p, p_start, p_end, &cp)) {
            if (cp < 0x20 || cp == 0x7f || cp == DUK_ASC_SINGLEQUOTE || cp == DUK_ASC_BACKSLASH) {
                DUK_ASSERT(DUK_UNICODE_MAX_XUTF8_LENGTH >= 4);  /* estimate is valid */
                DUK_ASSERT((cp >> 4) <= 0x0f);
                *q++ = (duk_uint8_t) DUK_ASC_BACKSLASH;
                *q++ = (duk_uint8_t) DUK_ASC_LC_X;
                *q++ = (duk_uint8_t) duk_lc_digits[cp >> 4];
                *q++ = (duk_uint8_t) duk_lc_digits[cp & 0x0f];
            } else {
                q += duk_unicode_encode_xutf8(cp, q);
            }
        } else {
            p++;  /* advance manually */
            *q++ = (duk_uint8_t) DUK_ASC_QUESTION;
        }
        nchars++;
    }
    *q++ = (duk_uint8_t) DUK_ASC_SINGLEQUOTE;
 
    duk_push_lstring(ctx, (const char *) buf, (duk_size_t) (q - buf));
}

References DUK__READABLE_STRING_MAXCHARS, DUK_ASC_BACKSLASH, DUK_ASC_LC_X, DUK_ASC_PERIOD, DUK_ASC_QUESTION, DUK_ASC_SINGLEQUOTE, DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_DATA, duk_lc_digits, duk_push_lstring(), duk_unicode_decode_xutf8(), duk_unicode_encode_xutf8(), DUK_UNICODE_MAX_XUTF8_LENGTH, and NULL.

Referenced by duk_push_string_tval_readable().

duk__push_stash()

DUK_LOCAL void duk__push_stash

(

duk_context *

ctx

)

Definition at line 3384 of file duktape-1.5.2/src-separate/duk_api_stack.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_pop(ctx);
        duk_push_object_internal(ctx);
        duk_dup_top(ctx);
        duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_C);  /* [ ... parent stash stash ] -> [ ... parent stash ] */
    }
    duk_remove(ctx, -2);
}

References DUK_ASSERT_CTX_VALID, DUK_DDD, DUK_DDDPRINT, duk_dup_top(), duk_get_prop_stridx(), duk_pop(), DUK_PROPDESC_FLAGS_C, duk_push_object_internal(), duk_remove(), DUK_STRIDX_INT_VALUE, and duk_xdef_prop_stridx().

Referenced by duk_push_global_stash(), duk_push_heap_stash(), and duk_push_thread_stash().

duk__push_this_helper()

DUK_LOCAL void duk__push_this_helper	(	duk_context *	ctx,
		duk_small_uint_t	check_object_coercible )

Definition at line 3259 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                {
    duk_hthread *thr;
    duk_tval *tv_slot;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT_DISABLE(thr->callstack_top >= 0);  /* avoid warning (unsigned) */
    thr = (duk_hthread *) ctx;
    DUK_ASSERT(thr->callstack_top <= thr->callstack_size);
    DUK__CHECK_SPACE();
 
    DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(thr->valstack_top));  /* because of valstack init policy */
    tv_slot = thr->valstack_top++;
 
    if (DUK_UNLIKELY(thr->callstack_top == 0)) {
        if (check_object_coercible) {
            goto type_error;
        }
        /* 'undefined' already on stack top */
    } else {
        duk_tval *tv;
 
        /* 'this' binding is just before current activation's bottom */
        DUK_ASSERT(thr->valstack_bottom > thr->valstack);
        tv = thr->valstack_bottom - 1;
        if (check_object_coercible &&
            (DUK_TVAL_IS_UNDEFINED(tv) || DUK_TVAL_IS_NULL(tv))) {
            /* XXX: better macro for DUK_TVAL_IS_UNDEFINED_OR_NULL(tv) */
            goto type_error;
        }
 
        DUK_TVAL_SET_TVAL(tv_slot, tv);
        DUK_TVAL_INCREF(thr, tv);
    }
    return;
 
 type_error:
    DUK_ERROR_TYPE(thr, DUK_STR_NOT_OBJECT_COERCIBLE);
}

References duk_hthread::callstack_size, duk_hthread::callstack_top, DUK__CHECK_SPACE, DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ASSERT_DISABLE, DUK_ERROR_TYPE, DUK_STR_NOT_OBJECT_COERCIBLE, DUK_TVAL_INCREF, DUK_TVAL_IS_NULL, DUK_TVAL_IS_UNDEFINED, DUK_TVAL_SET_TVAL, DUK_UNLIKELY, duk_hthread::valstack, duk_hthread::valstack_bottom, and duk_hthread::valstack_top.

Referenced by duk_push_this(), duk_push_this_check_object_coercible(), duk_push_this_coercible_to_object(), and duk_push_this_coercible_to_string().

duk__resize_valstack()

DUK_LOCAL duk_bool_t duk__resize_valstack	(	duk_context *	ctx,
		duk_size_t	new_size )

Definition at line 487 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                 {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_ptrdiff_t old_bottom_offset;
    duk_ptrdiff_t old_top_offset;
    duk_ptrdiff_t old_end_offset_post;
#ifdef DUK_USE_DEBUG
    duk_ptrdiff_t old_end_offset_pre;
    duk_tval *old_valstack_pre;
    duk_tval *old_valstack_post;
#endif
    duk_tval *new_valstack;
    duk_size_t new_alloc_size;
    duk_tval *p;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
    DUK_ASSERT((duk_size_t) (thr->valstack_top - thr->valstack) <= new_size);  /* can't resize below 'top' */
    DUK_ASSERT(new_size <= thr->valstack_max);  /* valstack limit caller has check, prevents wrapping */
    DUK_ASSERT(new_size <= DUK_SIZE_MAX / sizeof(duk_tval));  /* specific assert for wrapping */
 
    /* get pointer offsets for tweaking below */
    old_bottom_offset = (((duk_uint8_t *) thr->valstack_bottom) - ((duk_uint8_t *) thr->valstack));
    old_top_offset = (((duk_uint8_t *) thr->valstack_top) - ((duk_uint8_t *) thr->valstack));
#ifdef DUK_USE_DEBUG
    old_end_offset_pre = (((duk_uint8_t *) thr->valstack_end) - ((duk_uint8_t *) thr->valstack));  /* not very useful, used for debugging */
    old_valstack_pre = thr->valstack;
#endif
 
    /* Allocate a new valstack.
     *
     * Note: cannot use a plain DUK_REALLOC() because a mark-and-sweep may
     * invalidate the original thr->valstack base pointer inside the realloc
     * process.  See doc/memory-management.rst.
     */
 
    new_alloc_size = sizeof(duk_tval) * new_size;
    new_valstack = (duk_tval *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_valstack_ptr, (void *) thr, new_alloc_size);
    if (!new_valstack) {
        /* Because new_size != 0, if condition doesn't need to be
         * (new_valstack != NULL || new_size == 0).
         */
        DUK_ASSERT(new_size != 0);
        DUK_D(DUK_DPRINT("failed to resize valstack to %lu entries (%lu bytes)",
                         (unsigned long) new_size, (unsigned long) new_alloc_size));
        return 0;
    }
 
    /* Note: the realloc may have triggered a mark-and-sweep which may
     * have resized our valstack internally.  However, the mark-and-sweep
     * MUST NOT leave the stack bottom/top in a different state.  Particular
     * assumptions and facts:
     *
     *   - The thr->valstack pointer may be different after realloc,
     *     and the offset between thr->valstack_end <-> thr->valstack
     *     may have changed.
     *   - The offset between thr->valstack_bottom <-> thr->valstack
     *     and thr->valstack_top <-> thr->valstack MUST NOT have changed,
     *     because mark-and-sweep must adhere to a strict stack policy.
     *     In other words, logical bottom and top MUST NOT have changed.
     *   - All values above the top are unreachable but are initialized
     *     to UNDEFINED, up to the post-realloc valstack_end.
     *   - 'old_end_offset' must be computed after realloc to be correct.
     */
 
    DUK_ASSERT((((duk_uint8_t *) thr->valstack_bottom) - ((duk_uint8_t *) thr->valstack)) == old_bottom_offset);
    DUK_ASSERT((((duk_uint8_t *) thr->valstack_top) - ((duk_uint8_t *) thr->valstack)) == old_top_offset);
 
    /* success, fixup pointers */
    old_end_offset_post = (((duk_uint8_t *) thr->valstack_end) - ((duk_uint8_t *) thr->valstack));  /* must be computed after realloc */
#ifdef DUK_USE_DEBUG
    old_valstack_post = thr->valstack;
#endif
    thr->valstack = new_valstack;
    thr->valstack_end = new_valstack + new_size;
#if !defined(DUK_USE_PREFER_SIZE)
    thr->valstack_size = new_size;
#endif
    thr->valstack_bottom = (duk_tval *) (void *) ((duk_uint8_t *) new_valstack + old_bottom_offset);
    thr->valstack_top = (duk_tval *) (void *) ((duk_uint8_t *) new_valstack + old_top_offset);
 
    DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
 
    /* useful for debugging */
#ifdef DUK_USE_DEBUG
    if (old_end_offset_pre != old_end_offset_post) {
        DUK_D(DUK_DPRINT("valstack was resized during valstack_resize(), probably by mark-and-sweep; "
                         "end offset changed: %lu -> %lu",
                         (unsigned long) old_end_offset_pre,
                         (unsigned long) old_end_offset_post));
    }
    if (old_valstack_pre != old_valstack_post) {
        DUK_D(DUK_DPRINT("valstack pointer changed during valstack_resize(), probably by mark-and-sweep: %p -> %p",
                         (void *) old_valstack_pre,
                         (void *) old_valstack_post));
    }
#endif
 
    DUK_DD(DUK_DDPRINT("resized valstack to %lu elements (%lu bytes), bottom=%ld, top=%ld, "
                       "new pointers: start=%p end=%p bottom=%p top=%p",
                       (unsigned long) new_size, (unsigned long) new_alloc_size,
                       (long) (thr->valstack_bottom - thr->valstack),
                       (long) (thr->valstack_top - thr->valstack),
                       (void *) thr->valstack, (void *) thr->valstack_end,
                       (void *) thr->valstack_bottom, (void *) thr->valstack_top));
 
    /* Init newly allocated slots (only). */
    p = (duk_tval *) (void *) ((duk_uint8_t *) thr->valstack + old_end_offset_post);
    while (p < thr->valstack_end) {
        /* Never executed if new size is smaller. */
        DUK_TVAL_SET_UNDEFINED(p);
        p++;
    }
 
    /* Assert for value stack initialization policy. */
#if defined(DUK_USE_ASSERTIONS)
    p = thr->valstack_top;
    while (p < thr->valstack_end) {
        DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(p));
        p++;
    }
#endif
 
    return 1;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_D, DUK_DD, DUK_DDPRINT, DUK_DPRINT, duk_hthread_get_valstack_ptr(), DUK_REALLOC_INDIRECT, DUK_SIZE_MAX, DUK_TVAL_IS_UNDEFINED, DUK_TVAL_SET_UNDEFINED, duk_hthread::heap, NULL, duk_hthread::valstack, duk_hthread::valstack_bottom, duk_hthread::valstack_end, duk_hthread::valstack_size, and duk_hthread::valstack_top.

Referenced by duk_valstack_resize_raw().

duk__safe_to_string_raw()

DUK_LOCAL duk_ret_t duk__safe_to_string_raw

(

duk_context *

ctx

)

Definition at line 2049 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                              {
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk_to_string(ctx, -1);
    return 1;
}

References DUK_ASSERT_CTX_VALID, and duk_to_string().

Referenced by duk_safe_to_lstring().

duk__tag_check()

DUK_LOCAL duk_bool_t duk__tag_check	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_small_uint_t	tag )

Definition at line 2583 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                             {
    duk_tval *tv;
 
    tv = duk_get_tval(ctx, index);
    if (!tv) {
        return 0;
    }
    return (DUK_TVAL_GET_TAG(tv) == tag);
}

References duk_get_tval(), DUK_TVAL_GET_TAG, and index.

Referenced by duk_is_boolean(), duk_is_buffer(), duk_is_lightfunc(), duk_is_null(), duk_is_object(), duk_is_pointer(), duk_is_string(), and duk_is_undefined().

duk__to_int_uint_helper()

DUK_LOCAL duk_double_t duk__to_int_uint_helper	(	duk_context *	ctx,
		duk_idx_t	index,
		duk__toint_coercer	coerce_func )

Definition at line 1917 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                                  {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    duk_double_t d;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);
    d = coerce_func(thr, tv);
 
    /* XXX: fastint? */
 
    /* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */
    tv = duk_require_tval(ctx, index);
    DUK_TVAL_SET_NUMBER_UPDREF(thr, tv, d);  /* side effects */
    return d;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_require_tval(), DUK_TVAL_SET_NUMBER_UPDREF, index, and NULL.

Referenced by duk_to_int(), and duk_to_uint().

duk__try_push_vsprintf()

DUK_LOCAL duk_int_t duk__try_push_vsprintf	(	duk_context *	ctx,
		void *	buf,
		duk_size_t	sz,
		const char *	fmt,
		va_list	ap )

Definition at line 3424 of file duktape-1.5.2/src-separate/duk_api_stack.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;
}

References DUK_ASSERT_CTX_VALID, DUK_UNREF, and DUK_VSNPRINTF.

Referenced by duk_push_vsprintf().

duk_check_stack()

DUK_EXTERNAL duk_bool_t duk_check_stack	(	duk_context *	ctx,
		duk_idx_t	extra )

Definition at line 717 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                           {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_size_t min_new_size;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
 
    if (DUK_UNLIKELY(extra < 0)) {
        /* 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 */);
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_UNLIKELY, DUK_VALSTACK_INTERNAL_EXTRA, duk_valstack_resize_raw(), NULL, duk_hthread::valstack, and duk_hthread::valstack_top.

duk_check_stack_top()

DUK_EXTERNAL duk_bool_t duk_check_stack_top	(	duk_context *	ctx,
		duk_idx_t	top )

Definition at line 761 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                             {
    duk_size_t min_new_size;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    if (DUK_UNLIKELY(top < 0)) {
        /* 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 */);
}

References DUK_ASSERT_CTX_VALID, DUK_UNLIKELY, DUK_VALSTACK_INTERNAL_EXTRA, and duk_valstack_resize_raw().

duk_check_type()

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

Definition at line 2668 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                          {
    DUK_ASSERT_CTX_VALID(ctx);
 
    return (duk_get_type(ctx, index) == type) ? 1 : 0;
}

References DUK_ASSERT_CTX_VALID, duk_get_type(), and index.

duk_check_type_mask()

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

Definition at line 2712 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    if (duk_get_type_mask(ctx, index) & mask) {
        return 1;
    }
    if (mask & DUK_TYPE_MASK_THROW) {
        DUK_ERROR_TYPE(thr, DUK_STR_UNEXPECTED_TYPE);
        DUK_UNREACHABLE();
    }
    return 0;
}

References DUK_ASSERT_CTX_VALID, DUK_ERROR_TYPE, duk_get_type_mask(), DUK_STR_UNEXPECTED_TYPE, DUK_TYPE_MASK_THROW, DUK_UNREACHABLE, index, and mask.

Referenced by duk_to_primitive().

duk_copy()

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

Definition at line 930 of file duktape-1.5.2/src-separate/duk_api_stack.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 */
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_require_tval(), DUK_TVAL_SET_TVAL_UPDREF, DUK_UNREF, and NULL.

duk_dup()

DUK_EXTERNAL void duk_dup	(	duk_context *	ctx,
		duk_idx_t	from_index )

Definition at line 829 of file duktape-1.5.2/src-separate/duk_api_stack.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 */
}

References DUK__CHECK_SPACE, DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_require_tval(), DUK_TVAL_INCREF, DUK_TVAL_SET_TVAL, NULL, and duk_hthread::valstack_top.

Referenced by duk__defaultvalue_coerce_attempt(), duk_safe_to_lstring(), and duk_to_object().

duk_dup_top()

DUK_EXTERNAL void duk_dup_top

(

duk_context *

ctx

)

Definition at line 846 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                {
    duk_hthread *thr;
    duk_tval *tv_from;
    duk_tval *tv_to;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
 
    if (thr->valstack_top - thr->valstack_bottom <= 0) {
        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 */
}

References DUK__CHECK_SPACE, DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ERROR_API_INDEX, DUK_TVAL_INCREF, DUK_TVAL_SET_TVAL, NULL, duk_hthread::valstack_bottom, and duk_hthread::valstack_top.

Referenced by duk__push_stash().

duk_equals()

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

Definition at line 4409 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                         {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv1, *tv2;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv1 = duk_get_tval(ctx, index1);
    tv2 = duk_get_tval(ctx, index2);
    if ((tv1 == NULL) || (tv2 == NULL)) {
        return 0;
    }
 
    /* Coercion may be needed, the helper handles that by pushing the
     * tagged values to the stack.
     */
    return duk_js_equals(thr, tv1, tv2);
}

References DUK_ASSERT_CTX_VALID, duk_get_tval(), duk_js_equals, and NULL.

duk_error_raw()

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

Definition at line 4374 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                                                      {
    va_list ap;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    va_start(ap, fmt);
    duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap);
    va_end(ap);
    duk_throw(ctx);
}

References DUK_ASSERT_CTX_VALID, duk_push_error_object_va_raw(), and duk_throw().

duk_error_stash()

DUK_EXTERNAL void duk_error_stash	(	duk_context *	ctx,
		duk_errcode_t	err_code,
		const char *	fmt,
			... )

Definition at line 4386 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                  {
    const char *filename;
    duk_int_t line;
    va_list ap;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    filename = duk_api_global_filename;
    line = duk_api_global_line;
    duk_api_global_filename = NULL;
    duk_api_global_line = 0;
 
    va_start(ap, fmt);
    duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap);
    va_end(ap);
    duk_throw(ctx);
}

References duk_api_global_filename, duk_api_global_line, DUK_ASSERT_CTX_VALID, duk_push_error_object_va_raw(), duk_throw(), and NULL.

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 at line 4367 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                                                                {
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap);
    duk_throw(ctx);
}

References DUK_ASSERT_CTX_VALID, duk_push_error_object_va_raw(), and duk_throw().

duk_fatal()

DUK_EXTERNAL void duk_fatal	(	duk_context *	ctx,
		duk_errcode_t	err_code,
		const char *	err_msg )

Definition at line 4347 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                           {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->heap != NULL);
    DUK_ASSERT(thr->heap->fatal_func != NULL);
 
    DUK_D(DUK_DPRINT("fatal error occurred, code %ld, message %s",
                     (long) err_code, (const char *) err_msg));
 
    /* fatal_func should be noreturn, but noreturn declarations on function
     * pointers has a very spotty support apparently so it's not currently
     * done.
     */
    thr->heap->fatal_func(ctx, err_code, err_msg);
 
    DUK_PANIC(DUK_ERR_API_ERROR, "fatal handler returned");
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_D, DUK_DPRINT, DUK_ERR_API_ERROR, DUK_PANIC, duk_heap::fatal_func, duk_hthread::heap, and NULL.

duk_get_boolean()

DUK_EXTERNAL duk_bool_t duk_get_boolean	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1092 of file duktape-1.5.2/src-separate/duk_api_stack.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;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_tval(), DUK_TVAL_GET_BOOLEAN, DUK_TVAL_IS_BOOLEAN, and index.

duk_get_borrowed_this_tval()

DUK_INTERNAL duk_tval * duk_get_borrowed_this_tval

(

duk_context *

ctx

)

Definition at line 3334 of file duktape-1.5.2/src-separate/duk_api_stack.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;
}

References duk_hthread::callstack_top, DUK_ASSERT, NULL, duk_hthread::valstack, and duk_hthread::valstack_bottom.

duk_get_buffer()

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

Definition at line 1324 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                           {
    return duk__get_buffer_helper(ctx, index, out_size, 0 /*throw_flag*/);
}

References duk__get_buffer_helper(), and index.

duk_get_buffer_data()

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

Definition at line 1386 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                {
    return duk__get_buffer_data_helper(ctx, index, out_size, 0 /*throw_flag*/);
}

References duk__get_buffer_data_helper(), and index.

duk_get_c_function()

DUK_EXTERNAL duk_c_function duk_get_c_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1505 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                  {
    duk_tval *tv;
    duk_hobject *h;
    duk_hnativefunction *f;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (!tv) {
        return NULL;
    }
    if (!DUK_TVAL_IS_OBJECT(tv)) {
        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));
    f = (duk_hnativefunction *) h;
 
    return f->func;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_tval(), DUK_HOBJECT_HAS_NATIVEFUNCTION, DUK_HOBJECT_IS_NATIVEFUNCTION, DUK_TVAL_GET_OBJECT, DUK_TVAL_IS_OBJECT, duk_hnativefunction::func, index, and NULL.

Referenced by duk_require_c_function().

duk_get_context()

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

Definition at line 1550 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                             {
    DUK_ASSERT_CTX_VALID(ctx);
 
    return (duk_context *) duk_get_hthread(ctx, index);
}

References DUK_ASSERT_CTX_VALID, duk_get_hthread(), and index.

duk_get_error_code()

DUK_EXTERNAL duk_errcode_t duk_get_error_code	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2916 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                 {
    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]) {
            return DUK_ERR_SYNTAX_ERROR;
        }
        if (h == thr->builtins[DUK_BIDX_TYPE_ERROR_PROTOTYPE]) {
            return DUK_ERR_TYPE_ERROR;
        }
        if (h == thr->builtins[DUK_BIDX_URI_ERROR_PROTOTYPE]) {
            return DUK_ERR_URI_ERROR;
        }
        if (h == thr->builtins[DUK_BIDX_ERROR_PROTOTYPE]) {
            return DUK_ERR_ERROR;
        }
 
        h = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h);
    } while (--sanity > 0);
 
    return DUK_ERR_NONE;
}

References duk_hthread::builtins, DUK_ASSERT_CTX_VALID, DUK_BIDX_ERROR_PROTOTYPE, DUK_BIDX_EVAL_ERROR_PROTOTYPE, DUK_BIDX_RANGE_ERROR_PROTOTYPE, DUK_BIDX_REFERENCE_ERROR_PROTOTYPE, DUK_BIDX_SYNTAX_ERROR_PROTOTYPE, DUK_BIDX_TYPE_ERROR_PROTOTYPE, DUK_BIDX_URI_ERROR_PROTOTYPE, DUK_ERR_ERROR, DUK_ERR_EVAL_ERROR, DUK_ERR_NONE, DUK_ERR_RANGE_ERROR, DUK_ERR_REFERENCE_ERROR, DUK_ERR_SYNTAX_ERROR, DUK_ERR_TYPE_ERROR, DUK_ERR_URI_ERROR, duk_get_hobject(), DUK_HOBJECT_GET_PROTOTYPE, DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY, duk_hthread::heap, and index.

duk_get_hbuffer()

DUK_INTERNAL duk_hbuffer * duk_get_hbuffer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1441 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                             {
    return (duk_hbuffer *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_BUFFER);
}

References duk__get_tagged_heaphdr_raw(), DUK_TAG_BUFFER, and index.

Referenced by duk_to_buffer_raw().

duk_get_hcompiledfunction()

DUK_INTERNAL duk_hcompiledfunction * duk_get_hcompiledfunction	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1471 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                 {
    duk_hobject *h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
    if (h != NULL && !DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
        h = NULL;
    }
    return (duk_hcompiledfunction *) h;
}

References duk__get_tagged_heaphdr_raw(), DUK_HOBJECT_IS_COMPILEDFUNCTION, DUK_TAG_OBJECT, index, and NULL.

duk_get_heapptr()

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

Definition at line 1562 of file duktape-1.5.2/src-separate/duk_api_stack.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;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_tval(), DUK_TVAL_GET_HEAPHDR, DUK_TVAL_IS_HEAP_ALLOCATED, index, and NULL.

duk_get_hnativefunction()

DUK_INTERNAL duk_hnativefunction * duk_get_hnativefunction	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1488 of file duktape-1.5.2/src-separate/duk_api_stack.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;
}

References duk__get_tagged_heaphdr_raw(), DUK_HOBJECT_IS_NATIVEFUNCTION, DUK_TAG_OBJECT, index, and NULL.

Referenced by duk_to_object().

duk_get_hobject()

DUK_INTERNAL duk_hobject * duk_get_hobject	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1428 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                             {
    return (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
}

References duk__get_tagged_heaphdr_raw(), DUK_TAG_OBJECT, and index.

Referenced by duk__obj_flag_any_default_false(), duk_get_error_code(), duk_is_array(), duk_push_object_helper_proto(), duk_push_this_coercible_to_object(), duk_set_length(), and duk_to_object_class_string_top().

duk_get_hobject_or_lfunc_coerce()

DUK_INTERNAL duk_hobject * duk_get_hobject_or_lfunc_coerce	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1610 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                             {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);
    if (DUK_TVAL_IS_OBJECT(tv)) {
        return DUK_TVAL_GET_OBJECT(tv);
    } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
        duk_to_object(ctx, index);
        return duk_require_hobject(ctx, index);
    }
 
    return NULL;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_require_hobject(), duk_require_tval(), duk_to_object(), DUK_TVAL_GET_OBJECT, DUK_TVAL_IS_LIGHTFUNC, DUK_TVAL_IS_OBJECT, index, and NULL.

duk_get_hobject_with_class()

DUK_INTERNAL duk_hobject * duk_get_hobject_with_class	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_small_uint_t	classnum )

Definition at line 1668 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                                   {
    duk_hobject *h;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT_DISABLE(classnum >= 0);  /* unsigned */
    DUK_ASSERT(classnum <= DUK_HOBJECT_CLASS_MAX);
 
    h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
    if (h != NULL && DUK_HOBJECT_GET_CLASS_NUMBER(h) != classnum) {
        h = NULL;
    }
    return h;
}

References duk__get_tagged_heaphdr_raw(), DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ASSERT_DISABLE, DUK_HOBJECT_CLASS_MAX, DUK_HOBJECT_GET_CLASS_NUMBER, DUK_TAG_OBJECT, index, and NULL.

duk_get_hstring()

DUK_INTERNAL duk_hstring * duk_get_hstring	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1415 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                             {
    return (duk_hstring *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_STRING);
}

References duk__get_tagged_heaphdr_raw(), DUK_TAG_STRING, and index.

Referenced by duk_push_this_coercible_to_string(), and duk_to_hstring().

duk_get_hthread()

DUK_INTERNAL duk_hthread * duk_get_hthread	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1454 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                             {
    duk_hobject *h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
    if (h != NULL && !DUK_HOBJECT_IS_THREAD(h)) {
        h = NULL;
    }
    return (duk_hthread *) h;
}

References duk__get_tagged_heaphdr_raw(), DUK_HOBJECT_IS_THREAD, DUK_TAG_OBJECT, index, and NULL.

Referenced by duk_get_context().

duk_get_int()

DUK_EXTERNAL duk_int_t duk_get_int	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1167 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                      {
    /* Custom coercion for API */
    DUK_ASSERT_CTX_VALID(ctx);
    return (duk_int_t) duk__api_coerce_d2i(ctx, index, 0 /*require*/);
}

References duk__api_coerce_d2i(), DUK_ASSERT_CTX_VALID, and index.

duk_get_length()

DUK_EXTERNAL duk_size_t duk_get_length	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1702 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                          {
    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);
    }
    case DUK_TAG_LIGHTFUNC: {
        duk_small_uint_t lf_flags;
        lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv);
        return (duk_size_t) DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags);
    }
#if defined(DUK_USE_FASTINT)
    case DUK_TAG_FASTINT:
#endif
    default:
        /* number */
        DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv));
        DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
        return 0;
    }
 
    DUK_UNREACHABLE();
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_tval(), DUK_HBUFFER_GET_SIZE, duk_hobject_get_length(), DUK_HSTRING_GET_CHARLEN, DUK_LFUNC_FLAGS_GET_LENGTH, DUK_TAG_BOOLEAN, DUK_TAG_BUFFER, DUK_TAG_LIGHTFUNC, DUK_TAG_NULL, DUK_TAG_OBJECT, DUK_TAG_POINTER, DUK_TAG_STRING, DUK_TAG_UNDEFINED, DUK_TVAL_GET_BUFFER, DUK_TVAL_GET_LIGHTFUNC_FLAGS, DUK_TVAL_GET_OBJECT, DUK_TVAL_GET_STRING, DUK_TVAL_GET_TAG, DUK_TVAL_IS_NUMBER, DUK_TVAL_IS_UNUSED, DUK_UNREACHABLE, index, and NULL.

duk_get_lstring()

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

Definition at line 1191 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                 {
    const char *ret;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* default: NULL, length 0 */
    ret = NULL;
    if (out_len) {
        *out_len = 0;
    }
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_STRING(tv)) {
        /* 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;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_tval(), DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_DATA, DUK_TVAL_GET_STRING, DUK_TVAL_IS_STRING, index, and NULL.

Referenced by duk_get_string(), duk_require_lstring(), and duk_safe_to_lstring().

duk_get_number()

DUK_EXTERNAL duk_double_t duk_get_number	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1123 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                            {
    duk_double_union ret;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    ret.d = DUK_DOUBLE_NAN;  /* default: NaN */
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_NUMBER(tv)) {
        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;
}

References duk_double_union::d, DUK_ASSERT_CTX_VALID, DUK_DBLUNION_NORMALIZE_NAN_CHECK, DUK_DOUBLE_NAN, duk_get_tval(), DUK_TVAL_GET_NUMBER, DUK_TVAL_IS_NUMBER, and index.

duk_get_pointer()

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

Definition at line 1248 of file duktape-1.5.2/src-separate/duk_api_stack.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;
}

References DUK_ASSERT_CTX_VALID, duk_get_tval(), DUK_TVAL_GET_POINTER, DUK_TVAL_IS_POINTER, index, and NULL.

duk_get_string()

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

Definition at line 1236 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                           {
    DUK_ASSERT_CTX_VALID(ctx);
 
    return duk_get_lstring(ctx, index, NULL);
}

References DUK_ASSERT_CTX_VALID, duk_get_lstring(), index, and NULL.

Referenced by duk_safe_to_lstring().

duk_get_top()

DUK_EXTERNAL duk_idx_t duk_get_top

(

duk_context *

ctx

)

Definition at line 331 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                     {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    return (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
}

References DUK_ASSERT_CTX_VALID, duk_hthread::valstack_bottom, and duk_hthread::valstack_top.

duk_get_top_index()

DUK_EXTERNAL duk_idx_t duk_get_top_index

(

duk_context *

ctx

)

Definition at line 434 of file duktape-1.5.2/src-separate/duk_api_stack.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;
    }
    return ret;
}

References DUK_ASSERT_CTX_VALID, DUK_INVALID_INDEX, DUK_UNLIKELY, duk_hthread::valstack_bottom, and duk_hthread::valstack_top.

duk_get_tval()

DUK_INTERNAL duk_tval * duk_get_tval	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 248 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                       {
    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 */
 
    if (index < 0) {
        uindex = vs_size + (duk_uidx_t) index;
    } else {
        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 thr->valstack_bottom + uindex;
    }
    return NULL;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ASSERT_DISABLE, DUK_INVALID_INDEX, DUK_LIKELY, index, NULL, duk_hthread::valstack_bottom, and duk_hthread::valstack_top.

Referenced by duk__api_coerce_d2i(), duk__api_coerce_d2ui(), duk__get_buffer_data_helper(), duk__get_buffer_helper(), duk__get_tagged_heaphdr_raw(), duk__tag_check(), duk_equals(), duk_get_boolean(), duk_get_c_function(), duk_get_heapptr(), duk_get_length(), duk_get_lstring(), duk_get_number(), duk_get_pointer(), duk_get_type(), duk_get_type_mask(), duk_is_dynamic_buffer(), duk_is_external_buffer(), duk_is_fixed_buffer(), duk_is_function(), duk_is_nan(), duk_is_null_or_undefined(), duk_is_number(), duk_push_string_readable(), duk_require_boolean(), duk_require_null(), duk_require_number(), duk_require_pointer(), duk_require_undefined(), duk_strict_equals(), duk_throw(), and duk_to_int_clamped_raw().

duk_get_type()

DUK_EXTERNAL duk_int_t duk_get_type	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2605 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                       {
    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;
    case DUK_TAG_BUFFER:
        return DUK_TYPE_BUFFER;
    case DUK_TAG_POINTER:
        return DUK_TYPE_POINTER;
    case DUK_TAG_LIGHTFUNC:
        return DUK_TYPE_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_NUMBER;
    }
    DUK_UNREACHABLE();
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_tval(), DUK_TAG_BOOLEAN, DUK_TAG_BUFFER, DUK_TAG_LIGHTFUNC, DUK_TAG_NULL, DUK_TAG_OBJECT, DUK_TAG_POINTER, DUK_TAG_STRING, DUK_TAG_UNDEFINED, DUK_TVAL_GET_TAG, DUK_TVAL_IS_NUMBER, DUK_TVAL_IS_UNUSED, DUK_TYPE_BOOLEAN, DUK_TYPE_BUFFER, DUK_TYPE_LIGHTFUNC, DUK_TYPE_NONE, DUK_TYPE_NULL, DUK_TYPE_NUMBER, DUK_TYPE_OBJECT, DUK_TYPE_POINTER, DUK_TYPE_STRING, DUK_TYPE_UNDEFINED, DUK_UNREACHABLE, and index.

Referenced by duk_check_type().

duk_get_type_mask()

DUK_EXTERNAL duk_uint_t duk_get_type_mask	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2674 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                             {
    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;
    case DUK_TAG_BUFFER:
        return DUK_TYPE_MASK_BUFFER;
    case DUK_TAG_POINTER:
        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_UNREACHABLE();
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_tval(), DUK_TAG_BOOLEAN, DUK_TAG_BUFFER, DUK_TAG_LIGHTFUNC, DUK_TAG_NULL, DUK_TAG_OBJECT, DUK_TAG_POINTER, DUK_TAG_STRING, DUK_TAG_UNDEFINED, DUK_TVAL_GET_TAG, DUK_TVAL_IS_NUMBER, DUK_TVAL_IS_UNUSED, DUK_TYPE_MASK_BOOLEAN, DUK_TYPE_MASK_BUFFER, DUK_TYPE_MASK_LIGHTFUNC, DUK_TYPE_MASK_NONE, DUK_TYPE_MASK_NULL, DUK_TYPE_MASK_NUMBER, DUK_TYPE_MASK_OBJECT, DUK_TYPE_MASK_POINTER, DUK_TYPE_MASK_STRING, DUK_TYPE_MASK_UNDEFINED, DUK_UNREACHABLE, and index.

Referenced by duk_check_type_mask(), and duk_to_object_class_string_top().

duk_get_uint()

DUK_EXTERNAL duk_uint_t duk_get_uint	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1173 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                        {
    /* Custom coercion for API */
    DUK_ASSERT_CTX_VALID(ctx);
    return (duk_uint_t) duk__api_coerce_d2ui(ctx, index, 0 /*require*/);
}

References duk__api_coerce_d2ui(), DUK_ASSERT_CTX_VALID, and index.

duk_insert()

DUK_EXTERNAL void duk_insert	(	duk_context *	ctx,
		duk_idx_t	to_index )

Definition at line 867 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                   {
    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_DDD(DUK_DDDPRINT("duk_insert: 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);
    }
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_DDD, DUK_DDDPRINT, DUK_MEMMOVE, duk_require_tval(), DUK_TVAL_SET_TVAL, and NULL.

duk_instanceof()

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

Definition at line 4446 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                             {
    duk_tval *tv1, *tv2;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* Index validation is strict, which differs from duk_equals().
     * The strict behavior mimics how instanceof itself works, e.g.
     * it is a TypeError if rval is not a -callable- object.  It would
     * be somewhat inconsistent if rval would be allowed to be
     * non-existent without a TypeError.
     */
    tv1 = duk_require_tval(ctx, index1);
    DUK_ASSERT(tv1 != NULL);
    tv2 = duk_require_tval(ctx, index2);
    DUK_ASSERT(tv2 != NULL);
 
    return duk_js_instanceof((duk_hthread *) ctx, tv1, tv2);
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_js_instanceof(), duk_require_tval(), and NULL.

duk_is_array()

DUK_EXTERNAL duk_bool_t duk_is_array	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2818 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                        {
    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;
}

References DUK_ASSERT_CTX_VALID, duk_get_hobject(), DUK_HOBJECT_CLASS_ARRAY, DUK_HOBJECT_GET_CLASS_NUMBER, and index.

duk_is_boolean()

DUK_EXTERNAL duk_bool_t duk_is_boolean	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2751 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                          {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_BOOLEAN);
}

References duk__tag_check(), DUK_ASSERT_CTX_VALID, DUK_TAG_BOOLEAN, and index.

duk_is_bound_function()

DUK_EXTERNAL duk_bool_t duk_is_bound_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2860 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                 {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__obj_flag_any_default_false(ctx,
                                           index,
                                           DUK_HOBJECT_FLAG_BOUND);
}

References duk__obj_flag_any_default_false(), DUK_ASSERT_CTX_VALID, DUK_HOBJECT_FLAG_BOUND, and index.

duk_is_buffer()

DUK_EXTERNAL duk_bool_t duk_is_buffer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2803 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                         {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_BUFFER);
}

References duk__tag_check(), DUK_ASSERT_CTX_VALID, DUK_TAG_BUFFER, and index.

duk_is_c_function()

DUK_EXTERNAL duk_bool_t duk_is_c_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2846 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                             {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__obj_flag_any_default_false(ctx,
                                           index,
                                           DUK_HOBJECT_FLAG_NATIVEFUNCTION);
}

References duk__obj_flag_any_default_false(), DUK_ASSERT_CTX_VALID, DUK_HOBJECT_FLAG_NATIVEFUNCTION, and index.

duk_is_dynamic_buffer()

DUK_EXTERNAL duk_bool_t duk_is_dynamic_buffer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2888 of file duktape-1.5.2/src-separate/duk_api_stack.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;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_tval(), DUK_HBUFFER_HAS_DYNAMIC, DUK_HBUFFER_HAS_EXTERNAL, DUK_TVAL_GET_BUFFER, DUK_TVAL_IS_BUFFER, index, and NULL.

duk_is_ecmascript_function()

DUK_EXTERNAL duk_bool_t duk_is_ecmascript_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2853 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                      {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__obj_flag_any_default_false(ctx,
                                           index,
                                           DUK_HOBJECT_FLAG_COMPILEDFUNCTION);
}

References duk__obj_flag_any_default_false(), DUK_ASSERT_CTX_VALID, DUK_HOBJECT_FLAG_COMPILEDFUNCTION, and index.

duk_is_external_buffer()

DUK_EXTERNAL duk_bool_t duk_is_external_buffer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2902 of file duktape-1.5.2/src-separate/duk_api_stack.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;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_tval(), DUK_HBUFFER_HAS_DYNAMIC, DUK_HBUFFER_HAS_EXTERNAL, DUK_TVAL_GET_BUFFER, DUK_TVAL_IS_BUFFER, index, and NULL.

duk_is_fixed_buffer()

DUK_EXTERNAL duk_bool_t duk_is_fixed_buffer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2874 of file duktape-1.5.2/src-separate/duk_api_stack.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);
    }
    return 0;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_tval(), DUK_HBUFFER_HAS_DYNAMIC, DUK_TVAL_GET_BUFFER, DUK_TVAL_IS_BUFFER, index, and NULL.

duk_is_function()

DUK_EXTERNAL duk_bool_t duk_is_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2830 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                           {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (tv && DUK_TVAL_IS_LIGHTFUNC(tv)) {
        return 1;
    }
    return duk__obj_flag_any_default_false(ctx,
                                           index,
                                           DUK_HOBJECT_FLAG_COMPILEDFUNCTION |
                                           DUK_HOBJECT_FLAG_NATIVEFUNCTION |
                                           DUK_HOBJECT_FLAG_BOUND);
}

References duk__obj_flag_any_default_false(), DUK_ASSERT_CTX_VALID, duk_get_tval(), DUK_HOBJECT_FLAG_BOUND, DUK_HOBJECT_FLAG_COMPILEDFUNCTION, DUK_HOBJECT_FLAG_NATIVEFUNCTION, DUK_TVAL_IS_LIGHTFUNC, and index.

Referenced by duk_require_function().

duk_is_lightfunc()

DUK_EXTERNAL duk_bool_t duk_is_lightfunc	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2813 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                            {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_LIGHTFUNC);
}

References duk__tag_check(), DUK_ASSERT_CTX_VALID, DUK_TAG_LIGHTFUNC, and index.

duk_is_nan()

DUK_EXTERNAL duk_bool_t duk_is_nan	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2775 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                      {
    /* XXX: This will now return false for non-numbers, even though they would
     * coerce to NaN (as a general rule).  In particular, duk_get_number()
     * returns a NaN for non-numbers, so should this function also return
     * true for non-numbers?
     */
 
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (!tv || !DUK_TVAL_IS_NUMBER(tv)) {
        return 0;
    }
    return DUK_ISNAN(DUK_TVAL_GET_NUMBER(tv));
}

References DUK_ASSERT_CTX_VALID, duk_get_tval(), DUK_ISNAN, DUK_TVAL_GET_NUMBER, DUK_TVAL_IS_NUMBER, and index.

duk_is_null()

DUK_EXTERNAL duk_bool_t duk_is_null	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2732 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                       {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_NULL);
}

References duk__tag_check(), DUK_ASSERT_CTX_VALID, DUK_TAG_NULL, and index.

duk_is_null_or_undefined()

DUK_EXTERNAL duk_bool_t duk_is_null_or_undefined	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2737 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                    {
    duk_tval *tv;
    duk_small_uint_t tag;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_get_tval(ctx, index);
    if (!tv) {
        return 0;
    }
    tag = DUK_TVAL_GET_TAG(tv);
    return (tag == DUK_TAG_UNDEFINED) || (tag == DUK_TAG_NULL);
}

References DUK_ASSERT_CTX_VALID, duk_get_tval(), DUK_TAG_NULL, DUK_TAG_UNDEFINED, DUK_TVAL_GET_TAG, and index.

duk_is_number()

DUK_EXTERNAL duk_bool_t duk_is_number	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2756 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                         {
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /*
     *  Number is special because it doesn't have a specific
     *  tag in the 8-byte representation.
     */
 
    /* XXX: shorter version for 12-byte representation? */
 
    tv = duk_get_tval(ctx, index);
    if (!tv) {
        return 0;
    }
    return DUK_TVAL_IS_NUMBER(tv);
}

References DUK_ASSERT_CTX_VALID, duk_get_tval(), DUK_TVAL_IS_NUMBER, and index.

duk_is_object()

DUK_EXTERNAL duk_bool_t duk_is_object	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2798 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                         {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_OBJECT);
}

References duk__tag_check(), DUK_ASSERT_CTX_VALID, DUK_TAG_OBJECT, and index.

duk_is_pointer()

DUK_EXTERNAL duk_bool_t duk_is_pointer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2808 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                          {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_POINTER);
}

References duk__tag_check(), DUK_ASSERT_CTX_VALID, DUK_TAG_POINTER, and index.

duk_is_string()

DUK_EXTERNAL duk_bool_t duk_is_string	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2793 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                         {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_STRING);
}

References duk__tag_check(), DUK_ASSERT_CTX_VALID, DUK_TAG_STRING, and index.

Referenced by duk_safe_to_lstring().

duk_is_thread()

DUK_EXTERNAL duk_bool_t duk_is_thread	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2867 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                         {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__obj_flag_any_default_false(ctx,
                                           index,
                                           DUK_HOBJECT_FLAG_THREAD);
}

References duk__obj_flag_any_default_false(), DUK_ASSERT_CTX_VALID, DUK_HOBJECT_FLAG_THREAD, and index.

duk_is_undefined()

DUK_EXTERNAL duk_bool_t duk_is_undefined	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2727 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                            {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk__tag_check(ctx, index, DUK_TAG_UNDEFINED);
}

References duk__tag_check(), DUK_ASSERT_CTX_VALID, DUK_TAG_UNDEFINED, and index.

duk_is_valid_index()

DUK_EXTERNAL duk_bool_t duk_is_valid_index	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 307 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                              {
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(DUK_INVALID_INDEX < 0);
 
    return (duk_normalize_index(ctx, index) >= 0);
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_INVALID_INDEX, duk_normalize_index(), and index.

duk_normalize_index()

DUK_EXTERNAL duk_idx_t duk_normalize_index	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 183 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                              {
    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 */
 
    if (index < 0) {
        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;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ASSERT_DISABLE, DUK_INVALID_INDEX, DUK_LIKELY, index, duk_hthread::valstack_bottom, and duk_hthread::valstack_top.

Referenced by duk_is_valid_index(), and duk_require_valid_index().

duk_pop()

DUK_EXTERNAL void duk_pop

(

duk_context *

ctx

)

Definition at line 4273 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                            {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    DUK_ASSERT_CTX_VALID(ctx);
 
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    if (DUK_UNLIKELY(thr->valstack_top == thr->valstack_bottom)) {
        DUK_ERROR_API(thr, DUK_STR_POP_TOO_MANY);
    }
 
    tv = --thr->valstack_top;  /* tv points to element just below prev top */
    DUK_ASSERT(tv >= thr->valstack_bottom);
#ifdef DUK_USE_REFERENCE_COUNTING
    DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv);  /* side effects */
#else
    DUK_TVAL_SET_UNDEFINED(tv);
#endif
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ERROR_API, DUK_STR_POP_TOO_MANY, DUK_TVAL_SET_UNDEFINED, DUK_TVAL_SET_UNDEFINED_UPDREF, DUK_UNLIKELY, duk_hthread::valstack_bottom, and duk_hthread::valstack_top.

Referenced by duk__defaultvalue_coerce_attempt(), duk__push_stash(), duk_safe_to_lstring(), and duk_to_object_class_string_top().

duk_pop_2()

DUK_EXTERNAL void duk_pop_2

(

duk_context *

ctx

)

Definition at line 4294 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                              {
    DUK_ASSERT_CTX_VALID(ctx);
    duk_pop_n(ctx, 2);
}

References DUK_ASSERT_CTX_VALID, and duk_pop_n().

duk_pop_3()

DUK_EXTERNAL void duk_pop_3

(

duk_context *

ctx

)

Definition at line 4299 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                              {
    DUK_ASSERT_CTX_VALID(ctx);
    duk_pop_n(ctx, 3);
}

References DUK_ASSERT_CTX_VALID, and duk_pop_n().

duk_pop_n()

DUK_EXTERNAL void duk_pop_n	(	duk_context *	ctx,
		duk_idx_t	count )

Definition at line 4215 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                               {
    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--;
        tv = --thr->valstack_top;  /* tv points to element just below prev top */
        DUK_ASSERT(tv >= thr->valstack_bottom);
        DUK_TVAL_SET_UNDEFINED_UPDREF(thr, tv);  /* side effects */
    }
#else
    tv = thr->valstack_top;
    while (count > 0) {
        count--;
        tv--;
        DUK_ASSERT(tv >= thr->valstack_bottom);
        DUK_TVAL_SET_UNDEFINED(tv);
    }
    thr->valstack_top = tv;
#endif
 
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ERROR_API, DUK_STR_INVALID_COUNT, DUK_STR_POP_TOO_MANY, DUK_TVAL_SET_UNDEFINED, DUK_TVAL_SET_UNDEFINED_UPDREF, DUK_UNLIKELY, duk_hthread::valstack_bottom, and duk_hthread::valstack_top.

Referenced by duk_pop_2(), and duk_pop_3().

duk_push_array()

DUK_EXTERNAL duk_idx_t duk_push_array

(

duk_context *

ctx

)

Definition at line 3585 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                        {
    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.
     *
     *  The internal property must be a number (and preferably a
     *  fastint if fastint support is enabled).
     */
 
    duk_push_int(ctx, 0);
#if defined(DUK_USE_FASTINT)
    DUK_ASSERT(DUK_TVAL_IS_FASTINT(duk_require_tval(ctx, -1)));
#endif
 
    duk_hobject_define_property_internal(thr,
                                         obj,
                                         DUK_HTHREAD_STRING_LENGTH(thr),
                                         DUK_PROPDESC_FLAGS_W);
    DUK_HOBJECT_SET_EXOTIC_ARRAY(obj);
 
    return ret;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_BIDX_ARRAY_PROTOTYPE, DUK_HOBJECT_CLASS_ARRAY, DUK_HOBJECT_CLASS_AS_FLAGS, duk_hobject_define_property_internal(), DUK_HOBJECT_FLAG_ARRAY_PART, DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_HOBJECT_SET_EXOTIC_ARRAY, DUK_HTHREAD_STRING_LENGTH, DUK_PROPDESC_FLAGS_W, duk_push_int(), duk_push_object_helper(), duk_require_hobject(), and duk_require_tval().

duk_push_boolean()

DUK_EXTERNAL void duk_push_boolean	(	duk_context *	ctx,
		duk_bool_t	val )

Definition at line 3000 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                     {
    duk_hthread *thr;
    duk_tval *tv_slot;
    duk_small_int_t b;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
    b = (val ? 1 : 0);  /* ensure value is 1 or 0 (not other non-zero) */
    tv_slot = thr->valstack_top++;
    DUK_TVAL_SET_BOOLEAN(tv_slot, b);
}

References DUK__CHECK_SPACE, DUK_ASSERT_CTX_VALID, DUK_TVAL_SET_BOOLEAN, and duk_hthread::valstack_top.

duk_push_buffer_object()

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 )

Definition at line 3921 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                                                                   {
    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_ASSERT_HBUFFEROBJECT_VALID(h_bufobj);
 
        duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LC_BUFFER, DUK_PROPDESC_FLAGS_NONE);
        duk_compact(ctx, -1);
    }
#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
    return;
 
 range_error:
    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 */
}

References duk_hbufferobject::buf, duk__bufobj_flags_lookup, DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ASSERT_DISABLE, DUK_ASSERT_HBUFFEROBJECT_VALID, DUK_BIDX_ARRAYBUFFER_PROTOTYPE, DUK_BUFOBJ_CREATE_ARRBUF, duk_compact(), DUK_ERROR_RANGE, DUK_ERROR_TYPE, DUK_HBUFFER_INCREF, DUK_HBUFFEROBJECT_ELEM_UINT8, DUK_HOBJECT_CLASS_ARRAYBUFFER, DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_FLAG_BUFFEROBJECT, DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_PROPDESC_FLAGS_NONE, duk_push_bufferobject_raw(), duk_require_hbuffer(), DUK_STR_INVALID_CALL_ARGS, DUK_STRIDX_LC_BUFFER, DUK_UNREF, duk_xdef_prop_stridx(), duk_hbufferobject::elem_type, duk_hbufferobject::is_view, duk_hbufferobject::length, NULL, duk_hbufferobject::offset, and duk_hbufferobject::shift.

duk_push_buffer_raw()

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

Definition at line 4101 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                  {
    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);
    }
 
    /* Check for maximum buffer length. */
    if (size > DUK_HBUFFER_MAX_BYTELEN) {
        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;
}

References DUK_ASSERT_CTX_VALID, DUK_ERROR_ALLOC_DEFMSG, DUK_ERROR_API, DUK_ERROR_RANGE, duk_hbuffer_alloc(), DUK_HBUFFER_INCREF, DUK_HBUFFER_MAX_BYTELEN, DUK_STR_BUFFER_TOO_LONG, DUK_STR_PUSH_BEYOND_ALLOC_STACK, DUK_TVAL_SET_BUFFER, duk_hthread::heap, duk_hthread::valstack_end, and duk_hthread::valstack_top.

duk_push_bufferobject_raw()

DUK_INTERNAL duk_hbufferobject * duk_push_bufferobject_raw	(	duk_context *	ctx,
		duk_uint_t	hobject_flags_and_class,
		duk_small_int_t	prototype_bidx )

Definition at line 3862 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                                                                {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hbufferobject *obj;
    duk_tval *tv_slot;
 
    DUK_ASSERT(ctx != NULL);
    DUK_ASSERT(prototype_bidx >= 0);
 
    /* check stack first */
    if (thr->valstack_top >= thr->valstack_end) {
        DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
    }
 
    obj = duk_hbufferobject_alloc(thr->heap, hobject_flags_and_class);
    if (!obj) {
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
 
    DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) obj, thr->builtins[prototype_bidx]);
    DUK_ASSERT_HBUFFEROBJECT_VALID(obj);
 
    tv_slot = thr->valstack_top;
    DUK_TVAL_SET_OBJECT(tv_slot, (duk_hobject *) obj);
    DUK_HOBJECT_INCREF(thr, obj);
    thr->valstack_top++;
 
    return obj;
}

References duk_hthread::builtins, DUK_ASSERT, DUK_ASSERT_HBUFFEROBJECT_VALID, DUK_ERROR_ALLOC_DEFMSG, DUK_ERROR_API, duk_hbufferobject_alloc(), DUK_HOBJECT_INCREF, DUK_HOBJECT_SET_PROTOTYPE_UPDREF, DUK_STR_PUSH_BEYOND_ALLOC_STACK, DUK_TVAL_SET_OBJECT, duk_hthread::heap, NULL, duk_hthread::valstack_end, and duk_hthread::valstack_top.

Referenced by duk_push_buffer_object(), and duk_to_object().

duk_push_c_function()

DUK_EXTERNAL duk_idx_t duk_push_c_function	(	duk_context *	ctx,
		duk_c_function	func,
		duk_int_t	nargs )

Definition at line 3777 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                   {
    duk_uint_t flags;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    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 |
            DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION);
 
    return duk__push_c_function_raw(ctx, func, nargs, flags);
}

References duk__push_c_function_raw(), DUK_ASSERT_CTX_VALID, DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_CLASS_FUNCTION, DUK_HOBJECT_FLAG_CONSTRUCTABLE, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC, DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_HOBJECT_FLAG_NATIVEFUNCTION, DUK_HOBJECT_FLAG_NEWENV, DUK_HOBJECT_FLAG_NOTAIL, and DUK_HOBJECT_FLAG_STRICT.

duk_push_c_function_noconstruct_noexotic()

DUK_INTERNAL void duk_push_c_function_noconstruct_noexotic	(	duk_context *	ctx,
		duk_c_function	func,
		duk_int_t	nargs )

Definition at line 3810 of file duktape-1.5.2/src-separate/duk_api_stack.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);
}

References duk__push_c_function_raw(), DUK_ASSERT_CTX_VALID, DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_CLASS_FUNCTION, DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_HOBJECT_FLAG_NATIVEFUNCTION, DUK_HOBJECT_FLAG_NEWENV, DUK_HOBJECT_FLAG_NOTAIL, and DUK_HOBJECT_FLAG_STRICT.

duk_push_c_function_noexotic()

DUK_INTERNAL void duk_push_c_function_noexotic	(	duk_context *	ctx,
		duk_c_function	func,
		duk_int_t	nargs )

Definition at line 3794 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                       {
    duk_uint_t flags;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    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_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION);
 
    (void) duk__push_c_function_raw(ctx, func, nargs, flags);
}

References duk__push_c_function_raw(), DUK_ASSERT_CTX_VALID, DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_CLASS_FUNCTION, DUK_HOBJECT_FLAG_CONSTRUCTABLE, DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_HOBJECT_FLAG_NATIVEFUNCTION, DUK_HOBJECT_FLAG_NEWENV, DUK_HOBJECT_FLAG_NOTAIL, and DUK_HOBJECT_FLAG_STRICT.

duk_push_c_lightfunc()

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 )

Definition at line 3825 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                                                       {
    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;
    }
    if (!(length >= DUK_LFUNC_LENGTH_MIN && length <= DUK_LFUNC_LENGTH_MAX)) {
        goto api_error;
    }
    if (!(magic >= DUK_LFUNC_MAGIC_MIN && magic <= DUK_LFUNC_MAGIC_MAX)) {
        goto api_error;
    }
 
    lf_flags = DUK_LFUNC_FLAGS_PACK(magic, length, nargs);
    DUK_TVAL_SET_LIGHTFUNC(&tv_tmp, func, lf_flags);
    duk_push_tval(ctx, &tv_tmp);  /* XXX: direct valstack write */
    DUK_ASSERT(thr->valstack_top != thr->valstack_bottom);
    return ((duk_idx_t) (thr->valstack_top - thr->valstack_bottom)) - 1;
 
 api_error:
    DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS);
    return 0;  /* not reached */
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ERROR_API, DUK_LFUNC_FLAGS_PACK, DUK_LFUNC_LENGTH_MAX, DUK_LFUNC_LENGTH_MIN, DUK_LFUNC_MAGIC_MAX, DUK_LFUNC_MAGIC_MIN, DUK_LFUNC_NARGS_MAX, DUK_LFUNC_NARGS_MIN, DUK_LFUNC_NARGS_VARARGS, duk_push_tval(), DUK_STR_INVALID_CALL_ARGS, DUK_STR_PUSH_BEYOND_ALLOC_STACK, DUK_TVAL_SET_LIGHTFUNC, DUK_VARARGS, duk_hthread::valstack_bottom, duk_hthread::valstack_end, and duk_hthread::valstack_top.

duk_push_compiledfunction()

DUK_INTERNAL duk_idx_t duk_push_compiledfunction

(

duk_context *

ctx

)

Definition at line 3686 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                   {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hcompiledfunction *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);
    }
 
    /* Template functions are not strictly constructable (they don't
     * have a "prototype" property for instance), so leave the
     * DUK_HOBJECT_FLAG_CONSRUCTABLE flag cleared here.
     */
 
    obj = duk_hcompiledfunction_alloc(thr->heap,
                                      DUK_HOBJECT_FLAG_EXTENSIBLE |
                                      DUK_HOBJECT_FLAG_COMPILEDFUNCTION |
                                      DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION));
    if (!obj) {
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
 
    DUK_DDD(DUK_DDDPRINT("created compiled function object with flags: 0x%08lx", (unsigned long) obj->obj.hdr.h_flags));
 
    tv_slot = thr->valstack_top;
    DUK_TVAL_SET_OBJECT(tv_slot, (duk_hobject *) obj);
    DUK_HOBJECT_INCREF(thr, obj);
    ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
    thr->valstack_top++;
 
    /* default prototype (Note: 'obj' must be reachable) */
    DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) obj, thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]);
 
    return ret;
}

References duk_hthread::builtins, DUK_ASSERT_CTX_VALID, DUK_BIDX_FUNCTION_PROTOTYPE, DUK_DDD, DUK_DDDPRINT, DUK_ERROR_ALLOC_DEFMSG, DUK_ERROR_API, duk_hcompiledfunction_alloc(), DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_CLASS_FUNCTION, DUK_HOBJECT_FLAG_COMPILEDFUNCTION, DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_HOBJECT_INCREF, DUK_HOBJECT_SET_PROTOTYPE_UPDREF, DUK_STR_PUSH_BEYOND_ALLOC_STACK, DUK_TVAL_SET_OBJECT, duk_heaphdr::h_flags, duk_hobject::hdr, duk_hthread::heap, duk_hcompiledfunction::obj, duk_hthread::valstack_bottom, duk_hthread::valstack_end, and duk_hthread::valstack_top.

duk_push_current_function()

DUK_EXTERNAL void duk_push_current_function

(

duk_context *

ctx

)

Definition at line 3347 of file duktape-1.5.2/src-separate/duk_api_stack.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);
    } else {
        duk_push_undefined(ctx);
    }
}

References duk_hthread::callstack_size, duk_hthread::callstack_top, DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ASSERT_DISABLE, duk_hthread_get_current_activation(), duk_push_tval(), duk_push_undefined(), NULL, and duk_activation::tv_func.

duk_push_current_thread()

DUK_EXTERNAL void duk_push_current_thread

(

duk_context *

ctx

)

Definition at line 3364 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                            {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
 
    if (thr->heap->curr_thread) {
        duk_push_hobject(ctx, (duk_hobject *) thr->heap->curr_thread);
    } else {
        duk_push_undefined(ctx);
    }
}

References duk_heap::curr_thread, DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_push_hobject(), duk_push_undefined(), duk_hthread::heap, and NULL.

duk_push_error_object_raw()

DUK_EXTERNAL 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 4071 of file duktape-1.5.2/src-separate/duk_api_stack.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;
}

References DUK_ASSERT_CTX_VALID, and duk_push_error_object_va_raw().

duk_push_error_object_stash()

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

Definition at line 4084 of file duktape-1.5.2/src-separate/duk_api_stack.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;
}

References duk_api_global_filename, duk_api_global_line, DUK_ASSERT_CTX_VALID, duk_push_error_object_va_raw(), and NULL.

duk_push_error_object_va_raw()

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 )

Definition at line 4019 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                                                                                 {
    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
         * constructors use ToString() on their argument).  However, it's
         * probably more useful than having a separate 'code' property.
         */
        duk_push_int(ctx, err_code);
        duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE, DUK_PROPDESC_FLAGS_WC);
    }
 
    /* XXX: .code = err_code disabled, not sure if useful */
 
    /* Creation time error augmentation */
#ifdef DUK_USE_AUGMENT_ERROR_CREATE
    /* filename may be NULL in which case file/line is not recorded */
    duk_err_augment_error_create(thr, thr, filename, line, noblame_fileline);  /* may throw an error */
#endif
 
    return ret;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_err_augment_error_create(), DUK_ERRCODE_FLAG_NOBLAME_FILELINE, duk_error_prototype_from_code(), DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_CLASS_ERROR, DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_PROPDESC_FLAGS_WC, duk_push_int(), duk_push_object_helper_proto(), duk_push_vsprintf(), DUK_STRIDX_MESSAGE, DUK_UNREF, duk_xdef_prop_stridx(), NULL, and proto.

Referenced by duk_error_raw(), duk_error_stash(), duk_error_va_raw(), duk_push_error_object_raw(), and duk_push_error_object_stash().

duk_push_false()

DUK_EXTERNAL void duk_push_false

(

duk_context *

ctx

)

Definition at line 3024 of file duktape-1.5.2/src-separate/duk_api_stack.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_TVAL_SET_BOOLEAN_FALSE(tv_slot);
}

References DUK__CHECK_SPACE, DUK_ASSERT_CTX_VALID, DUK_TVAL_SET_BOOLEAN_FALSE, and duk_hthread::valstack_top.

duk_push_global_object()

DUK_EXTERNAL void duk_push_global_object

(

duk_context *

ctx

)

Definition at line 3377 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                           {
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk_push_hobject_bidx(ctx, DUK_BIDX_GLOBAL);
}

References DUK_ASSERT_CTX_VALID, DUK_BIDX_GLOBAL, and duk_push_hobject_bidx().

Referenced by duk_push_global_stash().

duk_push_global_stash()

DUK_EXTERNAL void duk_push_global_stash

(

duk_context *

ctx

)

Definition at line 3406 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                          {
    DUK_ASSERT_CTX_VALID(ctx);
    duk_push_global_object(ctx);
    duk__push_stash(ctx);
}

References duk__push_stash(), DUK_ASSERT_CTX_VALID, and duk_push_global_object().

duk_push_hbuffer()

DUK_INTERNAL void duk_push_hbuffer	(	duk_context *	ctx,
		duk_hbuffer *	h )

Definition at line 4194 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                     {
    duk_tval tv;
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(h != NULL);
    DUK_TVAL_SET_BUFFER(&tv, h);
    duk_push_tval(ctx, &tv);
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_push_tval(), DUK_TVAL_SET_BUFFER, and NULL.

Referenced by duk_push_heapptr().

duk_push_heap_stash()

DUK_EXTERNAL void duk_push_heap_stash

(

duk_context *

ctx

)

Definition at line 3396 of file duktape-1.5.2/src-separate/duk_api_stack.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);
}

References duk__push_stash(), DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_push_hobject(), duk_hthread::heap, duk_heap::heap_object, and NULL.

duk_push_heapptr()

DUK_EXTERNAL duk_idx_t duk_push_heapptr	(	duk_context *	ctx,
		void *	ptr )

Definition at line 4132 of file duktape-1.5.2/src-separate/duk_api_stack.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);
 
    if (ptr == NULL) {
        goto push_undefined;
    }
 
    switch ((int) DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) ptr)) {
    case DUK_HTYPE_STRING:
        duk_push_hstring(ctx, (duk_hstring *) ptr);
        break;
    case DUK_HTYPE_OBJECT:
        duk_push_hobject(ctx, (duk_hobject *) ptr);
        break;
    case DUK_HTYPE_BUFFER:
        duk_push_hbuffer(ctx, (duk_hbuffer *) ptr);
        break;
    default:
        goto push_undefined;
    }
    return ret;
 
 push_undefined:
    duk_push_undefined(ctx);
    return ret;
}

References DUK_ASSERT_CTX_VALID, DUK_HEAPHDR_GET_TYPE, DUK_HTYPE_BUFFER, DUK_HTYPE_OBJECT, DUK_HTYPE_STRING, duk_push_hbuffer(), duk_push_hobject(), duk_push_hstring(), duk_push_undefined(), NULL, duk_hthread::valstack_bottom, and duk_hthread::valstack_top.

duk_push_hobject()

DUK_INTERNAL void duk_push_hobject	(	duk_context *	ctx,
		duk_hobject *	h )

Definition at line 4186 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                     {
    duk_tval tv;
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(h != NULL);
    DUK_TVAL_SET_OBJECT(&tv, h);
    duk_push_tval(ctx, &tv);
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_push_tval(), DUK_TVAL_SET_OBJECT, and NULL.

Referenced by duk_push_current_thread(), duk_push_heap_stash(), duk_push_heapptr(), duk_push_hobject_bidx(), and duk_push_thread_stash().

duk_push_hobject_bidx()

DUK_INTERNAL void duk_push_hobject_bidx	(	duk_context *	ctx,
		duk_small_int_t	builtin_idx )

Definition at line 4202 of file duktape-1.5.2/src-separate/duk_api_stack.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]);
}

References duk_hthread::builtins, DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_NUM_BUILTINS, duk_push_hobject(), and NULL.

Referenced by duk_push_global_object().

duk_push_hobject_class_string()

DUK_INTERNAL void duk_push_hobject_class_string	(	duk_context *	ctx,
		duk_hobject *	h )

Definition at line 2128 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                  {
    duk_hthread *thr;
    duk_hstring *h_strclass;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(h != NULL);
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    h_strclass = DUK_HOBJECT_GET_CLASS_STRING(thr->heap, h);
    DUK_ASSERT(h_strclass != NULL);
    duk_push_sprintf(ctx, "[object %s]", (const char *) DUK_HSTRING_GET_DATA(h_strclass));
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_HOBJECT_GET_CLASS_STRING, DUK_HSTRING_GET_DATA, duk_push_sprintf(), DUK_UNREF, duk_hthread::heap, and NULL.

Referenced by duk_push_string_tval_readable().

duk_push_hstring()

DUK_INTERNAL void duk_push_hstring	(	duk_context *	ctx,
		duk_hstring *	h )

Definition at line 4171 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                     {
    duk_tval tv;
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(h != NULL);
    DUK_TVAL_SET_STRING(&tv, h);
    duk_push_tval(ctx, &tv);
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_push_tval(), DUK_TVAL_SET_STRING, and NULL.

Referenced by duk_push_heapptr(), and duk_push_hstring_stridx().

duk_push_hstring_stridx()

DUK_INTERNAL void duk_push_hstring_stridx	(	duk_context *	ctx,
		duk_small_int_t	stridx )

Definition at line 4179 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                    {
    duk_hthread *thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
    DUK_ASSERT(stridx >= 0 && stridx < DUK_HEAP_NUM_STRINGS);
    duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx));
}

References DUK_ASSERT, DUK_HEAP_NUM_STRINGS, DUK_HTHREAD_GET_STRING, duk_push_hstring(), and DUK_UNREF.

Referenced by duk_push_vsprintf(), duk_safe_to_lstring(), and duk_to_string().

duk_push_int()

DUK_EXTERNAL void duk_push_int	(	duk_context *	ctx,
		duk_int_t	val )

Definition at line 3050 of file duktape-1.5.2/src-separate/duk_api_stack.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_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_double_t = (duk_double_t) val;
        DUK_TVAL_SET_NUMBER(tv_slot, d);
    }
#endif
#else  /* DUK_USE_FASTINT */
    duk_hthread *thr;
    duk_tval *tv_slot;
    duk_double_t d;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
    d = (duk_double_t) val;
    tv_slot = thr->valstack_top++;
    DUK_TVAL_SET_NUMBER(tv_slot, d);
#endif  /* DUK_USE_FASTINT */
}

References DUK__CHECK_SPACE, DUK_ASSERT_CTX_VALID, DUK_TVAL_SET_FASTINT, DUK_TVAL_SET_FASTINT_I32, DUK_TVAL_SET_NUMBER, and duk_hthread::valstack_top.

Referenced by duk_push_array(), duk_push_error_object_va_raw(), and duk_to_object().

duk_push_lightfunc_name()

DUK_INTERNAL void duk_push_lightfunc_name	(	duk_context *	ctx,
		duk_tval *	tv )

Definition at line 4469 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                          {
    duk_c_function func;
 
    DUK_ASSERT(DUK_TVAL_IS_LIGHTFUNC(tv));
 
    /* Lightfunc name, includes Duktape/C native function pointer, which
     * can often be used to locate the function from a symbol table.
     * The name also includes the 16-bit duk_tval flags field because it
     * includes the magic value.  Because a single native function often
     * provides different functionality depending on the magic value, it
     * seems reasonably to include it in the name.
     *
     * On the other hand, a complicated name increases string table
     * pressure in low memory environments (but only when function name
     * is accessed).
     */
 
    func = DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv);
    duk_push_sprintf(ctx, "light_");
    duk_push_string_funcptr(ctx, (duk_uint8_t *) &func, sizeof(func));
    duk_push_sprintf(ctx, "_%04x", (unsigned int) DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv));
    duk_concat(ctx, 3);
}

References DUK_ASSERT, duk_concat(), duk_push_sprintf(), duk_push_string_funcptr(), DUK_TVAL_GET_LIGHTFUNC_FLAGS, DUK_TVAL_GET_LIGHTFUNC_FUNCPTR, and DUK_TVAL_IS_LIGHTFUNC.

Referenced by duk_push_lightfunc_tostring(), and duk_to_object().

duk_push_lightfunc_tostring()

DUK_INTERNAL void duk_push_lightfunc_tostring	(	duk_context *	ctx,
		duk_tval *	tv )

Definition at line 4493 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                              {
    DUK_ASSERT(DUK_TVAL_IS_LIGHTFUNC(tv));
 
    duk_push_string(ctx, "function ");
    duk_push_lightfunc_name(ctx, tv);
    duk_push_string(ctx, "() {\"light\"}");
    duk_concat(ctx, 3);
}

References DUK_ASSERT, duk_concat(), duk_push_lightfunc_name(), duk_push_string(), and DUK_TVAL_IS_LIGHTFUNC.

Referenced by duk_to_string().

duk_push_lstring()

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

Definition at line 3131 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                             {
    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) {
        len = 0;
    }
 
    /* Check for maximum string length */
    if (len > DUK_HSTRING_MAX_BYTELEN) {
        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);
 
    tv_slot = thr->valstack_top++;
    DUK_TVAL_SET_STRING(tv_slot, h);
    DUK_HSTRING_INCREF(thr, h);  /* no side effects */
 
    return (const char *) DUK_HSTRING_GET_DATA(h);
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ERROR_API, DUK_ERROR_RANGE, duk_heap_string_intern_checked(), DUK_HSTRING_GET_DATA, DUK_HSTRING_INCREF, DUK_HSTRING_MAX_BYTELEN, DUK_STR_PUSH_BEYOND_ALLOC_STACK, DUK_STR_STRING_TOO_LONG, DUK_TVAL_SET_STRING, NULL, duk_hthread::valstack_end, and duk_hthread::valstack_top.

Referenced by duk__push_hstring_readable_unicode(), duk_push_string(), duk_push_string_funcptr(), duk_push_vsprintf(), and duk_to_string().

duk_push_nan()

DUK_EXTERNAL void duk_push_nan

(

duk_context *

ctx

)

Definition at line 3117 of file duktape-1.5.2/src-separate/duk_api_stack.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);
}

References duk_double_union::d, DUK__CHECK_SPACE, DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_DBLUNION_IS_NORMALIZED, DUK_DBLUNION_SET_NAN, DUK_TVAL_SET_NUMBER, and duk_hthread::valstack_top.

duk_push_null()

DUK_EXTERNAL void duk_push_null

(

duk_context *

ctx

)

Definition at line 2989 of file duktape-1.5.2/src-separate/duk_api_stack.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_TVAL_SET_NULL(tv_slot);
}

References DUK__CHECK_SPACE, DUK_ASSERT_CTX_VALID, DUK_TVAL_SET_NULL, and duk_hthread::valstack_top.

Referenced by duk_push_string().

duk_push_number()

DUK_EXTERNAL void duk_push_number	(	duk_context *	ctx,
		duk_double_t	val )

Definition at line 3036 of file duktape-1.5.2/src-separate/duk_api_stack.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);
}

References duk_double_union::d, DUK__CHECK_SPACE, DUK_ASSERT_CTX_VALID, DUK_DBLUNION_NORMALIZE_NAN_CHECK, DUK_TVAL_SET_NUMBER, and duk_hthread::valstack_top.

duk_push_object()

DUK_EXTERNAL duk_idx_t duk_push_object

(

duk_context *

ctx

)

Definition at line 3576 of file duktape-1.5.2/src-separate/duk_api_stack.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);
}

References DUK_ASSERT_CTX_VALID, DUK_BIDX_OBJECT_PROTOTYPE, DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_CLASS_OBJECT, DUK_HOBJECT_FLAG_EXTENSIBLE, and duk_push_object_helper().

duk_push_object_helper()

DUK_INTERNAL duk_idx_t duk_push_object_helper	(	duk_context *	ctx,
		duk_uint_t	hobject_flags_and_class,
		duk_small_int_t	prototype_bidx )

Definition at line 3521 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                                                    {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv_slot;
    duk_hobject *h;
    duk_idx_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(prototype_bidx == -1 ||
               (prototype_bidx >= 0 && prototype_bidx < DUK_NUM_BUILTINS));
 
    /* check stack first */
    if (thr->valstack_top >= thr->valstack_end) {
        DUK_ERROR_API(thr, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
    }
 
    h = duk_hobject_alloc(thr->heap, hobject_flags_and_class);
    if (!h) {
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
 
    DUK_DDD(DUK_DDDPRINT("created object with flags: 0x%08lx", (unsigned long) h->hdr.h_flags));
 
    tv_slot = thr->valstack_top;
    DUK_TVAL_SET_OBJECT(tv_slot, h);
    DUK_HOBJECT_INCREF(thr, h);  /* no side effects */
    ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
    thr->valstack_top++;
 
    /* object is now reachable */
 
    if (prototype_bidx >= 0) {
        DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, thr->builtins[prototype_bidx]);
    } else {
        DUK_ASSERT(prototype_bidx == -1);
        DUK_ASSERT(DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h) == NULL);
    }
 
    return ret;
}

References duk_hthread::builtins, DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_DDD, DUK_DDDPRINT, DUK_ERROR_ALLOC_DEFMSG, DUK_ERROR_API, duk_hobject_alloc(), DUK_HOBJECT_GET_PROTOTYPE, DUK_HOBJECT_INCREF, DUK_HOBJECT_SET_PROTOTYPE_UPDREF, DUK_NUM_BUILTINS, DUK_STR_PUSH_BEYOND_ALLOC_STACK, DUK_TVAL_SET_OBJECT, duk_heaphdr::h_flags, duk_hobject::hdr, duk_hthread::heap, NULL, duk_hthread::valstack_bottom, duk_hthread::valstack_end, and duk_hthread::valstack_top.

Referenced by duk_push_array(), duk_push_object(), duk_push_object_helper_proto(), duk_push_object_internal(), and duk_to_object().

duk_push_object_helper_proto()

DUK_INTERNAL duk_idx_t duk_push_object_helper_proto	(	duk_context *	ctx,
		duk_uint_t	hobject_flags_and_class,
		duk_hobject *	proto )

Definition at line 3561 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                                              {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_idx_t ret;
    duk_hobject *h;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    ret = duk_push_object_helper(ctx, hobject_flags_and_class, -1);
    h = duk_get_hobject(ctx, -1);
    DUK_ASSERT(h != NULL);
    DUK_ASSERT(DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h) == NULL);
    DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, proto);
    return ret;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_hobject(), DUK_HOBJECT_GET_PROTOTYPE, DUK_HOBJECT_SET_PROTOTYPE_UPDREF, duk_push_object_helper(), duk_hthread::heap, NULL, and proto.

Referenced by duk_push_error_object_va_raw().

duk_push_object_internal()

DUK_INTERNAL duk_idx_t duk_push_object_internal

(

duk_context *

ctx

)

Definition at line 4164 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                  {
    return duk_push_object_helper(ctx,
                                  DUK_HOBJECT_FLAG_EXTENSIBLE |
                                  DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
                                  -1);  /* no prototype */
}

References DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_CLASS_OBJECT, DUK_HOBJECT_FLAG_EXTENSIBLE, and duk_push_object_helper().

Referenced by duk__push_stash().

duk_push_pointer()

DUK_EXTERNAL void duk_push_pointer	(	duk_context *	ctx,
		void *	val )

Definition at line 3248 of file duktape-1.5.2/src-separate/duk_api_stack.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_TVAL_SET_POINTER(tv_slot, val);
}

References DUK__CHECK_SPACE, DUK_ASSERT_CTX_VALID, DUK_TVAL_SET_POINTER, and duk_hthread::valstack_top.

Referenced by duk_to_pointer().

duk_push_sprintf()

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

Definition at line 3507 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                  {
    va_list ap;
    const char *ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* allow fmt==NULL */
    va_start(ap, fmt);
    ret = duk_push_vsprintf(ctx, fmt, ap);
    va_end(ap);
 
    return ret;
}

References DUK_ASSERT_CTX_VALID, and duk_push_vsprintf().

Referenced by duk_push_hobject_class_string(), duk_push_lightfunc_name(), duk_push_string_tval_readable(), duk_to_object_class_string_top(), and duk_to_string().

duk_push_string()

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

Definition at line 3167 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                            {
    DUK_ASSERT_CTX_VALID(ctx);
 
    if (str) {
        return duk_push_lstring(ctx, str, DUK_STRLEN(str));
    } else {
        duk_push_null(ctx);
        return NULL;
    }
}

References DUK_ASSERT_CTX_VALID, duk_push_lstring(), duk_push_null(), DUK_STRLEN, and NULL.

Referenced by duk_push_lightfunc_tostring(), and duk_push_string_tval_readable().

duk_push_string_file_raw()

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

Definition at line 3183 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                        {
    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 */
    f = NULL;
    return duk_to_string(ctx, -1);
 
 fail:
    if (f) {
        DUK_FCLOSE(f);
    }
 
    if (flags != 0) {
        DUK_ASSERT(flags == DUK_STRING_PUSH_SAFE);  /* only flag now */
        duk_push_undefined(ctx);
    } else {
        /* XXX: string not shared because it is conditional */
        DUK_ERROR_TYPE(thr, "read file error");
    }
    return NULL;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ERROR_TYPE, DUK_FCLOSE, DUK_FOPEN, DUK_FREAD, DUK_FSEEK, DUK_FTELL, duk_push_fixed_buffer, duk_push_undefined(), DUK_STRING_PUSH_SAFE, duk_to_string(), and NULL.

duk_push_string_funcptr()

DUK_INTERNAL void duk_push_string_funcptr	(	duk_context *	ctx,
		duk_uint8_t *	ptr,
		duk_size_t	sz )

Definition at line 4509 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                             {
    duk_uint8_t buf[32 * 2];
    duk_uint8_t *p, *q;
    duk_small_uint_t i;
    duk_small_uint_t t;
 
    DUK_ASSERT(sz <= 32);  /* sanity limit for function pointer size */
 
    p = buf;
#if defined(DUK_USE_INTEGER_LE)
    q = ptr + sz;
#else
    q = ptr;
#endif
    for (i = 0; i < sz; i++) {
#if defined(DUK_USE_INTEGER_LE)
        t = *(--q);
#else
        t = *(q++);
#endif
        *p++ = duk_lc_digits[t >> 4];
        *p++ = duk_lc_digits[t & 0x0f];
    }
 
    duk_push_lstring(ctx, (const char *) buf, sz * 2);
}

References DUK_ASSERT, duk_lc_digits, and duk_push_lstring().

Referenced by duk_push_lightfunc_name().

duk_push_string_readable()

DUK_INTERNAL const char * duk_push_string_readable	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 4650 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                     {
    DUK_ASSERT_CTX_VALID(ctx);
    return duk_push_string_tval_readable(ctx, duk_get_tval(ctx, index));
}

References DUK_ASSERT_CTX_VALID, duk_get_tval(), duk_push_string_tval_readable(), and index.

duk_push_string_tval_readable()

DUK_INTERNAL const char * duk_push_string_tval_readable	(	duk_context *	ctx,
		duk_tval *	tv )

Definition at line 4603 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                       {
    duk_hthread *thr;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    if (tv == NULL) {
        duk_push_string(ctx, "none");
    } else {
        switch (DUK_TVAL_GET_TAG(tv)) {
        case DUK_TAG_STRING: {
            duk__push_hstring_readable_unicode(ctx, DUK_TVAL_GET_STRING(tv));
            break;
        }
        case DUK_TAG_OBJECT: {
            duk_hobject *h = DUK_TVAL_GET_OBJECT(tv);
            DUK_ASSERT(h != NULL);
            duk_push_hobject_class_string(ctx, h);
            break;
        }
        case DUK_TAG_BUFFER: {
            /* XXX: Hex encoded, length limited buffer summary here? */
            duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
            DUK_ASSERT(h != NULL);
            duk_push_sprintf(ctx, "[buffer:%ld]", (long) DUK_HBUFFER_GET_SIZE(h));
            break;
        }
        case DUK_TAG_POINTER: {
            /* Surround with parentheses like in JX, ensures NULL pointer
             * is distinguishable from null value ("(null)" vs "null").
             */
            duk_push_tval(ctx, tv);
            duk_push_sprintf(ctx, "(%s)", duk_to_string(ctx, -1));
            duk_remove(ctx, -2);
            break;
        }
        default: {
            duk_push_tval(ctx, tv);
            break;
        }
        }
    }
 
    return duk_to_string(ctx, -1);
}

References duk__push_hstring_readable_unicode(), DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_HBUFFER_GET_SIZE, duk_push_hobject_class_string(), duk_push_sprintf(), duk_push_string(), duk_push_tval(), duk_remove(), DUK_TAG_BUFFER, DUK_TAG_OBJECT, DUK_TAG_POINTER, DUK_TAG_STRING, duk_to_string(), DUK_TVAL_GET_BUFFER, DUK_TVAL_GET_OBJECT, DUK_TVAL_GET_STRING, DUK_TVAL_GET_TAG, DUK_UNREF, and NULL.

Referenced by duk_push_string_readable().

duk_push_this()

DUK_EXTERNAL void duk_push_this

(

duk_context *

ctx

)

Definition at line 3298 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                  {
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk__push_this_helper(ctx, 0 /*check_object_coercible*/);
}

References duk__push_this_helper(), and DUK_ASSERT_CTX_VALID.

duk_push_this_check_object_coercible()

DUK_INTERNAL void duk_push_this_check_object_coercible

(

duk_context *

ctx

)

Definition at line 3304 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                         {
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk__push_this_helper(ctx, 1 /*check_object_coercible*/);
}

References duk__push_this_helper(), and DUK_ASSERT_CTX_VALID.

duk_push_this_coercible_to_object()

DUK_INTERNAL duk_hobject * duk_push_this_coercible_to_object

(

duk_context *

ctx

)

Definition at line 3310 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                              {
    duk_hobject *h;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk__push_this_helper(ctx, 1 /*check_object_coercible*/);
    duk_to_object(ctx, -1);
    h = duk_get_hobject(ctx, -1);
    DUK_ASSERT(h != NULL);
    return h;
}

References duk__push_this_helper(), DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_hobject(), duk_to_object(), and NULL.

duk_push_this_coercible_to_string()

DUK_INTERNAL duk_hstring * duk_push_this_coercible_to_string

(

duk_context *

ctx

)

Definition at line 3322 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                              {
    duk_hstring *h;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk__push_this_helper(ctx, 1 /*check_object_coercible*/);
    duk_to_string(ctx, -1);
    h = duk_get_hstring(ctx, -1);
    DUK_ASSERT(h != NULL);
    return h;
}

References duk__push_this_helper(), DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_hstring(), duk_to_string(), and NULL.

duk_push_thread_raw()

DUK_EXTERNAL duk_idx_t duk_push_thread_raw	(	duk_context *	ctx,
		duk_uint_t	flags )

Definition at line 3623 of file duktape-1.5.2/src-separate/duk_api_stack.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 */
    if (flags & DUK_THREAD_NEW_GLOBAL_ENV) {
        duk_hthread_create_builtin_objects(obj);
    } else {
        duk_hthread_copy_builtin_objects(thr, obj);
    }
 
    /* default prototype (Note: 'obj' must be reachable) */
    DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) obj, obj->builtins[DUK_BIDX_THREAD_PROTOTYPE]);
 
    /* Initial stack size satisfies the stack spare constraints so there
     * is no need to require stack here.
     */
    DUK_ASSERT(DUK_VALSTACK_INITIAL_SIZE >=
               DUK_VALSTACK_API_ENTRY_MINIMUM + DUK_VALSTACK_INTERNAL_EXTRA);
 
    return ret;
}

References duk_hthread::builtins, DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_BIDX_THREAD_PROTOTYPE, DUK_DDD, DUK_DDDPRINT, DUK_ERROR_ALLOC_DEFMSG, DUK_ERROR_API, DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_CLASS_THREAD, DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_HOBJECT_FLAG_THREAD, DUK_HOBJECT_SET_PROTOTYPE_UPDREF, duk_hthread_alloc(), duk_hthread_copy_builtin_objects(), duk_hthread_create_builtin_objects(), DUK_HTHREAD_INCREF, duk_hthread_init_stacks(), DUK_HTHREAD_STATE_INACTIVE, DUK_STR_PUSH_BEYOND_ALLOC_STACK, DUK_THREAD_NEW_GLOBAL_ENV, DUK_TVAL_SET_OBJECT, DUK_VALSTACK_API_ENTRY_MINIMUM, DUK_VALSTACK_INITIAL_SIZE, DUK_VALSTACK_INTERNAL_EXTRA, duk_heaphdr::h_flags, duk_hobject::hdr, duk_hthread::heap, duk_hthread::obj, duk_hthread::state, duk_hthread::strs, duk_hthread::valstack_bottom, duk_hthread::valstack_end, and duk_hthread::valstack_top.

duk_push_thread_stash()

DUK_EXTERNAL void duk_push_thread_stash	(	duk_context *	ctx,
		duk_context *	target_ctx )

Definition at line 3412 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                   {
    duk_hthread *thr = (duk_hthread *) ctx;
    DUK_ASSERT_CTX_VALID(ctx);
    if (!target_ctx) {
        DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS);
        return;  /* not reached */
    }
    duk_push_hobject(ctx, (duk_hobject *) target_ctx);
    duk__push_stash(ctx);
}

References duk__push_stash(), DUK_ASSERT_CTX_VALID, DUK_ERROR_API, duk_push_hobject(), and DUK_STR_INVALID_CALL_ARGS.

duk_push_true()

DUK_EXTERNAL void duk_push_true

(

duk_context *

ctx

)

Definition at line 3013 of file duktape-1.5.2/src-separate/duk_api_stack.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_TVAL_SET_BOOLEAN_TRUE(tv_slot);
}

References DUK__CHECK_SPACE, DUK_ASSERT_CTX_VALID, DUK_TVAL_SET_BOOLEAN_TRUE, and duk_hthread::valstack_top.

duk_push_tval()

DUK_INTERNAL void duk_push_tval	(	duk_context *	ctx,
		duk_tval *	tv )

Definition at line 2962 of file duktape-1.5.2/src-separate/duk_api_stack.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_TVAL_SET_TVAL(tv_slot, tv);
    DUK_TVAL_INCREF(thr, tv);  /* no side effects */
}

References DUK__CHECK_SPACE, DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_TVAL_INCREF, DUK_TVAL_SET_TVAL, NULL, and duk_hthread::valstack_top.

Referenced by duk_push_c_lightfunc(), duk_push_current_function(), duk_push_hbuffer(), duk_push_hobject(), duk_push_hstring(), duk_push_string_tval_readable(), and duk_to_string().

duk_push_uint()

DUK_EXTERNAL void duk_push_uint	(	duk_context *	ctx,
		duk_uint_t	val )

Definition at line 3083 of file duktape-1.5.2/src-separate/duk_api_stack.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_double_t = (duk_double_t) val;
        DUK_TVAL_SET_NUMBER(tv_slot, d);
    }
#endif
#else  /* DUK_USE_FASTINT */
    duk_hthread *thr;
    duk_tval *tv_slot;
    duk_double_t d;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
    d = (duk_double_t) val;
    tv_slot = thr->valstack_top++;
    DUK_TVAL_SET_NUMBER(tv_slot, d);
#endif  /* DUK_USE_FASTINT */
}

References DUK__CHECK_SPACE, DUK_ASSERT_CTX_VALID, DUK_TVAL_SET_FASTINT, DUK_TVAL_SET_FASTINT_U32, DUK_TVAL_SET_NUMBER, and duk_hthread::valstack_top.

duk_push_undefined()

DUK_EXTERNAL void duk_push_undefined

(

duk_context *

ctx

)

Definition at line 2975 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                       {
    duk_hthread *thr;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK__CHECK_SPACE();
 
    /* Because value stack init policy is 'undefined above top',
     * we don't need to write, just assert.
     */
    thr->valstack_top++;
    DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(thr->valstack_top - 1));
}

References DUK__CHECK_SPACE, DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_TVAL_IS_UNDEFINED, and duk_hthread::valstack_top.

Referenced by duk_push_current_function(), duk_push_current_thread(), duk_push_heapptr(), and duk_push_string_file_raw().

duk_push_vsprintf()

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

Definition at line 3441 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                          {
    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;
        }
 
        /* failed, resize and try again */
        sz = sz * 2;
        if (sz >= DUK_PUSH_SPRINTF_SANITY_LIMIT) {
            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);
    }
    return res;
}

References duk__try_push_vsprintf(), DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ERROR_API, DUK_HSTRING_GET_DATA, DUK_HTHREAD_STRING_EMPTY_STRING, duk_push_dynamic_buffer, duk_push_hstring_stridx(), duk_push_lstring(), DUK_PUSH_SPRINTF_INITIAL_SIZE, DUK_PUSH_SPRINTF_SANITY_LIMIT, duk_remove(), duk_resize_buffer(), DUK_STR_SPRINTF_TOO_LONG, DUK_STRIDX_EMPTY_STRING, DUK_STRLEN, DUK_VA_COPY, and NULL.

Referenced by duk_push_error_object_va_raw(), and duk_push_sprintf().

duk_remove()

DUK_EXTERNAL void duk_remove	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 947 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                {
    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 ]         [ ... ]
     */
 
#ifdef DUK_USE_REFERENCE_COUNTING
    /* use a temp: decref only when valstack reachable values are correct */
    DUK_TVAL_SET_TVAL(&tv_tmp, p);
#endif
 
    nbytes = (duk_size_t) (((duk_uint8_t *) q) - ((duk_uint8_t *) p));  /* Note: 'q' is top-1 */
    DUK_MEMMOVE((void *) p, (const void *) (p + 1), (size_t) nbytes);  /* zero size not an issue: pointers are valid */
 
    DUK_TVAL_SET_UNDEFINED(q);
    thr->valstack_top--;
 
#ifdef DUK_USE_REFERENCE_COUNTING
    DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
#endif
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_MEMMOVE, duk_require_tval(), DUK_TVAL_DECREF, DUK_TVAL_SET_TVAL, DUK_TVAL_SET_UNDEFINED, index, NULL, and duk_hthread::valstack_top.

Referenced by duk__push_stash(), duk_push_string_tval_readable(), and duk_push_vsprintf().

duk_replace()

DUK_EXTERNAL void duk_replace	(	duk_context *	ctx,
		duk_idx_t	to_index )

Definition at line 907 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                    {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv1;
    duk_tval *tv2;
    duk_tval tv_tmp;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv1 = duk_require_tval(ctx, -1);
    DUK_ASSERT(tv1 != NULL);
    tv2 = duk_require_tval(ctx, to_index);
    DUK_ASSERT(tv2 != NULL);
 
    /* For tv1 == tv2, both pointing to stack top, the end result
     * is same as duk_pop(ctx).
     */
    DUK_TVAL_SET_TVAL(&tv_tmp, tv2);
    DUK_TVAL_SET_TVAL(tv2, tv1);
    DUK_TVAL_SET_UNDEFINED(tv1);
    thr->valstack_top--;
    DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_require_tval(), DUK_TVAL_DECREF, DUK_TVAL_SET_TVAL, DUK_TVAL_SET_UNDEFINED, NULL, and duk_hthread::valstack_top.

Referenced by duk__defaultvalue_coerce_attempt(), duk_safe_to_lstring(), duk_to_buffer_raw(), duk_to_object(), duk_to_pointer(), and duk_to_string().

duk_require_boolean()

DUK_EXTERNAL duk_bool_t duk_require_boolean	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1107 of file duktape-1.5.2/src-separate/duk_api_stack.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 */
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ERROR_REQUIRE_TYPE_INDEX, duk_get_tval(), DUK_STR_NOT_BOOLEAN, DUK_TVAL_GET_BOOLEAN, DUK_TVAL_IS_BOOLEAN, and index.

duk_require_buffer()

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

Definition at line 1328 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                               {
    return duk__get_buffer_helper(ctx, index, out_size, 1 /*throw_flag*/);
}

References duk__get_buffer_helper(), and index.

duk_require_buffer_data()

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

Definition at line 1390 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                    {
    return duk__get_buffer_data_helper(ctx, index, out_size, 1 /*throw_flag*/);
}

References duk__get_buffer_data_helper(), and index.

duk_require_c_function()

DUK_EXTERNAL duk_c_function duk_require_c_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1531 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                      {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_c_function ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    ret = duk_get_c_function(ctx, index);
    if (!ret) {
        DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "nativefunction", DUK_STR_NOT_NATIVEFUNCTION);
    }
    return ret;
}

References DUK_ASSERT_CTX_VALID, DUK_ERROR_REQUIRE_TYPE_INDEX, duk_get_c_function(), DUK_STR_NOT_NATIVEFUNCTION, and index.

duk_require_context()

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

Definition at line 1556 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                 {
    DUK_ASSERT_CTX_VALID(ctx);
 
    return (duk_context *) duk_require_hthread(ctx, index);
}

References DUK_ASSERT_CTX_VALID, duk_require_hthread(), and index.

duk_require_function()

DUK_EXTERNAL void duk_require_function	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1544 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                          {
    if (!duk_is_function(ctx, index)) {
        DUK_ERROR_REQUIRE_TYPE_INDEX((duk_hthread *) ctx, index, "function", DUK_STR_NOT_FUNCTION);
    }
}

References DUK_ERROR_REQUIRE_TYPE_INDEX, duk_is_function(), DUK_STR_NOT_FUNCTION, and index.

duk_require_hbuffer()

DUK_INTERNAL duk_hbuffer * duk_require_hbuffer	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1445 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                 {
    duk_heaphdr *h;
    h = duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_BUFFER);
    if (h == NULL) {
        DUK_ERROR_REQUIRE_TYPE_INDEX(ctx, index, "buffer", DUK_STR_NOT_BUFFER);
    }
    return (duk_hbuffer *) h;
}

References duk__get_tagged_heaphdr_raw(), DUK_ERROR_REQUIRE_TYPE_INDEX, DUK_STR_NOT_BUFFER, DUK_TAG_BUFFER, index, and NULL.

Referenced by duk_push_buffer_object().

duk_require_hcompiledfunction()

DUK_INTERNAL duk_hcompiledfunction * duk_require_hcompiledfunction	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1479 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                     {
    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_COMPILEDFUNCTION(h))) {
        DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "compiledfunction", DUK_STR_NOT_COMPILEDFUNCTION);
    }
    return (duk_hcompiledfunction *) h;
}

References duk__get_tagged_heaphdr_raw(), DUK_ERROR_REQUIRE_TYPE_INDEX, DUK_HOBJECT_IS_COMPILEDFUNCTION, DUK_STR_NOT_COMPILEDFUNCTION, DUK_TAG_OBJECT, index, and NULL.

duk_require_heapptr()

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

Definition at line 1578 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                          {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    void *ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);
    if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
        ret = (void *) DUK_TVAL_GET_HEAPHDR(tv);
        DUK_ASSERT(ret != NULL);
        return ret;
    }
 
    DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "heapobject", DUK_STR_UNEXPECTED_TYPE);
    return (void *) NULL;  /* not reachable */
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ERROR_REQUIRE_TYPE_INDEX, duk_require_tval(), DUK_STR_UNEXPECTED_TYPE, DUK_TVAL_GET_HEAPHDR, DUK_TVAL_IS_HEAP_ALLOCATED, index, and NULL.

duk_require_hnativefunction()

DUK_INTERNAL duk_hnativefunction * duk_require_hnativefunction	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1496 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                 {
    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;
}

References duk__get_tagged_heaphdr_raw(), DUK_ERROR_REQUIRE_TYPE_INDEX, DUK_HOBJECT_IS_NATIVEFUNCTION, DUK_STR_NOT_NATIVEFUNCTION, DUK_TAG_OBJECT, index, and NULL.

duk_require_hobject()

DUK_INTERNAL duk_hobject * duk_require_hobject	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1432 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                 {
    duk_heaphdr *h;
    h = duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
    if (h == NULL) {
        DUK_ERROR_REQUIRE_TYPE_INDEX(ctx, index, "object", DUK_STR_NOT_OBJECT);
    }
    return (duk_hobject *) h;
}

References duk__get_tagged_heaphdr_raw(), DUK_ERROR_REQUIRE_TYPE_INDEX, DUK_STR_NOT_OBJECT, DUK_TAG_OBJECT, index, and NULL.

Referenced by duk_get_hobject_or_lfunc_coerce(), duk_push_array(), and duk_require_hobject_or_lfunc_coerce().

duk_require_hobject_or_lfunc()

DUK_INTERNAL duk_hobject * duk_require_hobject_or_lfunc	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1630 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                          {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);
    if (DUK_TVAL_IS_OBJECT(tv)) {
        return DUK_TVAL_GET_OBJECT(tv);
    } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
        return NULL;
    }
    DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "object", DUK_STR_NOT_OBJECT);
    return NULL;  /* not reachable */
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ERROR_REQUIRE_TYPE_INDEX, duk_require_tval(), DUK_STR_NOT_OBJECT, DUK_TVAL_GET_OBJECT, DUK_TVAL_IS_LIGHTFUNC, DUK_TVAL_IS_OBJECT, index, and NULL.

Referenced by duk_to_defaultvalue().

duk_require_hobject_or_lfunc_coerce()

DUK_INTERNAL duk_hobject * duk_require_hobject_or_lfunc_coerce	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1651 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                 {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_require_tval(ctx, index);
    if (DUK_TVAL_IS_OBJECT(tv)) {
        return DUK_TVAL_GET_OBJECT(tv);
    } else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
        duk_to_object(ctx, index);
        return duk_require_hobject(ctx, index);
    }
    DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "object", DUK_STR_NOT_OBJECT);
    return NULL;  /* not reachable */
}

References DUK_ASSERT_CTX_VALID, DUK_ERROR_REQUIRE_TYPE_INDEX, duk_require_hobject(), duk_require_tval(), DUK_STR_NOT_OBJECT, duk_to_object(), DUK_TVAL_GET_OBJECT, DUK_TVAL_IS_LIGHTFUNC, DUK_TVAL_IS_OBJECT, index, and NULL.

duk_require_hobject_with_class()

DUK_INTERNAL duk_hobject * duk_require_hobject_with_class	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_small_uint_t	classnum )

Definition at line 1682 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                                       {
    duk_hthread *thr;
    duk_hobject *h;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT_DISABLE(classnum >= 0);  /* unsigned */
    DUK_ASSERT(classnum <= DUK_HOBJECT_CLASS_MAX);
    thr = (duk_hthread *) ctx;
 
    h = (duk_hobject *) duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
    if (!(h != NULL && DUK_HOBJECT_GET_CLASS_NUMBER(h) == classnum)) {
        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;
}

References duk__get_tagged_heaphdr_raw(), DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ASSERT_DISABLE, DUK_ERROR_REQUIRE_TYPE_INDEX, DUK_HOBJECT_CLASS_MAX, DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX, DUK_HOBJECT_GET_CLASS_NUMBER, DUK_HSTRING_GET_DATA, DUK_HTHREAD_GET_STRING, DUK_STR_UNEXPECTED_TYPE, DUK_TAG_OBJECT, DUK_UNREF, index, and NULL.

duk_require_hstring()

DUK_INTERNAL duk_hstring * duk_require_hstring	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1419 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                 {
    duk_heaphdr *h;
    h = duk__get_tagged_heaphdr_raw(ctx, index, DUK_TAG_STRING);
    if (h == NULL) {
        DUK_ERROR_REQUIRE_TYPE_INDEX(ctx, index, "string", DUK_STR_NOT_STRING);
    }
    return (duk_hstring *) h;
}

References duk__get_tagged_heaphdr_raw(), DUK_ERROR_REQUIRE_TYPE_INDEX, DUK_STR_NOT_STRING, DUK_TAG_STRING, index, and NULL.

duk_require_hthread()

DUK_INTERNAL duk_hthread * duk_require_hthread	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1462 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                 {
    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_THREAD(h))) {
        DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "thread", DUK_STR_NOT_THREAD);
    }
    return (duk_hthread *) h;
}

References duk__get_tagged_heaphdr_raw(), DUK_ERROR_REQUIRE_TYPE_INDEX, DUK_HOBJECT_IS_THREAD, DUK_STR_NOT_THREAD, DUK_TAG_OBJECT, index, and NULL.

Referenced by duk_require_context().

duk_require_int()

DUK_EXTERNAL duk_int_t duk_require_int	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1179 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                          {
    /* Custom coercion for API */
    DUK_ASSERT_CTX_VALID(ctx);
    return (duk_int_t) duk__api_coerce_d2i(ctx, index, 1 /*require*/);
}

References duk__api_coerce_d2i(), DUK_ASSERT_CTX_VALID, and index.

duk_require_lstring()

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

Definition at line 1219 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                     {
    duk_hthread *thr = (duk_hthread *) ctx;
    const char *ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* Note: this check relies on the fact that even a zero-size string
     * has a non-NULL pointer.
     */
    ret = duk_get_lstring(ctx, index, out_len);
    if (ret) {
        return ret;
    }
    DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "string", DUK_STR_NOT_STRING);
    return NULL;  /* not reachable */
}

References DUK_ASSERT_CTX_VALID, DUK_ERROR_REQUIRE_TYPE_INDEX, duk_get_lstring(), DUK_STR_NOT_STRING, index, and NULL.

Referenced by duk_require_string(), and duk_to_lstring().

duk_require_normalize_index()

DUK_EXTERNAL duk_idx_t duk_require_normalize_index	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 219 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                      {
    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 */
 
    if (index < 0) {
        uindex = vs_size + (duk_uidx_t) index;
    } else {
        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;
    }
    DUK_ERROR_API_INDEX(thr, index);
    return 0;  /* unreachable */
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ASSERT_DISABLE, DUK_ERROR_API_INDEX, DUK_INVALID_INDEX, DUK_LIKELY, index, duk_hthread::valstack_bottom, and duk_hthread::valstack_top.

Referenced by duk_safe_to_lstring(), duk_to_boolean(), duk_to_buffer_raw(), duk_to_defaultvalue(), duk_to_object(), duk_to_pointer(), duk_to_primitive(), and duk_to_string().

duk_require_null()

DUK_EXTERNAL void duk_require_null	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1078 of file duktape-1.5.2/src-separate/duk_api_stack.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);
    return;  /* not reachable */
}

References DUK_ASSERT_CTX_VALID, DUK_ERROR_REQUIRE_TYPE_INDEX, duk_get_tval(), DUK_STR_NOT_NULL, DUK_TVAL_IS_NULL, and index.

duk_require_number()

DUK_EXTERNAL duk_double_t duk_require_number	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1144 of file duktape-1.5.2/src-separate/duk_api_stack.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_NUMBER(tv)) {
        duk_double_union ret;
        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_ERROR_REQUIRE_TYPE_INDEX(thr, index, "number", DUK_STR_NOT_NUMBER);
    return DUK_DOUBLE_NAN;  /* not reachable */
}

References duk_double_union::d, DUK_ASSERT_CTX_VALID, DUK_DBLUNION_NORMALIZE_NAN_CHECK, DUK_DOUBLE_NAN, DUK_ERROR_REQUIRE_TYPE_INDEX, duk_get_tval(), DUK_STR_NOT_NUMBER, DUK_TVAL_GET_NUMBER, DUK_TVAL_IS_NUMBER, and index.

duk_require_pointer()

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

Definition at line 1262 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                          {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    /* Note: here we must be wary of the fact that a pointer may be
     * valid and be a NULL.
     */
    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;
    }
    DUK_ERROR_REQUIRE_TYPE_INDEX(thr, index, "pointer", DUK_STR_NOT_POINTER);
    return NULL;  /* not reachable */
}

References DUK_ASSERT_CTX_VALID, DUK_ERROR_REQUIRE_TYPE_INDEX, duk_get_tval(), DUK_STR_NOT_POINTER, DUK_TVAL_GET_POINTER, DUK_TVAL_IS_POINTER, index, and NULL.

duk_require_stack()

DUK_EXTERNAL void duk_require_stack	(	duk_context *	ctx,
		duk_idx_t	extra )

Definition at line 739 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                       {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_size_t min_new_size;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
 
    if (DUK_UNLIKELY(extra < 0)) {
        /* 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);
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_UNLIKELY, DUK_VALSTACK_INTERNAL_EXTRA, duk_valstack_resize_raw(), DUK_VSRESIZE_FLAG_THROW, NULL, duk_hthread::valstack, and duk_hthread::valstack_top.

duk_require_stack_top()

DUK_EXTERNAL void duk_require_stack_top	(	duk_context *	ctx,
		duk_idx_t	top )

Definition at line 781 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                         {
    duk_size_t min_new_size;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    if (DUK_UNLIKELY(top < 0)) {
        /* Clamping to zero makes the API more robust to calling code
         * calculation errors.
         */
        top = 0;
    }
 
    min_new_size = top + 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);
}

References DUK_ASSERT_CTX_VALID, DUK_UNLIKELY, DUK_VALSTACK_INTERNAL_EXTRA, duk_valstack_resize_raw(), and DUK_VSRESIZE_FLAG_THROW.

duk_require_string()

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

Definition at line 1242 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                               {
    DUK_ASSERT_CTX_VALID(ctx);
 
    return duk_require_lstring(ctx, index, NULL);
}

References DUK_ASSERT_CTX_VALID, duk_require_lstring(), index, and NULL.

Referenced by duk_to_string().

duk_require_top_index()

DUK_EXTERNAL duk_idx_t duk_require_top_index

(

duk_context *

ctx

)

Definition at line 451 of file duktape-1.5.2/src-separate/duk_api_stack.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)) {
        DUK_ERROR_API_INDEX(thr, -1);
        return 0;  /* unreachable */
    }
    return ret;
}

References DUK_ASSERT_CTX_VALID, DUK_ERROR_API_INDEX, DUK_UNLIKELY, duk_hthread::valstack_bottom, and duk_hthread::valstack_top.

duk_require_tval()

DUK_INTERNAL duk_tval * duk_require_tval	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 276 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                           {
    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 */
 
    /* Use unsigned arithmetic to optimize comparison. */
    if (index < 0) {
        uindex = vs_size + (duk_uidx_t) index;
    } else {
        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 thr->valstack_bottom + uindex;
    }
    DUK_ERROR_API_INDEX(thr, index);
    return NULL;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ASSERT_DISABLE, DUK_ERROR_API_INDEX, DUK_INVALID_INDEX, DUK_LIKELY, index, NULL, duk_hthread::valstack_bottom, and duk_hthread::valstack_top.

Referenced by duk__to_int_uint_helper(), duk_copy(), duk_dup(), duk_get_hobject_or_lfunc_coerce(), duk_insert(), duk_instanceof(), duk_push_array(), duk_remove(), duk_replace(), duk_require_heapptr(), duk_require_hobject_or_lfunc(), duk_require_hobject_or_lfunc_coerce(), duk_swap(), duk_to_boolean(), duk_to_int32(), duk_to_int_clamped_raw(), duk_to_null(), duk_to_number(), duk_to_object(), duk_to_pointer(), duk_to_string(), duk_to_uint16(), duk_to_uint32(), and duk_to_undefined().

duk_require_uint()

DUK_EXTERNAL duk_uint_t duk_require_uint	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1185 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                            {
    /* Custom coercion for API */
    DUK_ASSERT_CTX_VALID(ctx);
    return (duk_uint_t) duk__api_coerce_d2ui(ctx, index, 1 /*require*/);
}

References duk__api_coerce_d2ui(), DUK_ASSERT_CTX_VALID, and index.

duk_require_undefined()

DUK_EXTERNAL void duk_require_undefined	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1064 of file duktape-1.5.2/src-separate/duk_api_stack.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_ERROR_REQUIRE_TYPE_INDEX(thr, index, "undefined", DUK_STR_NOT_UNDEFINED);
    return;  /* not reachable */
}

References DUK_ASSERT_CTX_VALID, DUK_ERROR_REQUIRE_TYPE_INDEX, duk_get_tval(), DUK_STR_NOT_UNDEFINED, DUK_TVAL_IS_UNDEFINED, and index.

duk_require_valid_index()

DUK_EXTERNAL void duk_require_valid_index	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 315 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                             {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(DUK_INVALID_INDEX < 0);
 
    if (duk_normalize_index(ctx, index) < 0) {
        DUK_ERROR_API_INDEX(thr, index);
        return;  /* unreachable */
    }
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ERROR_API_INDEX, DUK_INVALID_INDEX, duk_normalize_index(), and index.

duk_safe_to_lstring()

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

Definition at line 2056 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                     {
    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. */
        (void) duk_safe_call(ctx, duk__safe_to_string_raw, 1 /*nargs*/, 1 /*nrets*/);
        if (!duk_is_string(ctx, -1)) {
            /* Double error */
            duk_pop(ctx);
            duk_push_hstring_stridx(ctx, DUK_STRIDX_UC_ERROR);
        } else {
            ;
        }
    } else {
        ;
    }
    DUK_ASSERT(duk_is_string(ctx, -1));
    DUK_ASSERT(duk_get_string(ctx, -1) != NULL);
 
    duk_replace(ctx, index);
    return duk_get_lstring(ctx, index, out_len);
}

References duk__safe_to_string_raw(), DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_dup(), duk_get_lstring(), duk_get_string(), duk_is_string(), duk_pop(), duk_push_hstring_stridx(), duk_replace(), duk_require_normalize_index(), duk_safe_call(), DUK_STRIDX_UC_ERROR, index, and NULL.

duk_set_length()

DUK_INTERNAL void duk_set_length	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t	length )

Definition at line 1751 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                       {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *h;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    h = duk_get_hobject(ctx, index);
    if (!h) {
        return;
    }
 
    duk_hobject_set_length(thr, h, (duk_uint32_t) length);  /* XXX: typing */
}

References DUK_ASSERT_CTX_VALID, duk_get_hobject(), duk_hobject_set_length(), and index.

duk_set_top()

DUK_EXTERNAL void duk_set_top	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 343 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                 {
    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 */
        }
#else  /* DUK_USE_REFERENCE_COUNTING */
        duk_uidx_t count;
        duk_tval *tv_end;
 
        count = vs_size - uindex;
        tv = thr->valstack_top;
        tv_end = tv - count;
        DUK_ASSERT(tv > tv_end);
        do {
            tv--;
            DUK_TVAL_SET_UNDEFINED(tv);
        } while (tv != tv_end);
        thr->valstack_top = tv_end;
#endif  /* DUK_USE_REFERENCE_COUNTING */
    }
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ERROR_API_INDEX, DUK_INVALID_INDEX, DUK_TVAL_IS_UNDEFINED, DUK_TVAL_SET_UNDEFINED, DUK_TVAL_SET_UNDEFINED_UPDREF, DUK_UNLIKELY, DUK_UNREF, index, duk_hthread::valstack_bottom, duk_hthread::valstack_end, and duk_hthread::valstack_top.

duk_strict_equals()

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

Definition at line 4427 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                {
    duk_tval *tv1, *tv2;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv1 = duk_get_tval(ctx, index1);
    tv2 = duk_get_tval(ctx, index2);
    if ((tv1 == NULL) || (tv2 == NULL)) {
        return 0;
    }
 
    /* No coercions or other side effects, so safe */
    return duk_js_strict_equals(tv1, tv2);
}

References DUK_ASSERT_CTX_VALID, duk_get_tval(), duk_js_strict_equals, and NULL.

duk_swap()

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

Definition at line 805 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                 {
    duk_tval *tv1;
    duk_tval *tv2;
    duk_tval tv_tmp;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv1 = duk_require_tval(ctx, index1);
    DUK_ASSERT(tv1 != NULL);
    tv2 = duk_require_tval(ctx, index2);
    DUK_ASSERT(tv2 != NULL);
 
    /* If tv1==tv2 this is a NOP, no check is needed */
    DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
    DUK_TVAL_SET_TVAL(tv1, tv2);
    DUK_TVAL_SET_TVAL(tv2, &tv_tmp);
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_require_tval(), DUK_TVAL_SET_TVAL, and NULL.

Referenced by duk_swap_top().

duk_swap_top()

DUK_EXTERNAL void duk_swap_top	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 823 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                  {
    DUK_ASSERT_CTX_VALID(ctx);
 
    duk_swap(ctx, index, -1);
}

References DUK_ASSERT_CTX_VALID, duk_swap(), and index.

duk_throw()

DUK_EXTERNAL void duk_throw

(

duk_context *

ctx

)

Definition at line 4308 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                              {
    duk_hthread *thr = (duk_hthread *) ctx;
 
    DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
 
    if (thr->valstack_top == thr->valstack_bottom) {
        DUK_ERROR_API(thr, DUK_STR_INVALID_CALL_ARGS);
    }
 
    /* Errors are augmented when they are created, not when they are
     * thrown or re-thrown.  The current error handler, however, runs
     * just before an error is thrown.
     */
 
    /* Sync so that augmentation sees up-to-date activations, NULL
     * thr->ptr_curr_pc so that it's not used if side effects occur
     * in augmentation or longjmp handling.
     */
    duk_hthread_sync_and_null_currpc(thr);
 
#if defined(DUK_USE_AUGMENT_ERROR_THROW)
    DUK_DDD(DUK_DDDPRINT("THROW ERROR (API): %!dT (before throw augment)", (duk_tval *) duk_get_tval(ctx, -1)));
    duk_err_augment_error_throw(thr);
#endif
    DUK_DDD(DUK_DDDPRINT("THROW ERROR (API): %!dT (after throw augment)", (duk_tval *) duk_get_tval(ctx, -1)));
 
    duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_THROW);
 
    /* thr->heap->lj.jmpbuf_ptr is checked by duk_err_longjmp() so we don't
     * need to check that here.  If the value is NULL, a panic occurs because
     * we can't return.
     */
 
    duk_err_longjmp(thr);
    DUK_UNREACHABLE();
}

References DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, duk_err_augment_error_throw(), duk_err_longjmp(), duk_err_setup_heap_ljstate(), DUK_ERROR_API, duk_get_tval(), duk_hthread_sync_and_null_currpc(), DUK_LJ_TYPE_THROW, DUK_STR_INVALID_CALL_ARGS, DUK_UNREACHABLE, duk_hthread::valstack, duk_hthread::valstack_bottom, duk_hthread::valstack_end, and duk_hthread::valstack_top.

Referenced by duk_error_raw(), duk_error_stash(), and duk_error_va_raw().

duk_to_boolean()

DUK_EXTERNAL duk_bool_t duk_to_boolean	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1871 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                          {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    duk_bool_t val;
 
    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);
 
    val = duk_js_toboolean(tv);
    DUK_ASSERT(val == 0 || val == 1);
 
    /* Note: no need to re-lookup tv, conversion is side effect free */
    DUK_ASSERT(tv != NULL);
    DUK_TVAL_SET_BOOLEAN_UPDREF(thr, tv, val);  /* side effects */
    return val;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_js_toboolean(), duk_require_normalize_index(), duk_require_tval(), DUK_TVAL_SET_BOOLEAN_UPDREF, DUK_UNREF, index, and NULL.

duk_to_buffer_raw()

DUK_EXTERNAL void * duk_to_buffer_raw	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_size_t *	out_size,
		duk_uint_t	mode )

Definition at line 2313 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                               {
    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);
    }
 
    dst_data = (duk_uint8_t *) duk_push_buffer(ctx, src_size, (mode == DUK_BUF_MODE_DYNAMIC) /*dynamic*/);
    if (DUK_LIKELY(src_size > 0)) {
        /* 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;
}

References DUK_ASSERT_CTX_VALID, DUK_BUF_MODE_DONTCARE, DUK_BUF_MODE_DYNAMIC, DUK_BUF_MODE_FIXED, duk_get_hbuffer(), DUK_HBUFFER_GET_DATA_PTR, DUK_HBUFFER_GET_SIZE, DUK_HBUFFER_HAS_DYNAMIC, DUK_HBUFFER_HAS_EXTERNAL, DUK_LIKELY, DUK_MEMCPY, duk_push_buffer, duk_replace(), duk_require_normalize_index(), duk_to_lstring(), DUK_UNREF, duk_hthread::heap, index, and NULL.

duk_to_defaultvalue()

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

Definition at line 1792 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                         {
    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;
        }
    }
 
    if (hint == DUK_HINT_STRING) {
        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])) {
        return;
    }
 
    DUK_ERROR_TYPE(thr, DUK_STR_DEFAULTVALUE_COERCE_FAILED);
}

References duk__defaultvalue_coerce_attempt(), DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ERROR_TYPE, DUK_HINT_NONE, DUK_HINT_NUMBER, DUK_HINT_STRING, DUK_HOBJECT_CLASS_DATE, DUK_HOBJECT_GET_CLASS_NUMBER, duk_require_hobject_or_lfunc(), duk_require_normalize_index(), DUK_STR_DEFAULTVALUE_COERCE_FAILED, DUK_STRIDX_TO_STRING, DUK_STRIDX_VALUE_OF, index, and NULL.

Referenced by duk_to_primitive().

duk_to_hstring()

DUK_INTERNAL duk_hstring * duk_to_hstring	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2304 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                            {
    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;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_hstring(), duk_to_string(), index, and NULL.

duk_to_int()

DUK_EXTERNAL duk_int_t duk_to_int	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1936 of file duktape-1.5.2/src-separate/duk_api_stack.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_int_t) duk__api_coerce_d2i(ctx, index, 0 /*require*/);
}

References duk__api_coerce_d2i(), duk__to_int_uint_helper(), DUK_ASSERT_CTX_VALID, duk_js_tointeger(), and index.

duk_to_int32()

DUK_EXTERNAL duk_int32_t duk_to_int32	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1954 of file duktape-1.5.2/src-separate/duk_api_stack.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;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_js_toint32(), duk_require_tval(), DUK_TVAL_SET_FASTINT_I32_UPDREF, index, and NULL.

duk_to_int_check_range()

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 )

Definition at line 2212 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                                     {
    return duk_to_int_clamped_raw(ctx, index, minval, maxval, NULL);  /* out_clamped==NULL -> RangeError if outside range */
}

References duk_to_int_clamped_raw(), index, and NULL.

duk_to_int_clamped()

DUK_INTERNAL duk_int_t duk_to_int_clamped	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_idx_t	minval,
		duk_idx_t	maxval )

Definition at line 2207 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                                 {
    duk_bool_t dummy;
    return duk_to_int_clamped_raw(ctx, index, minval, maxval, &dummy);
}

References duk_to_int_clamped_raw(), dummy, and index.

duk_to_int_clamped_raw()

DUK_INTERNAL duk_int_t duk_to_int_clamped_raw	(	duk_context *	ctx,
		duk_idx_t	index,
		duk_int_t	minval,
		duk_int_t	maxval,
		duk_bool_t *	out_clamped )

Definition at line 2144 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                                                              {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    duk_tval tv_tmp;
    duk_double_t d, dmin, dmax;
    duk_int_t res;
    duk_bool_t clamped = 0;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);
    d = duk_js_tointeger(thr, tv);  /* E5 Section 9.4, ToInteger() */
 
    dmin = (duk_double_t) minval;
    dmax = (duk_double_t) maxval;
 
    if (d < dmin) {
        clamped = 1;
        res = minval;
        d = dmin;
    } else if (d > dmax) {
        clamped = 1;
        res = maxval;
        d = dmax;
    } else {
        res = (duk_int_t) d;
    }
    DUK_UNREF(d);  /* SCANBUILD: with suitable dmin/dmax limits 'd' is unused */
    /* 'd' and 'res' agree here */
 
    /* Relookup in case duk_js_tointeger() ends up e.g. coercing an object. */
    tv = duk_get_tval(ctx, index);
    DUK_ASSERT(tv != NULL);  /* not popped by side effect */
    DUK_TVAL_SET_TVAL(&tv_tmp, tv);
#if defined(DUK_USE_FASTINT)
#if (DUK_INT_MAX <= 0x7fffffffL)
    DUK_TVAL_SET_FASTINT_I32(tv, res);
#else
    /* Clamping needed if duk_int_t is 64 bits. */
    if (res >= DUK_FASTINT_MIN && res <= DUK_FASTINT_MAX) {
        DUK_TVAL_SET_FASTINT(tv, res);
    } else {
        DUK_TVAL_SET_NUMBER(tv, d);
    }
#endif
#else
    DUK_TVAL_SET_NUMBER(tv, d);  /* no need to incref */
#endif
    DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
 
    if (out_clamped) {
        *out_clamped = clamped;
    } else {
        /* coerced value is updated to value stack even when RangeError thrown */
        if (clamped) {
            DUK_ERROR_RANGE(thr, DUK_STR_NUMBER_OUTSIDE_RANGE);
        }
    }
 
    return res;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ERROR_RANGE, duk_get_tval(), duk_js_tointeger(), duk_require_tval(), DUK_STR_NUMBER_OUTSIDE_RANGE, DUK_TVAL_DECREF, DUK_TVAL_SET_FASTINT, DUK_TVAL_SET_FASTINT_I32, DUK_TVAL_SET_NUMBER, DUK_TVAL_SET_TVAL, DUK_UNREF, index, and NULL.

Referenced by duk_to_int_check_range(), and duk_to_int_clamped().

duk_to_lstring()

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

Definition at line 2042 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                                {
    DUK_ASSERT_CTX_VALID(ctx);
 
    (void) duk_to_string(ctx, index);
    return duk_require_lstring(ctx, index, out_len);
}

References DUK_ASSERT_CTX_VALID, duk_require_lstring(), duk_to_string(), and index.

Referenced by duk_to_buffer_raw().

duk_to_null()

DUK_EXTERNAL void duk_to_null	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1843 of file duktape-1.5.2/src-separate/duk_api_stack.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_TVAL_SET_NULL_UPDREF(thr, tv);  /* side effects */
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_require_tval(), DUK_TVAL_SET_NULL_UPDREF, DUK_UNREF, index, and NULL.

duk_to_number()

DUK_EXTERNAL duk_double_t duk_to_number	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1893 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                           {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    duk_double_t d;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);
    /* XXX: fastint? */
    d = duk_js_tonumber(thr, tv);
 
    /* Note: need to re-lookup because ToNumber() may have side effects */
    tv = duk_require_tval(ctx, index);
    DUK_TVAL_SET_NUMBER_UPDREF(thr, tv, d);  /* side effects */
    return d;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_js_tonumber(), duk_require_tval(), DUK_TVAL_SET_NUMBER_UPDREF, index, and NULL.

Referenced by duk_to_uint8clamped().

duk_to_object()

DUK_EXTERNAL void duk_to_object	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2426 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                   {
    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;
 
 create_object:
    (void) duk_push_object_helper(ctx, flags, proto);
 
    /* Note: Boolean prototype's internal value property is not writable,
     * but duk_xdef_prop_stridx() disregards the write protection.  Boolean
     * instances are immutable.
     *
     * String and buffer special behaviors are already enabled which is not
     * ideal, but a write to the internal value is not affected by them.
     */
    duk_dup(ctx, index);
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_NONE);
 
 replace_value:
    duk_replace(ctx, index);
}

References duk_hbufferobject::buf, duk__push_c_function_raw(), DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ASSERT_HBUFFEROBJECT_VALID, DUK_BIDX_BOOLEAN_PROTOTYPE, DUK_BIDX_BUFFER_PROTOTYPE, DUK_BIDX_NUMBER_PROTOTYPE, DUK_BIDX_POINTER_PROTOTYPE, DUK_BIDX_STRING_PROTOTYPE, duk_dup(), DUK_ERROR_TYPE, duk_get_hnativefunction(), DUK_HBUFFER_GET_SIZE, DUK_HBUFFER_INCREF, DUK_HBUFFEROBJECT_ELEM_UINT8, DUK_HOBJECT_CLASS_AS_FLAGS, DUK_HOBJECT_CLASS_BOOLEAN, DUK_HOBJECT_CLASS_BUFFER, DUK_HOBJECT_CLASS_FUNCTION, DUK_HOBJECT_CLASS_NUMBER, DUK_HOBJECT_CLASS_POINTER, DUK_HOBJECT_CLASS_STRING, DUK_HOBJECT_FLAG_BUFFEROBJECT, DUK_HOBJECT_FLAG_CONSTRUCTABLE, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ, DUK_HOBJECT_FLAG_EXTENSIBLE, DUK_HOBJECT_FLAG_NATIVEFUNCTION, DUK_HOBJECT_FLAG_NEWENV, DUK_HOBJECT_FLAG_NOTAIL, DUK_HOBJECT_FLAG_STRICT, DUK_HOBJECT_HAS_EXTENSIBLE, DUK_HOBJECT_IS_BUFFEROBJECT, DUK_HOBJECT_SET_EXOTIC_DUKFUNC, DUK_LFUNC_FLAGS_GET_LENGTH, DUK_LFUNC_FLAGS_GET_MAGIC, DUK_LFUNC_FLAGS_GET_NARGS, DUK_LFUNC_NARGS_VARARGS, DUK_PROPDESC_FLAGS_NONE, duk_push_bufferobject_raw(), duk_push_int(), duk_push_lightfunc_name(), duk_push_object_helper(), duk_replace(), duk_require_normalize_index(), duk_require_tval(), DUK_STR_NOT_OBJECT_COERCIBLE, DUK_STRIDX_INT_VALUE, DUK_STRIDX_LENGTH, DUK_STRIDX_NAME, DUK_TAG_BOOLEAN, DUK_TAG_BUFFER, DUK_TAG_LIGHTFUNC, DUK_TAG_NULL, DUK_TAG_OBJECT, DUK_TAG_POINTER, DUK_TAG_STRING, DUK_TAG_UNDEFINED, DUK_TVAL_GET_BUFFER, DUK_TVAL_GET_LIGHTFUNC, DUK_TVAL_GET_TAG, DUK_TVAL_IS_NUMBER, DUK_TVAL_IS_UNUSED, DUK_VARARGS, duk_xdef_prop_stridx(), duk_hbufferobject::elem_type, index, duk_hbufferobject::length, duk_hnativefunction::magic, NULL, duk_hbufferobject::offset, proto, and duk_hbufferobject::shift.

Referenced by duk_get_hobject_or_lfunc_coerce(), duk_push_this_coercible_to_object(), duk_require_hobject_or_lfunc_coerce(), and duk_to_object_class_string_top().

duk_to_object_class_string_top()

DUK_INTERNAL void duk_to_object_class_string_top

(

duk_context *

ctx

)

Definition at line 2098 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                   {
    duk_hthread *thr;
    duk_uint_t typemask;
    duk_hstring *h_strclass;
 
    DUK_ASSERT_CTX_VALID(ctx);
    thr = (duk_hthread *) ctx;
    DUK_UNREF(thr);
 
    typemask = duk_get_type_mask(ctx, -1);
    if (typemask & DUK_TYPE_MASK_UNDEFINED) {
        h_strclass = DUK_HTHREAD_STRING_UC_UNDEFINED(thr);
    } else if (typemask & DUK_TYPE_MASK_NULL) {
        h_strclass = DUK_HTHREAD_STRING_UC_NULL(thr);
    } else {
        duk_hobject *h_obj;
 
        duk_to_object(ctx, -1);
        h_obj = duk_get_hobject(ctx, -1);
        DUK_ASSERT(h_obj != NULL);
 
        h_strclass = DUK_HOBJECT_GET_CLASS_STRING(thr->heap, h_obj);
    }
    DUK_ASSERT(h_strclass != NULL);
 
    duk_pop(ctx);
    duk_push_sprintf(ctx, "[object %s]", (const char *) DUK_HSTRING_GET_DATA(h_strclass));
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_get_hobject(), duk_get_type_mask(), DUK_HOBJECT_GET_CLASS_STRING, DUK_HSTRING_GET_DATA, DUK_HTHREAD_STRING_UC_NULL, DUK_HTHREAD_STRING_UC_UNDEFINED, duk_pop(), duk_push_sprintf(), duk_to_object(), DUK_TYPE_MASK_NULL, DUK_TYPE_MASK_UNDEFINED, DUK_UNREF, duk_hthread::heap, and NULL.

duk_to_pointer()

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

Definition at line 2375 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                     {
    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.
         */
        res = NULL;
        break;
#if defined(DUK_USE_FASTINT)
    case DUK_TAG_FASTINT:
#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;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_push_pointer(), duk_replace(), duk_require_normalize_index(), duk_require_tval(), DUK_TAG_BOOLEAN, DUK_TAG_BUFFER, DUK_TAG_LIGHTFUNC, DUK_TAG_NULL, DUK_TAG_OBJECT, DUK_TAG_POINTER, DUK_TAG_STRING, DUK_TAG_UNDEFINED, DUK_TVAL_GET_HEAPHDR, DUK_TVAL_GET_POINTER, DUK_TVAL_GET_TAG, DUK_TVAL_IS_NUMBER, DUK_TVAL_IS_UNUSED, index, and NULL.

duk_to_primitive()

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

Definition at line 1856 of file duktape-1.5.2/src-separate/duk_api_stack.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);
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_check_type_mask(), DUK_HINT_NONE, DUK_HINT_NUMBER, DUK_HINT_STRING, duk_require_normalize_index(), duk_to_defaultvalue(), DUK_TYPE_MASK_LIGHTFUNC, DUK_TYPE_MASK_OBJECT, and index.

Referenced by duk_to_string().

duk_to_string()

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

Definition at line 2216 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                          {
    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: {
        /* number */
        DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv));
        DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
        duk_push_tval(ctx, tv);
        duk_numconv_stringify(ctx,
                              10 /*radix*/,
                              0 /*precision:shortest*/,
                              0 /*force_exponential*/);
        break;
    }
    }
 
    duk_replace(ctx, index);
 
 skip_replace:
    return duk_require_string(ctx, index);
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_HBUFFER_GET_DATA_PTR, DUK_HBUFFER_GET_SIZE, DUK_HINT_STRING, duk_numconv_stringify(), duk_push_hstring_stridx(), duk_push_lightfunc_tostring(), duk_push_lstring(), duk_push_sprintf(), duk_push_tval(), duk_replace(), duk_require_normalize_index(), duk_require_string(), duk_require_tval(), DUK_STR_FMT_PTR, DUK_STRIDX_FALSE, DUK_STRIDX_LC_NULL, DUK_STRIDX_LC_UNDEFINED, DUK_STRIDX_TRUE, DUK_TAG_BOOLEAN, DUK_TAG_BUFFER, DUK_TAG_LIGHTFUNC, DUK_TAG_NULL, DUK_TAG_OBJECT, DUK_TAG_POINTER, DUK_TAG_STRING, DUK_TAG_UNDEFINED, duk_to_primitive(), duk_to_string(), DUK_TVAL_GET_BOOLEAN, DUK_TVAL_GET_BUFFER, DUK_TVAL_GET_POINTER, DUK_TVAL_GET_TAG, DUK_TVAL_IS_NUMBER, DUK_TVAL_IS_UNUSED, DUK_UNREF, duk_hthread::heap, index, and NULL.

Referenced by duk__safe_to_string_raw(), duk_push_string_file_raw(), duk_push_string_tval_readable(), duk_push_this_coercible_to_string(), duk_to_hstring(), duk_to_lstring(), and duk_to_string().

duk_to_uint()

DUK_EXTERNAL duk_uint_t duk_to_uint	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1945 of file duktape-1.5.2/src-separate/duk_api_stack.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*/);
}

References duk__api_coerce_d2ui(), duk__to_int_uint_helper(), DUK_ASSERT_CTX_VALID, duk_js_tointeger(), and index.

duk_to_uint16()

DUK_EXTERNAL duk_uint16_t duk_to_uint16	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1988 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                           {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_tval *tv;
    duk_uint16_t ret;
 
    DUK_ASSERT_CTX_VALID(ctx);
 
    tv = duk_require_tval(ctx, index);
    DUK_ASSERT(tv != NULL);
    ret = duk_js_touint16(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;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_js_touint16(), duk_require_tval(), DUK_TVAL_SET_FASTINT_U32_UPDREF, index, and NULL.

duk_to_uint32()

DUK_EXTERNAL duk_uint32_t duk_to_uint32	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1971 of file duktape-1.5.2/src-separate/duk_api_stack.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;
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_js_touint32(), duk_require_tval(), DUK_TVAL_SET_FASTINT_U32_UPDREF, index, and NULL.

duk_to_uint8clamped()

DUK_INTERNAL duk_uint8_t duk_to_uint8clamped	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 2007 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                                                {
    duk_double_t d;
    duk_double_t t;
    duk_uint8_t ret;
 
    /* XXX: Simplify this algorithm, should be possible to come up with
     * a shorter and faster algorithm by inspecting IEEE representation
     * directly.
     */
 
    d = duk_to_number(ctx, index);
    if (d <= 0.0) {
        return 0;
    } else if (d >= 255) {
        return 255;
    } else if (DUK_ISNAN(d)) {
        /* Avoid NaN-to-integer coercion as it is compiler specific. */
        return 0;
    }
 
    t = d - DUK_FLOOR(d);
    if (t == 0.5) {
        /* Exact halfway, round to even. */
        ret = (duk_uint8_t) d;
        ret = (ret + 1) & 0xfe;  /* Example: d=3.5, t=0.5 -> ret = (3 + 1) & 0xfe = 4 & 0xfe = 4
                                  * Example: d=4.5, t=0.5 -> ret = (4 + 1) & 0xfe = 5 & 0xfe = 4
                                  */
    } else {
        /* Not halfway, round to nearest. */
        ret = (duk_uint8_t) (d + 0.5);
    }
    return ret;
}

References DUK_FLOOR, DUK_ISNAN, duk_to_number(), and index.

duk_to_undefined()

DUK_EXTERNAL void duk_to_undefined	(	duk_context *	ctx,
		duk_idx_t	index )

Definition at line 1831 of file duktape-1.5.2/src-separate/duk_api_stack.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_TVAL_SET_UNDEFINED_UPDREF(thr, tv);  /* side effects */
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, duk_require_tval(), DUK_TVAL_SET_UNDEFINED_UPDREF, DUK_UNREF, index, and NULL.

duk_valstack_resize_raw()

DUK_INTERNAL duk_bool_t duk_valstack_resize_raw	(	duk_context *	ctx,
		duk_size_t	min_new_size,
		duk_small_uint_t	flags )

Definition at line 618 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                           {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_size_t old_size;
    duk_size_t new_size;
    duk_bool_t is_shrink = 0;
    duk_small_uint_t shrink_flag = (flags & DUK_VSRESIZE_FLAG_SHRINK);
    duk_small_uint_t compact_flag = (flags & DUK_VSRESIZE_FLAG_COMPACT);
    duk_small_uint_t throw_flag = (flags & DUK_VSRESIZE_FLAG_THROW);
 
    DUK_DDD(DUK_DDDPRINT("check valstack resize: min_new_size=%lu, curr_size=%ld, curr_top=%ld, "
                         "curr_bottom=%ld, shrink=%d, compact=%d, throw=%d",
                         (unsigned long) min_new_size,
                         (long) (thr->valstack_end - thr->valstack),
                         (long) (thr->valstack_top - thr->valstack),
                         (long) (thr->valstack_bottom - thr->valstack),
                         (int) shrink_flag, (int) compact_flag, (int) throw_flag));
 
    DUK_ASSERT_CTX_VALID(ctx);
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
    DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
    DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
 
#if defined(DUK_USE_PREFER_SIZE)
    old_size = (duk_size_t) (thr->valstack_end - thr->valstack);
#else
    DUK_ASSERT((duk_size_t) (thr->valstack_end - thr->valstack) == thr->valstack_size);
    old_size = thr->valstack_size;
#endif
 
    if (min_new_size <= old_size) {
        is_shrink = 1;
        if (!shrink_flag ||
            old_size - min_new_size < DUK_VALSTACK_SHRINK_THRESHOLD) {
            DUK_DDD(DUK_DDDPRINT("no need to grow or shrink valstack"));
            return 1;
        }
    }
 
    new_size = min_new_size;
    if (!compact_flag) {
        if (is_shrink) {
            /* shrink case; leave some spare */
            new_size += DUK_VALSTACK_SHRINK_SPARE;
        }
 
        /* round up roughly to next 'grow step' */
        new_size = (new_size / DUK_VALSTACK_GROW_STEP + 1) * DUK_VALSTACK_GROW_STEP;
    }
 
    DUK_DD(DUK_DDPRINT("want to %s valstack: %lu -> %lu elements (min_new_size %lu)",
                       (const char *) (new_size > old_size ? "grow" : "shrink"),
                       (unsigned long) old_size, (unsigned long) new_size,
                       (unsigned long) min_new_size));
 
    if (new_size > thr->valstack_max) {
        /* Note: may be triggered even if minimal new_size would not reach the limit,
         * plan limit accordingly (taking DUK_VALSTACK_GROW_STEP into account).
         */
        if (throw_flag) {
            DUK_ERROR_RANGE(thr, DUK_STR_VALSTACK_LIMIT);
        } else {
            return 0;
        }
    }
 
    /*
     *  When resizing the valstack, a mark-and-sweep may be triggered for
     *  the allocation of the new valstack.  If the mark-and-sweep needs
     *  to use our thread for something, it may cause *the same valstack*
     *  to be resized recursively.  This happens e.g. when mark-and-sweep
     *  finalizers are called.  This is taken into account carefully in
     *  duk__resize_valstack().
     *
     *  'new_size' is known to be <= valstack_max, which ensures that
     *  size_t and pointer arithmetic won't wrap in duk__resize_valstack().
     */
 
    if (!duk__resize_valstack(ctx, new_size)) {
        if (is_shrink) {
            DUK_DD(DUK_DDPRINT("valstack resize failed, but is a shrink, ignore"));
            return 1;
        }
 
        DUK_DD(DUK_DDPRINT("valstack resize failed"));
 
        if (throw_flag) {
            DUK_ERROR_ALLOC_DEFMSG(thr);
        } else {
            return 0;
        }
    }
 
    DUK_DDD(DUK_DDDPRINT("valstack resize successful"));
    return 1;
}

References duk__resize_valstack(), DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, DUK_ERROR_ALLOC_DEFMSG, DUK_ERROR_RANGE, DUK_STR_VALSTACK_LIMIT, DUK_VALSTACK_GROW_STEP, DUK_VALSTACK_SHRINK_SPARE, DUK_VALSTACK_SHRINK_THRESHOLD, DUK_VSRESIZE_FLAG_COMPACT, DUK_VSRESIZE_FLAG_SHRINK, DUK_VSRESIZE_FLAG_THROW, NULL, duk_hthread::valstack, duk_hthread::valstack_bottom, duk_hthread::valstack_end, duk_hthread::valstack_max, duk_hthread::valstack_size, and duk_hthread::valstack_top.

Referenced by duk_check_stack(), duk_check_stack_top(), duk_require_stack(), and duk_require_stack_top().

duk_xcopymove_raw()

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

Definition at line 991 of file duktape-1.5.2/src-separate/duk_api_stack.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;
        while (p < q) {
            DUK_TVAL_INCREF(to_thr, p);  /* no side effects */
            p++;
        }
    } else {
        /* No net refcount change. */
        p = from_thr->valstack_top;
        q = (duk_tval *) (void *) (((duk_uint8_t *) p) - nbytes);
        from_thr->valstack_top = q;
 
        while (p > q) {
            p--;
            DUK_TVAL_SET_UNDEFINED(p);
            /* XXX: fast primitive to set a bunch of values to UNDEFINED */
        }
    }
}

References DUK_ASSERT, DUK_ASSERT_CTX_VALID, DUK_ERROR_API, DUK_MEMCPY, DUK_STR_INVALID_CONTEXT, DUK_STR_INVALID_COUNT, DUK_STR_PUSH_BEYOND_ALLOC_STACK, DUK_TVAL_INCREF, DUK_TVAL_SET_UNDEFINED, NULL, duk_hthread::valstack_bottom, duk_hthread::valstack_end, duk_hthread::valstack_max, and duk_hthread::valstack_top.

Variable Documentation

duk__bufobj_flags_lookup

const duk_uint32_t duk__bufobj_flags_lookup[]

static

Initial value:

= {
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_BUFFER,            DUK_BIDX_BUFFER_PROTOTYPE,            DUK_HBUFFEROBJECT_ELEM_UINT8,        0, 0),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_BUFFER,            DUK_BIDX_NODEJS_BUFFER_PROTOTYPE,     DUK_HBUFFEROBJECT_ELEM_UINT8,        0, 0),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_ARRAYBUFFER,       DUK_BIDX_ARRAYBUFFER_PROTOTYPE,       DUK_HBUFFEROBJECT_ELEM_UINT8,        0, 0),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_DATAVIEW,          DUK_BIDX_DATAVIEW_PROTOTYPE,          DUK_HBUFFEROBJECT_ELEM_UINT8,        0, 1),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_INT8ARRAY,         DUK_BIDX_INT8ARRAY_PROTOTYPE,         DUK_HBUFFEROBJECT_ELEM_INT8,         0, 1),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT8ARRAY,        DUK_BIDX_UINT8ARRAY_PROTOTYPE,        DUK_HBUFFEROBJECT_ELEM_UINT8,        0, 1),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY, DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED, 0, 1),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_INT16ARRAY,        DUK_BIDX_INT16ARRAY_PROTOTYPE,        DUK_HBUFFEROBJECT_ELEM_INT16,        1, 1),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT16ARRAY,       DUK_BIDX_UINT16ARRAY_PROTOTYPE,       DUK_HBUFFEROBJECT_ELEM_UINT16,       1, 1),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_INT32ARRAY,        DUK_BIDX_INT32ARRAY_PROTOTYPE,        DUK_HBUFFEROBJECT_ELEM_INT32,        2, 1),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT32ARRAY,       DUK_BIDX_UINT32ARRAY_PROTOTYPE,       DUK_HBUFFEROBJECT_ELEM_UINT32,       2, 1),  
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_FLOAT32ARRAY,      DUK_BIDX_FLOAT32ARRAY_PROTOTYPE,      DUK_HBUFFEROBJECT_ELEM_FLOAT32,      2, 1),  
   
}

Definition at line 3898 of file duktape-1.5.2/src-separate/duk_api_stack.c.

                                                       {
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_BUFFER,            DUK_BIDX_BUFFER_PROTOTYPE,            DUK_HBUFFEROBJECT_ELEM_UINT8,        0, 0),  /* DUK_BUFOBJ_DUKTAPE_BUFFER */
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_BUFFER,            DUK_BIDX_NODEJS_BUFFER_PROTOTYPE,     DUK_HBUFFEROBJECT_ELEM_UINT8,        0, 0),  /* DUK_BUFOBJ_NODEJS_BUFFER */
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_ARRAYBUFFER,       DUK_BIDX_ARRAYBUFFER_PROTOTYPE,       DUK_HBUFFEROBJECT_ELEM_UINT8,        0, 0),  /* DUK_BUFOBJ_ARRAYBUFFER */
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_DATAVIEW,          DUK_BIDX_DATAVIEW_PROTOTYPE,          DUK_HBUFFEROBJECT_ELEM_UINT8,        0, 1),  /* DUK_BUFOBJ_DATAVIEW */
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_INT8ARRAY,         DUK_BIDX_INT8ARRAY_PROTOTYPE,         DUK_HBUFFEROBJECT_ELEM_INT8,         0, 1),  /* DUK_BUFOBJ_INT8ARRAY */
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT8ARRAY,        DUK_BIDX_UINT8ARRAY_PROTOTYPE,        DUK_HBUFFEROBJECT_ELEM_UINT8,        0, 1),  /* DUK_BUFOBJ_UINT8ARRAY */
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY, DUK_BIDX_UINT8CLAMPEDARRAY_PROTOTYPE, DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED, 0, 1),  /* DUK_BUFOBJ_UINT8CLAMPEDARRAY */
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_INT16ARRAY,        DUK_BIDX_INT16ARRAY_PROTOTYPE,        DUK_HBUFFEROBJECT_ELEM_INT16,        1, 1),  /* DUK_BUFOBJ_INT16ARRAY */
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT16ARRAY,       DUK_BIDX_UINT16ARRAY_PROTOTYPE,       DUK_HBUFFEROBJECT_ELEM_UINT16,       1, 1),  /* DUK_BUFOBJ_UINT16ARRAY */
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_INT32ARRAY,        DUK_BIDX_INT32ARRAY_PROTOTYPE,        DUK_HBUFFEROBJECT_ELEM_INT32,        2, 1),  /* DUK_BUFOBJ_INT32ARRAY */
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_UINT32ARRAY,       DUK_BIDX_UINT32ARRAY_PROTOTYPE,       DUK_HBUFFEROBJECT_ELEM_UINT32,       2, 1),  /* DUK_BUFOBJ_UINT32ARRAY */
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_FLOAT32ARRAY,      DUK_BIDX_FLOAT32ARRAY_PROTOTYPE,      DUK_HBUFFEROBJECT_ELEM_FLOAT32,      2, 1),  /* DUK_BUFOBJ_FLOAT32ARRAY */
    DUK__PACK_ARGS(DUK_HOBJECT_CLASS_FLOAT64ARRAY,      DUK_BIDX_FLOAT64ARRAY_PROTOTYPE,      DUK_HBUFFEROBJECT_ELEM_FLOAT64,      3, 1)   /* DUK_BUFOBJ_FLOAT64ARRAY */
};

Referenced by duk_push_buffer_object().

duk_api_global_filename

DUK_EXTERNAL const char* duk_api_global_filename = NULL

Definition at line 26 of file duktape-1.5.2/src-separate/duk_api_stack.c.

Referenced by duk_error_stash(), and duk_push_error_object_stash().

duk_api_global_line

DUK_EXTERNAL duk_int_t duk_api_global_line = 0

Definition at line 27 of file duktape-1.5.2/src-separate/duk_api_stack.c.

Referenced by duk_error_stash(), and duk_push_error_object_stash().