duk_js_ops.c File Reference

#include "duk_internal.h"

Go to the source code of this file.

Functions
DUK_INTERNAL duk_bool_t	duk_js_toboolean (duk_tval *tv)
DUK_LOCAL duk_double_t	duk__tonumber_string_raw (duk_hthread *thr)
DUK_INTERNAL duk_double_t	duk_js_tonumber (duk_hthread *thr, duk_tval *tv)
DUK_INTERNAL duk_double_t	duk_js_tointeger_number (duk_double_t x)
DUK_INTERNAL duk_double_t	duk_js_tointeger (duk_hthread *thr, duk_tval *tv)
DUK_LOCAL duk_double_t	duk__toint32_touint32_helper (duk_double_t x, duk_bool_t is_toint32)
DUK_INTERNAL duk_int32_t	duk_js_toint32 (duk_hthread *thr, duk_tval *tv)
DUK_INTERNAL duk_uint32_t	duk_js_touint32 (duk_hthread *thr, duk_tval *tv)
DUK_INTERNAL duk_uint16_t	duk_js_touint16 (duk_hthread *thr, duk_tval *tv)
DUK_LOCAL duk_bool_t	duk__js_equals_number (duk_double_t x, duk_double_t y)
DUK_LOCAL duk_bool_t	duk__js_samevalue_number (duk_double_t x, duk_double_t y)
DUK_INTERNAL duk_bool_t	duk_js_equals_helper (duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags)
DUK_INTERNAL duk_small_int_t	duk_js_data_compare (const duk_uint8_t *buf1, const duk_uint8_t *buf2, duk_size_t len1, duk_size_t len2)
DUK_INTERNAL duk_small_int_t	duk_js_string_compare (duk_hstring *h1, duk_hstring *h2)
DUK_INTERNAL duk_bool_t	duk_js_compare_helper (duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags)
DUK_INTERNAL duk_bool_t	duk_js_instanceof (duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y)
DUK_INTERNAL duk_bool_t	duk_js_in (duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y)
DUK_INTERNAL duk_hstring *	duk_js_typeof (duk_hthread *thr, duk_tval *tv_x)
DUK_INTERNAL duk_small_int_t	duk_js_to_arrayindex_raw_string (const duk_uint8_t *str, duk_uint32_t blen, duk_uarridx_t *out_idx)
DUK_INTERNAL duk_uarridx_t	duk_js_to_arrayindex_string_helper (duk_hstring *h)

Function Documentation

duk__js_equals_number()

DUK_LOCAL duk_bool_t duk__js_equals_number	(	duk_double_t	x,
		duk_double_t	y )

Definition at line 440 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                           {
#if defined(DUK_USE_PARANOID_MATH)
    /* Straightforward algorithm, makes fewer compiler assumptions. */
    duk_small_int_t cx = (duk_small_int_t) DUK_FPCLASSIFY(x);
    duk_small_int_t cy = (duk_small_int_t) DUK_FPCLASSIFY(y);
    if (cx == DUK_FP_NAN || cy == DUK_FP_NAN) {
        return 0;
    }
    if (cx == DUK_FP_ZERO && cy == DUK_FP_ZERO) {
        return 1;
    }
    if (x == y) {
        return 1;
    }
    return 0;
#else  /* DUK_USE_PARANOID_MATH */
    /* Better equivalent algorithm.  If the compiler is compliant, C and
     * Ecmascript semantics are identical for this particular comparison.
     * In particular, NaNs must never compare equal and zeroes must compare
     * equal regardless of sign.  Could also use a macro, but this inlines
     * already nicely (no difference on gcc, for instance).
     */
    if (x == y) {
        /* IEEE requires that NaNs compare false */
        DUK_ASSERT(DUK_FPCLASSIFY(x) != DUK_FP_NAN);
        DUK_ASSERT(DUK_FPCLASSIFY(y) != DUK_FP_NAN);
        return 1;
    } else {
        /* IEEE requires that zeros compare the same regardless
         * of their signed, so if both x and y are zeroes, they
         * are caught above.
         */
        DUK_ASSERT(!(DUK_FPCLASSIFY(x) == DUK_FP_ZERO && DUK_FPCLASSIFY(y) == DUK_FP_ZERO));
        return 0;
    }
#endif  /* DUK_USE_PARANOID_MATH */
}

References DUK_ASSERT, DUK_FP_NAN, DUK_FP_ZERO, and DUK_FPCLASSIFY.

Referenced by duk_js_equals_helper().

duk__js_samevalue_number()

DUK_LOCAL duk_bool_t duk__js_samevalue_number	(	duk_double_t	x,
		duk_double_t	y )

Definition at line 478 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                              {
#if defined(DUK_USE_PARANOID_MATH)
    duk_small_int_t cx = (duk_small_int_t) DUK_FPCLASSIFY(x);
    duk_small_int_t cy = (duk_small_int_t) DUK_FPCLASSIFY(y);
 
    if (cx == DUK_FP_NAN && cy == DUK_FP_NAN) {
        /* SameValue(NaN, NaN) = true, regardless of NaN sign or extra bits */
        return 1;
    }
    if (cx == DUK_FP_ZERO && cy == DUK_FP_ZERO) {
        /* Note: cannot assume that a non-zero return value of signbit() would
         * always be the same -- hence cannot (portably) use something like:
         *
         *     signbit(x) == signbit(y)
         */
        duk_small_int_t sx = (DUK_SIGNBIT(x) ? 1 : 0);
        duk_small_int_t sy = (DUK_SIGNBIT(y) ? 1 : 0);
        return (sx == sy);
    }
 
    /* normal comparison; known:
     *   - both x and y are not NaNs (but one of them can be)
     *   - both x and y are not zero (but one of them can be)
     *   - x and y may be denormal or infinite
     */
 
    return (x == y);
#else  /* DUK_USE_PARANOID_MATH */
    duk_small_int_t cx = (duk_small_int_t) DUK_FPCLASSIFY(x);
    duk_small_int_t cy = (duk_small_int_t) DUK_FPCLASSIFY(y);
 
    if (x == y) {
        /* IEEE requires that NaNs compare false */
        DUK_ASSERT(DUK_FPCLASSIFY(x) != DUK_FP_NAN);
        DUK_ASSERT(DUK_FPCLASSIFY(y) != DUK_FP_NAN);
 
        /* Using classification has smaller footprint than direct comparison. */
        if (DUK_UNLIKELY(cx == DUK_FP_ZERO && cy == DUK_FP_ZERO)) {
            /* Note: cannot assume that a non-zero return value of signbit() would
             * always be the same -- hence cannot (portably) use something like:
             *
             *     signbit(x) == signbit(y)
             */
            duk_small_int_t sx = (DUK_SIGNBIT(x) ? 1 : 0);
            duk_small_int_t sy = (DUK_SIGNBIT(y) ? 1 : 0);
            return (sx == sy);
        }
        return 1;
    } else {
        /* IEEE requires that zeros compare the same regardless
         * of their signed, so if both x and y are zeroes, they
         * are caught above.
         */
        DUK_ASSERT(!(DUK_FPCLASSIFY(x) == DUK_FP_ZERO && DUK_FPCLASSIFY(y) == DUK_FP_ZERO));
 
        /* Difference to non-strict/strict comparison is that NaNs compare
         * equal and signed zero signs matter.
         */
        if (DUK_UNLIKELY(cx == DUK_FP_NAN && cy == DUK_FP_NAN)) {
            /* SameValue(NaN, NaN) = true, regardless of NaN sign or extra bits */
            return 1;
        }
        return 0;
    }
#endif  /* DUK_USE_PARANOID_MATH */
}

References DUK_ASSERT, DUK_FP_NAN, DUK_FP_ZERO, DUK_FPCLASSIFY, DUK_SIGNBIT, and DUK_UNLIKELY.

Referenced by duk_js_equals_helper().

duk__toint32_touint32_helper()

DUK_LOCAL duk_double_t duk__toint32_touint32_helper	(	duk_double_t	x,
		duk_bool_t	is_toint32 )

Definition at line 289 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                                           {
    duk_small_int_t c = (duk_small_int_t) DUK_FPCLASSIFY(x);
    duk_small_int_t s;
 
    if (c == DUK_FP_NAN || c == DUK_FP_ZERO || c == DUK_FP_INFINITE) {
        return 0.0;
    }
 
 
    /* x = sign(x) * floor(abs(x)), i.e. truncate towards zero, keep sign */
    s = (duk_small_int_t) DUK_SIGNBIT(x);
    x = DUK_FLOOR(DUK_FABS(x));
    if (s) {
        x = -x;
    }
 
    /* NOTE: fmod(x) result sign is same as sign of x, which
     * differs from what Javascript wants (see Section 9.6).
     */
 
    x = DUK_FMOD(x, DUK_DOUBLE_2TO32);    /* -> x in ]-2**32, 2**32[ */
 
    if (x < 0.0) {
        x += DUK_DOUBLE_2TO32;
    }
    /* -> x in [0, 2**32[ */
 
    if (is_toint32) {
        if (x >= DUK_DOUBLE_2TO31) {
            /* x in [2**31, 2**32[ */
 
            x -= DUK_DOUBLE_2TO32;  /* -> x in [-2**31,2**31[ */
        }
    }
 
    return x;
}

References DUK_DOUBLE_2TO31, DUK_DOUBLE_2TO32, DUK_FABS, DUK_FLOOR, DUK_FMOD, DUK_FP_INFINITE, DUK_FP_NAN, DUK_FP_ZERO, DUK_FPCLASSIFY, DUK_SIGNBIT, and s.

Referenced by duk_js_toint32(), and duk_js_touint32().

duk__tonumber_string_raw()

DUK_LOCAL duk_double_t duk__tonumber_string_raw

(

duk_hthread *

thr

)

Definition at line 148 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                  {
    duk_context *ctx = (duk_context *) thr;
    duk_small_uint_t s2n_flags;
    duk_double_t d;
 
    /* Quite lenient, e.g. allow empty as zero, but don't allow trailing
     * garbage.
     */
    s2n_flags = DUK_S2N_FLAG_TRIM_WHITE |
                DUK_S2N_FLAG_ALLOW_EXP |
                DUK_S2N_FLAG_ALLOW_PLUS |
                DUK_S2N_FLAG_ALLOW_MINUS |
                DUK_S2N_FLAG_ALLOW_INF |
                DUK_S2N_FLAG_ALLOW_FRAC |
                DUK_S2N_FLAG_ALLOW_NAKED_FRAC |
                DUK_S2N_FLAG_ALLOW_EMPTY_FRAC |
                DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO |
                DUK_S2N_FLAG_ALLOW_LEADING_ZERO |
                DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT;
 
    duk_numconv_parse(ctx, 10 /*radix*/, s2n_flags);
    d = duk_get_number(ctx, -1);
    duk_pop(ctx);
 
    return d;
}

References duk_get_number(), duk_numconv_parse(), duk_pop(), DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT, DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO, DUK_S2N_FLAG_ALLOW_EMPTY_FRAC, DUK_S2N_FLAG_ALLOW_EXP, DUK_S2N_FLAG_ALLOW_FRAC, DUK_S2N_FLAG_ALLOW_INF, DUK_S2N_FLAG_ALLOW_LEADING_ZERO, DUK_S2N_FLAG_ALLOW_MINUS, DUK_S2N_FLAG_ALLOW_NAKED_FRAC, DUK_S2N_FLAG_ALLOW_PLUS, and DUK_S2N_FLAG_TRIM_WHITE.

Referenced by duk_js_tonumber().

duk_js_compare_helper()

DUK_INTERNAL duk_bool_t duk_js_compare_helper	(	duk_hthread *	thr,
		duk_tval *	tv_x,
		duk_tval *	tv_y,
		duk_small_int_t	flags )

Definition at line 845 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                                                                       {
    duk_context *ctx = (duk_context *) thr;
    duk_double_t d1, d2;
    duk_small_int_t c1, c2;
    duk_small_int_t s1, s2;
    duk_small_int_t rc;
    duk_bool_t retval;
 
    /* Fast path for fastints */
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) {
        duk_int64_t v1 = DUK_TVAL_GET_FASTINT(tv_x);
        duk_int64_t v2 = DUK_TVAL_GET_FASTINT(tv_y);
        if (v1 < v2) {
            /* 'lt is true' */
            retval = 1;
        } else {
            retval = 0;
        }
        if (flags & DUK_COMPARE_FLAG_NEGATE) {
            retval ^= 1;
        }
        return retval;
    }
#endif  /* DUK_USE_FASTINT */
 
    /* Fast path for numbers (one of which may be a fastint) */
#if 1  /* XXX: make fast paths optional for size minimization? */
    if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) {
        d1 = DUK_TVAL_GET_NUMBER(tv_x);
        d2 = DUK_TVAL_GET_NUMBER(tv_y);
        c1 = DUK_FPCLASSIFY(d1);
        c2 = DUK_FPCLASSIFY(d2);
 
        if (c1 == DUK_FP_NORMAL && c2 == DUK_FP_NORMAL) {
            /* XXX: this is a very narrow check, and doesn't cover
             * zeroes, subnormals, infinities, which compare normally.
             */
 
            if (d1 < d2) {
                /* 'lt is true' */
                retval = 1;
            } else {
                retval = 0;
            }
            if (flags & DUK_COMPARE_FLAG_NEGATE) {
                retval ^= 1;
            }
            return retval;
        }
    }
#endif
 
    /* Slow path */
 
    duk_push_tval(ctx, tv_x);
    duk_push_tval(ctx, tv_y);
 
    if (flags & DUK_COMPARE_FLAG_EVAL_LEFT_FIRST) {
        duk_to_primitive(ctx, -2, DUK_HINT_NUMBER);
        duk_to_primitive(ctx, -1, DUK_HINT_NUMBER);
    } else {
        duk_to_primitive(ctx, -1, DUK_HINT_NUMBER);
        duk_to_primitive(ctx, -2, DUK_HINT_NUMBER);
    }
 
    /* Note: reuse variables */
    tv_x = DUK_GET_TVAL_NEGIDX(ctx, -2);
    tv_y = DUK_GET_TVAL_NEGIDX(ctx, -1);
 
    if (DUK_TVAL_IS_STRING(tv_x) && DUK_TVAL_IS_STRING(tv_y)) {
        duk_hstring *h1 = DUK_TVAL_GET_STRING(tv_x);
        duk_hstring *h2 = DUK_TVAL_GET_STRING(tv_y);
        DUK_ASSERT(h1 != NULL);
        DUK_ASSERT(h2 != NULL);
 
        rc = duk_js_string_compare(h1, h2);
        if (rc < 0) {
            goto lt_true;
        } else {
            goto lt_false;
        }
    } else {
        /* Ordering should not matter (E5 Section 11.8.5, step 3.a) but
         * preserve it just in case.
         */
 
        if (flags & DUK_COMPARE_FLAG_EVAL_LEFT_FIRST) {
            d1 = duk_to_number(ctx, -2);
            d2 = duk_to_number(ctx, -1);
        } else {
            d2 = duk_to_number(ctx, -1);
            d1 = duk_to_number(ctx, -2);
        }
 
        c1 = (duk_small_int_t) DUK_FPCLASSIFY(d1);
        s1 = (duk_small_int_t) DUK_SIGNBIT(d1);
        c2 = (duk_small_int_t) DUK_FPCLASSIFY(d2);
        s2 = (duk_small_int_t) DUK_SIGNBIT(d2);
 
        if (c1 == DUK_FP_NAN || c2 == DUK_FP_NAN) {
            goto lt_undefined;
        }
 
        if (c1 == DUK_FP_ZERO && c2 == DUK_FP_ZERO) {
            /* For all combinations: +0 < +0, +0 < -0, -0 < +0, -0 < -0,
             * steps e, f, and g.
             */
            goto lt_false;
        }
 
        if (d1 == d2) {
            goto lt_false;
        }
 
        if (c1 == DUK_FP_INFINITE && s1 == 0) {
            /* x == +Infinity */
            goto lt_false;
        }
 
        if (c2 == DUK_FP_INFINITE && s2 == 0) {
            /* y == +Infinity */
            goto lt_true;
        }
 
        if (c2 == DUK_FP_INFINITE && s2 != 0) {
            /* y == -Infinity */
            goto lt_false;
        }
 
        if (c1 == DUK_FP_INFINITE && s1 != 0) {
            /* x == -Infinity */
            goto lt_true;
        }
 
        if (d1 < d2) {
            goto lt_true;
        }
 
        goto lt_false;
    }
 
 lt_undefined:
    /* Note: undefined from Section 11.8.5 always results in false
     * return (see e.g. Section 11.8.3) - hence special treatment here.
     */
    retval = 0;
    goto cleanup;
 
 lt_true:
    if (flags & DUK_COMPARE_FLAG_NEGATE) {
        retval = 0;
        goto cleanup;
    } else {
        retval = 1;
        goto cleanup;
    }
    /* never here */
 
 lt_false:
    if (flags & DUK_COMPARE_FLAG_NEGATE) {
        retval = 1;
        goto cleanup;
    } else {
        retval = 0;
        goto cleanup;
    }
    /* never here */
 
 cleanup:
    duk_pop_2(ctx);
    return retval;
}

References DUK_ASSERT, DUK_COMPARE_FLAG_EVAL_LEFT_FIRST, DUK_COMPARE_FLAG_NEGATE, DUK_FP_INFINITE, DUK_FP_NAN, DUK_FP_NORMAL, DUK_FP_ZERO, DUK_FPCLASSIFY, DUK_GET_TVAL_NEGIDX, DUK_HINT_NUMBER, duk_js_string_compare(), duk_pop_2(), duk_push_tval(), DUK_SIGNBIT, duk_to_number(), duk_to_primitive(), DUK_TVAL_GET_NUMBER, DUK_TVAL_GET_STRING, DUK_TVAL_IS_NUMBER, DUK_TVAL_IS_STRING, and NULL.

duk_js_data_compare()

DUK_INTERNAL duk_small_int_t duk_js_data_compare	(	const duk_uint8_t *	buf1,
		const duk_uint8_t *	buf2,
		duk_size_t	len1,
		duk_size_t	len2 )

Definition at line 777 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                                                                                     {
    duk_size_t prefix_len;
    duk_small_int_t rc;
 
    prefix_len = (len1 <= len2 ? len1 : len2);
 
    /* DUK_MEMCMP() is guaranteed to return zero (equal) for zero length
     * inputs so no zero length check is needed.
     */
    rc = DUK_MEMCMP((const void *) buf1,
                    (const void *) buf2,
                    (size_t) prefix_len);
 
    if (rc < 0) {
        return -1;
    } else if (rc > 0) {
        return 1;
    }
 
    /* prefix matches, lengths matter now */
    if (len1 < len2) {
        /* e.g. "x" < "xx" */
        return -1;
    } else if (len1 > len2) {
        return 1;
    }
 
    return 0;
}

References DUK_MEMCMP.

Referenced by duk_js_string_compare().

duk_js_equals_helper()

DUK_INTERNAL duk_bool_t duk_js_equals_helper	(	duk_hthread *	thr,
		duk_tval *	tv_x,
		duk_tval *	tv_y,
		duk_small_int_t	flags )

Definition at line 545 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                                                                      {
    duk_context *ctx = (duk_context *) thr;
    duk_tval *tv_tmp;
 
    /* If flags != 0 (strict or SameValue), thr can be NULL.  For loose
     * equals comparison it must be != NULL.
     */
    DUK_ASSERT(flags != 0 || thr != NULL);
 
    /*
     *  Same type?
     *
     *  Note: since number values have no explicit tag in the 8-byte
     *  representation, need the awkward if + switch.
     */
 
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) {
        if (DUK_TVAL_GET_FASTINT(tv_x) == DUK_TVAL_GET_FASTINT(tv_y)) {
            return 1;
        } else {
            return 0;
        }
    }
    else
#endif
    if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) {
        /* Catches both doubles and cases where only one argument is a fastint */
        if (DUK_UNLIKELY((flags & DUK_EQUALS_FLAG_SAMEVALUE) != 0)) {
            /* SameValue */
            return duk__js_samevalue_number(DUK_TVAL_GET_NUMBER(tv_x),
                                            DUK_TVAL_GET_NUMBER(tv_y));
        } else {
            /* equals and strict equals */
            return duk__js_equals_number(DUK_TVAL_GET_NUMBER(tv_x),
                                         DUK_TVAL_GET_NUMBER(tv_y));
        }
    } else if (DUK_TVAL_GET_TAG(tv_x) == DUK_TVAL_GET_TAG(tv_y)) {
        switch (DUK_TVAL_GET_TAG(tv_x)) {
        case DUK_TAG_UNDEFINED:
        case DUK_TAG_NULL: {
            return 1;
        }
        case DUK_TAG_BOOLEAN: {
            return DUK_TVAL_GET_BOOLEAN(tv_x) == DUK_TVAL_GET_BOOLEAN(tv_y);
        }
        case DUK_TAG_POINTER: {
            return DUK_TVAL_GET_POINTER(tv_x) == DUK_TVAL_GET_POINTER(tv_y);
        }
        case DUK_TAG_STRING:
        case DUK_TAG_OBJECT: {
            /* heap pointer comparison suffices */
            return DUK_TVAL_GET_HEAPHDR(tv_x) == DUK_TVAL_GET_HEAPHDR(tv_y);
        }
        case DUK_TAG_BUFFER: {
            if ((flags & (DUK_EQUALS_FLAG_STRICT | DUK_EQUALS_FLAG_SAMEVALUE)) != 0) {
                /* heap pointer comparison suffices */
                return DUK_TVAL_GET_HEAPHDR(tv_x) == DUK_TVAL_GET_HEAPHDR(tv_y);
            } else {
                /* non-strict equality for buffers compares contents */
                duk_hbuffer *h_x = DUK_TVAL_GET_BUFFER(tv_x);
                duk_hbuffer *h_y = DUK_TVAL_GET_BUFFER(tv_y);
                duk_size_t len_x = DUK_HBUFFER_GET_SIZE(h_x);
                duk_size_t len_y = DUK_HBUFFER_GET_SIZE(h_y);
                void *buf_x;
                void *buf_y;
                if (len_x != len_y) {
                    return 0;
                }
                buf_x = (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_x);
                buf_y = (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_y);
                /* if len_x == len_y == 0, buf_x and/or buf_y may
                 * be NULL, but that's OK.
                 */
                DUK_ASSERT(len_x == len_y);
                DUK_ASSERT(len_x == 0 || buf_x != NULL);
                DUK_ASSERT(len_y == 0 || buf_y != NULL);
                return (DUK_MEMCMP((const void *) buf_x, (const void *) buf_y, (size_t) len_x) == 0) ? 1 : 0;
            }
        }
        case DUK_TAG_LIGHTFUNC: {
            /* At least 'magic' has a significant impact on function
             * identity.
             */
            duk_small_uint_t lf_flags_x;
            duk_small_uint_t lf_flags_y;
            duk_c_function func_x;
            duk_c_function func_y;
 
            DUK_TVAL_GET_LIGHTFUNC(tv_x, func_x, lf_flags_x);
            DUK_TVAL_GET_LIGHTFUNC(tv_y, func_y, lf_flags_y);
            return ((func_x == func_y) && (lf_flags_x == lf_flags_y)) ? 1 : 0;
        }
#if defined(DUK_USE_FASTINT)
        case DUK_TAG_FASTINT:
#endif
        default: {
            DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv_x));
            DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv_y));
            DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_x));
            DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_y));
            DUK_UNREACHABLE();
            return 0;
        }
        }
    }
 
    if ((flags & (DUK_EQUALS_FLAG_STRICT | DUK_EQUALS_FLAG_SAMEVALUE)) != 0) {
        return 0;
    }
 
    DUK_ASSERT(flags == 0);  /* non-strict equality from here on */
 
    /*
     *  Types are different; various cases for non-strict comparison
     *
     *  Since comparison is symmetric, we use a "swap trick" to reduce
     *  code size.
     */
 
    /* Undefined/null are considered equal (e.g. "null == undefined" -> true). */
    if ((DUK_TVAL_IS_UNDEFINED(tv_x) && DUK_TVAL_IS_NULL(tv_y)) ||
        (DUK_TVAL_IS_NULL(tv_x) && DUK_TVAL_IS_UNDEFINED(tv_y))) {
        return 1;
    }
 
    /* Number/string-or-buffer -> coerce string to number (e.g. "'1.5' == 1.5" -> true). */
    if (DUK_TVAL_IS_NUMBER(tv_x) && (DUK_TVAL_IS_STRING(tv_y) || DUK_TVAL_IS_BUFFER(tv_y))) {
        /* the next 'if' is guaranteed to match after swap */
        tv_tmp = tv_x;
        tv_x = tv_y;
        tv_y = tv_tmp;
    }
    if ((DUK_TVAL_IS_STRING(tv_x) || DUK_TVAL_IS_BUFFER(tv_x)) && DUK_TVAL_IS_NUMBER(tv_y)) {
        /* XXX: this is possible without resorting to the value stack */
        duk_double_t d1, d2;
        d2 = DUK_TVAL_GET_NUMBER(tv_y);
        duk_push_tval(ctx, tv_x);
        duk_to_string(ctx, -1);  /* buffer values are coerced first to string here */
        duk_to_number(ctx, -1);
        d1 = duk_require_number(ctx, -1);
        duk_pop(ctx);
        return duk__js_equals_number(d1, d2);
    }
 
    /* Buffer/string -> compare contents. */
    if (DUK_TVAL_IS_BUFFER(tv_x) && DUK_TVAL_IS_STRING(tv_y)) {
        tv_tmp = tv_x;
        tv_x = tv_y;
        tv_y = tv_tmp;
    }
    if (DUK_TVAL_IS_STRING(tv_x) && DUK_TVAL_IS_BUFFER(tv_y)) {
        duk_hstring *h_x = DUK_TVAL_GET_STRING(tv_x);
        duk_hbuffer *h_y = DUK_TVAL_GET_BUFFER(tv_y);
        duk_size_t len_x = DUK_HSTRING_GET_BYTELEN(h_x);
        duk_size_t len_y = DUK_HBUFFER_GET_SIZE(h_y);
        const void *buf_x;
        const void *buf_y;
        if (len_x != len_y) {
            return 0;
        }
        buf_x = (const void *) DUK_HSTRING_GET_DATA(h_x);
        buf_y = (const void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_y);
        /* if len_x == len_y == 0, buf_x and/or buf_y may
         * be NULL, but that's OK.
         */
        DUK_ASSERT(len_x == len_y);
        DUK_ASSERT(len_x == 0 || buf_x != NULL);
        DUK_ASSERT(len_y == 0 || buf_y != NULL);
        return (DUK_MEMCMP((const void *) buf_x, (const void *) buf_y, (size_t) len_x) == 0) ? 1 : 0;
    }
 
    /* Boolean/any -> coerce boolean to number and try again.  If boolean is
     * compared to a pointer, the final comparison after coercion now always
     * yields false (as pointer vs. number compares to false), but this is
     * not special cased.
     */
    if (DUK_TVAL_IS_BOOLEAN(tv_x)) {
        tv_tmp = tv_x;
        tv_x = tv_y;
        tv_y = tv_tmp;
    }
    if (DUK_TVAL_IS_BOOLEAN(tv_y)) {
        /* ToNumber(bool) is +1.0 or 0.0.  Tagged boolean value is always 0 or 1. */
        duk_bool_t rc;
        DUK_ASSERT(DUK_TVAL_GET_BOOLEAN(tv_y) == 0 || DUK_TVAL_GET_BOOLEAN(tv_y) == 1);
        duk_push_tval(ctx, tv_x);
        duk_push_int(ctx, DUK_TVAL_GET_BOOLEAN(tv_y));
        rc = duk_js_equals_helper(thr,
                                  DUK_GET_TVAL_NEGIDX(ctx, -2),
                                  DUK_GET_TVAL_NEGIDX(ctx, -1),
                                  0 /*flags:nonstrict*/);
        duk_pop_2(ctx);
        return rc;
    }
 
    /* String-number-buffer/object -> coerce object to primitive (apparently without hint), then try again. */
    if ((DUK_TVAL_IS_STRING(tv_x) || DUK_TVAL_IS_NUMBER(tv_x) || DUK_TVAL_IS_BUFFER(tv_x)) &&
        DUK_TVAL_IS_OBJECT(tv_y)) {
        tv_tmp = tv_x;
        tv_x = tv_y;
        tv_y = tv_tmp;
    }
    if (DUK_TVAL_IS_OBJECT(tv_x) &&
        (DUK_TVAL_IS_STRING(tv_y) || DUK_TVAL_IS_NUMBER(tv_y) || DUK_TVAL_IS_BUFFER(tv_y))) {
        duk_bool_t rc;
        duk_push_tval(ctx, tv_x);
        duk_push_tval(ctx, tv_y);
        duk_to_primitive(ctx, -2, DUK_HINT_NONE);  /* apparently no hint? */
        rc = duk_js_equals_helper(thr,
                                  DUK_GET_TVAL_NEGIDX(ctx, -2),
                                  DUK_GET_TVAL_NEGIDX(ctx, -1),
                                  0 /*flags:nonstrict*/);
        duk_pop_2(ctx);
        return rc;
    }
 
    /* Nothing worked -> not equal. */
    return 0;
}

References duk__js_equals_number(), duk__js_samevalue_number(), DUK_ASSERT, DUK_EQUALS_FLAG_SAMEVALUE, DUK_EQUALS_FLAG_STRICT, DUK_GET_TVAL_NEGIDX, DUK_HBUFFER_GET_DATA_PTR, DUK_HBUFFER_GET_SIZE, DUK_HINT_NONE, DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_DATA, duk_js_equals_helper(), DUK_MEMCMP, duk_pop(), duk_pop_2(), duk_push_int(), duk_push_tval(), duk_require_number(), 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_number(), duk_to_primitive(), duk_to_string(), DUK_TVAL_GET_BOOLEAN, DUK_TVAL_GET_BUFFER, DUK_TVAL_GET_HEAPHDR, DUK_TVAL_GET_LIGHTFUNC, DUK_TVAL_GET_NUMBER, DUK_TVAL_GET_POINTER, DUK_TVAL_GET_STRING, DUK_TVAL_GET_TAG, DUK_TVAL_IS_BOOLEAN, DUK_TVAL_IS_BUFFER, DUK_TVAL_IS_NULL, DUK_TVAL_IS_NUMBER, DUK_TVAL_IS_OBJECT, DUK_TVAL_IS_STRING, DUK_TVAL_IS_UNDEFINED, DUK_TVAL_IS_UNUSED, DUK_UNLIKELY, DUK_UNREACHABLE, duk_hthread::heap, and NULL.

Referenced by duk_js_equals_helper().

duk_js_in()

DUK_INTERNAL duk_bool_t duk_js_in	(	duk_hthread *	thr,
		duk_tval *	tv_x,
		duk_tval *	tv_y )

Definition at line 1196 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                                    {
    duk_context *ctx = (duk_context *) thr;
    duk_bool_t retval;
 
    /*
     *  Get the values onto the stack first.  It would be possible to cover
     *  some normal cases without resorting to the value stack (e.g. if
     *  lval is already a string).
     */
 
    /* XXX: The ES5/5.1/6 specifications require that the key in 'key in obj'
     * must be string coerced before the internal HasProperty() algorithm is
     * invoked.  A fast path skipping coercion could be safely implemented for
     * numbers (as number-to-string coercion has no side effects).  For ES6
     * proxy behavior, the trap 'key' argument must be in a string coerced
     * form (which is a shame).
     */
 
    /* TypeError if rval is not an object (or lightfunc which should behave
     * like a Function instance).
     */
    duk_push_tval(ctx, tv_x);
    duk_push_tval(ctx, tv_y);
    duk_require_type_mask(ctx, -1, DUK_TYPE_MASK_OBJECT | DUK_TYPE_MASK_LIGHTFUNC);
    duk_to_string(ctx, -2);               /* coerce lval with ToString() */
 
    retval = duk_hobject_hasprop(thr,
                                 DUK_GET_TVAL_NEGIDX(ctx, -1),
                                 DUK_GET_TVAL_NEGIDX(ctx, -2));
 
    duk_pop_2(ctx);
    return retval;
}

References DUK_GET_TVAL_NEGIDX, duk_hobject_hasprop(), duk_pop_2(), duk_push_tval(), duk_require_type_mask, duk_to_string(), DUK_TYPE_MASK_LIGHTFUNC, and DUK_TYPE_MASK_OBJECT.

duk_js_instanceof()

DUK_INTERNAL duk_bool_t duk_js_instanceof	(	duk_hthread *	thr,
		duk_tval *	tv_x,
		duk_tval *	tv_y )

Definition at line 1039 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                                            {
    duk_context *ctx = (duk_context *) thr;
    duk_hobject *func;
    duk_hobject *val;
    duk_hobject *proto;
    duk_uint_t sanity;
 
    /*
     *  Get the values onto the stack first.  It would be possible to cover
     *  some normal cases without resorting to the value stack.
     *
     *  The right hand side could be a light function (as they generally
     *  behave like objects).  Light functions never have a 'prototype'
     *  property so E5.1 Section 15.3.5.3 step 3 always throws a TypeError.
     *  Using duk_require_hobject() is thus correct (except for error msg).
     */
 
    duk_push_tval(ctx, tv_x);
    duk_push_tval(ctx, tv_y);
    func = duk_require_hobject(ctx, -1);
 
    /*
     *  For bound objects, [[HasInstance]] just calls the target function
     *  [[HasInstance]].  If that is again a bound object, repeat until
     *  we find a non-bound Function object.
     */
 
    /* XXX: this bound function resolution also happens elsewhere,
     * move into a shared helper.
     */
 
    sanity = DUK_HOBJECT_BOUND_CHAIN_SANITY;
    do {
        /* check func supports [[HasInstance]] (this is checked for every function
         * in the bound chain, including the final one)
         */
 
        if (!DUK_HOBJECT_IS_CALLABLE(func)) {
            /*
             *  Note: of native Ecmascript objects, only Function instances
             *  have a [[HasInstance]] internal property.  Custom objects might
             *  also have it, but not in current implementation.
             *
             *  XXX: add a separate flag, DUK_HOBJECT_FLAG_ALLOW_INSTANCEOF?
             */
            DUK_ERROR_TYPE(thr, "invalid instanceof rval");
        }
 
        if (!DUK_HOBJECT_HAS_BOUND(func)) {
            break;
        }
 
        /* [ ... lval rval ] */
 
        duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_TARGET);         /* -> [ ... lval rval new_rval ] */
        duk_replace(ctx, -1);                                        /* -> [ ... lval new_rval ] */
        func = duk_require_hobject(ctx, -1);
 
        /* func support for [[HasInstance]] checked in the beginning of the loop */
    } while (--sanity > 0);
 
    if (sanity == 0) {
        DUK_ERROR_RANGE(thr, DUK_STR_BOUND_CHAIN_LIMIT);
    }
 
    /*
     *  'func' is now a non-bound object which supports [[HasInstance]]
     *  (which here just means DUK_HOBJECT_FLAG_CALLABLE).  Move on
     *  to execute E5 Section 15.3.5.3.
     */
 
    DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func));
    DUK_ASSERT(DUK_HOBJECT_IS_CALLABLE(func));
 
    /* [ ... lval rval(func) ] */
 
    /* Handle lightfuncs through object coercion for now. */
    /* XXX: direct implementation */
    val = duk_get_hobject_or_lfunc_coerce(ctx, -2);
    if (!val) {
        goto pop_and_false;
    }
 
    duk_get_prop_stridx(ctx, -1, DUK_STRIDX_PROTOTYPE);  /* -> [ ... lval rval rval.prototype ] */
    proto = duk_require_hobject(ctx, -1);
    duk_pop(ctx);  /* -> [ ... lval rval ] */
 
    DUK_ASSERT(val != NULL);
 
#if defined(DUK_USE_ES6_PROXY)
    val = duk_hobject_resolve_proxy_target(thr, val);
    DUK_ASSERT(val != NULL);
#endif
 
    sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY;
    do {
        /*
         *  Note: prototype chain is followed BEFORE first comparison.  This
         *  means that the instanceof lval is never itself compared to the
         *  rval.prototype property.  This is apparently intentional, see E5
         *  Section 15.3.5.3, step 4.a.
         *
         *  Also note:
         *
         *      js> (function() {}) instanceof Function
         *      true
         *      js> Function instanceof Function
         *      true
         *
         *  For the latter, h_proto will be Function.prototype, which is the
         *  built-in Function prototype.  Because Function.[[Prototype]] is
         *  also the built-in Function prototype, the result is true.
         */
 
        DUK_ASSERT(val != NULL);
        val = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, val);
 
        if (!val) {
            goto pop_and_false;
        }
 
        DUK_ASSERT(val != NULL);
#if defined(DUK_USE_ES6_PROXY)
        val = duk_hobject_resolve_proxy_target(thr, val);
#endif
 
        if (val == proto) {
            goto pop_and_true;
        }
 
        /* follow prototype chain */
    } while (--sanity > 0);
 
    if (sanity == 0) {
        DUK_ERROR_RANGE(thr, DUK_STR_PROTOTYPE_CHAIN_LIMIT);
    }
    DUK_UNREACHABLE();
 
 pop_and_false:
    duk_pop_2(ctx);
    return 0;
 
 pop_and_true:
    duk_pop_2(ctx);
    return 1;
}

References DUK_ASSERT, DUK_ERROR_RANGE, DUK_ERROR_TYPE, duk_get_hobject_or_lfunc_coerce(), duk_get_prop_stridx(), DUK_HOBJECT_BOUND_CHAIN_SANITY, DUK_HOBJECT_GET_PROTOTYPE, DUK_HOBJECT_HAS_BOUND, DUK_HOBJECT_IS_CALLABLE, DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY, duk_hobject_resolve_proxy_target(), duk_pop(), duk_pop_2(), duk_push_tval(), duk_replace(), duk_require_hobject(), DUK_STR_BOUND_CHAIN_LIMIT, DUK_STR_PROTOTYPE_CHAIN_LIMIT, DUK_STRIDX_INT_TARGET, DUK_STRIDX_PROTOTYPE, DUK_UNREACHABLE, duk_hthread::heap, NULL, and proto.

duk_js_string_compare()

DUK_INTERNAL duk_small_int_t duk_js_string_compare	(	duk_hstring *	h1,
		duk_hstring *	h2 )

Definition at line 807 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                                     {
    /*
     *  String comparison (E5 Section 11.8.5, step 4), which
     *  needs to compare codepoint by codepoint.
     *
     *  However, UTF-8 allows us to use strcmp directly: the shared
     *  prefix will be encoded identically (UTF-8 has unique encoding)
     *  and the first differing character can be compared with a simple
     *  unsigned byte comparison (which strcmp does).
     *
     *  This will not work properly for non-xutf-8 strings, but this
     *  is not an issue for compliance.
     */
 
    DUK_ASSERT(h1 != NULL);
    DUK_ASSERT(h2 != NULL);
 
    return duk_js_data_compare((const duk_uint8_t *) DUK_HSTRING_GET_DATA(h1),
                               (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h2),
                               (duk_size_t) DUK_HSTRING_GET_BYTELEN(h1),
                               (duk_size_t) DUK_HSTRING_GET_BYTELEN(h2));
}

References DUK_ASSERT, DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_DATA, duk_js_data_compare(), and NULL.

Referenced by duk_js_compare_helper().

duk_js_to_arrayindex_raw_string()

DUK_INTERNAL duk_small_int_t duk_js_to_arrayindex_raw_string	(	const duk_uint8_t *	str,
		duk_uint32_t	blen,
		duk_uarridx_t *	out_idx )

Definition at line 1317 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                                                                                {
    duk_uarridx_t res, new_res;
 
    if (blen == 0 || blen > 10) {
        goto parse_fail;
    }
    if (str[0] == (duk_uint8_t) '0' && blen > 1) {
        goto parse_fail;
    }
 
    /* Accept 32-bit decimal integers, no leading zeroes, signs, etc.
     * Leading zeroes are not accepted (zero index "0" is an exception
     * handled above).
     */
 
    res = 0;
    while (blen-- > 0) {
        duk_uint8_t c = *str++;
        if (c >= (duk_uint8_t) '0' && c <= (duk_uint8_t) '9') {
            new_res = res * 10 + (duk_uint32_t) (c - (duk_uint8_t) '0');
            if (new_res < res) {
                /* overflow, more than 32 bits -> not an array index */
                goto parse_fail;
            }
            res = new_res;
        } else {
            goto parse_fail;
        }
    }
 
    *out_idx = res;
    return 1;
 
 parse_fail:
    *out_idx = DUK_HSTRING_NO_ARRAY_INDEX;
    return 0;
}

References DUK_HSTRING_NO_ARRAY_INDEX.

Referenced by duk_js_to_arrayindex_string_helper().

duk_js_to_arrayindex_string_helper()

DUK_INTERNAL duk_uarridx_t duk_js_to_arrayindex_string_helper

(

duk_hstring *

h

)

Definition at line 1356 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                              {
    duk_uarridx_t res;
    duk_small_int_t rc;
 
    if (!DUK_HSTRING_HAS_ARRIDX(h)) {
        return DUK_HSTRING_NO_ARRAY_INDEX;
    }
 
    rc = duk_js_to_arrayindex_raw_string(DUK_HSTRING_GET_DATA(h),
                                         DUK_HSTRING_GET_BYTELEN(h),
                                         &res);
    DUK_UNREF(rc);
    DUK_ASSERT(rc != 0);
    return res;
}

References DUK_ASSERT, DUK_HSTRING_GET_BYTELEN, DUK_HSTRING_GET_DATA, DUK_HSTRING_HAS_ARRIDX, DUK_HSTRING_NO_ARRAY_INDEX, duk_js_to_arrayindex_raw_string(), and DUK_UNREF.

duk_js_toboolean()

DUK_INTERNAL duk_bool_t duk_js_toboolean

(

duk_tval *

tv

)

Definition at line 65 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                       {
    switch (DUK_TVAL_GET_TAG(tv)) {
    case DUK_TAG_UNDEFINED:
    case DUK_TAG_NULL:
        return 0;
    case DUK_TAG_BOOLEAN:
        return DUK_TVAL_GET_BOOLEAN(tv);
    case DUK_TAG_STRING: {
        duk_hstring *h = DUK_TVAL_GET_STRING(tv);
        DUK_ASSERT(h != NULL);
        return (DUK_HSTRING_GET_BYTELEN(h) > 0 ? 1 : 0);
    }
    case DUK_TAG_OBJECT: {
        return 1;
    }
    case DUK_TAG_BUFFER: {
        /* mimic semantics for strings */
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
        DUK_ASSERT(h != NULL);
        return (DUK_HBUFFER_GET_SIZE(h) > 0 ? 1 : 0);
    }
    case DUK_TAG_POINTER: {
        void *p = DUK_TVAL_GET_POINTER(tv);
        return (p != NULL ? 1 : 0);
    }
    case DUK_TAG_LIGHTFUNC: {
        return 1;
    }
#if defined(DUK_USE_FASTINT)
    case DUK_TAG_FASTINT:
        if (DUK_TVAL_GET_FASTINT(tv) != 0) {
            return 1;
        } else {
            return 0;
        }
#endif
    default: {
        /* number */
        duk_double_t d;
        int c;
        DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv));
        DUK_ASSERT(DUK_TVAL_IS_DOUBLE(tv));
        d = DUK_TVAL_GET_DOUBLE(tv);
        c = DUK_FPCLASSIFY((double) d);
        if (c == DUK_FP_ZERO || c == DUK_FP_NAN) {
            return 0;
        } else {
            return 1;
        }
    }
    }
    DUK_UNREACHABLE();
}

References DUK_ASSERT, DUK_FP_NAN, DUK_FP_ZERO, DUK_FPCLASSIFY, DUK_HBUFFER_GET_SIZE, DUK_HSTRING_GET_BYTELEN, 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_BOOLEAN, DUK_TVAL_GET_BUFFER, DUK_TVAL_GET_DOUBLE, DUK_TVAL_GET_POINTER, DUK_TVAL_GET_STRING, DUK_TVAL_GET_TAG, DUK_TVAL_IS_DOUBLE, DUK_TVAL_IS_UNUSED, DUK_UNREACHABLE, and NULL.

duk_js_toint32()

DUK_INTERNAL duk_int32_t duk_js_toint32	(	duk_hthread *	thr,
		duk_tval *	tv )

Definition at line 327 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                        {
    duk_double_t d;
 
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv)) {
        return DUK_TVAL_GET_FASTINT_I32(tv);
    }
#endif
 
    d = duk_js_tonumber(thr, tv);  /* invalidates tv */
    d = duk__toint32_touint32_helper(d, 1);
    DUK_ASSERT(DUK_FPCLASSIFY(d) == DUK_FP_ZERO || DUK_FPCLASSIFY(d) == DUK_FP_NORMAL);
    DUK_ASSERT(d >= -2147483648.0 && d <= 2147483647.0);  /* [-0x80000000,0x7fffffff] */
    DUK_ASSERT(d == ((duk_double_t) ((duk_int32_t) d)));  /* whole, won't clip */
    return (duk_int32_t) d;
}

References duk__toint32_touint32_helper(), DUK_ASSERT, DUK_FP_NORMAL, DUK_FP_ZERO, DUK_FPCLASSIFY, and duk_js_tonumber().

duk_js_tointeger()

DUK_INTERNAL duk_double_t duk_js_tointeger	(	duk_hthread *	thr,
		duk_tval *	tv )

Definition at line 278 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                           {
    /* XXX: fastint */
    duk_double_t d = duk_js_tonumber(thr, tv);  /* invalidates tv */
    return duk_js_tointeger_number(d);
}

References duk_js_tointeger_number(), and duk_js_tonumber().

duk_js_tointeger_number()

DUK_INTERNAL duk_double_t duk_js_tointeger_number

(

duk_double_t

x

)

Definition at line 258 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                  {
    duk_small_int_t c = (duk_small_int_t) DUK_FPCLASSIFY(x);
 
    if (c == DUK_FP_NAN) {
        return 0.0;
    } else if (c == DUK_FP_ZERO || c == DUK_FP_INFINITE) {
        /* XXX: FP_ZERO check can be removed, the else clause handles it
         * correctly (preserving sign).
         */
        return x;
    } else {
        duk_small_int_t s = (duk_small_int_t) DUK_SIGNBIT(x);
        x = DUK_FLOOR(DUK_FABS(x));  /* truncate towards zero */
        if (s) {
            x = -x;
        }
        return x;
    }
}

References DUK_FABS, DUK_FLOOR, DUK_FP_INFINITE, DUK_FP_NAN, DUK_FP_ZERO, DUK_FPCLASSIFY, DUK_SIGNBIT, and s.

Referenced by duk_js_tointeger().

duk_js_tonumber()

DUK_INTERNAL duk_double_t duk_js_tonumber	(	duk_hthread *	thr,
		duk_tval *	tv )

Definition at line 175 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                          {
    duk_context *ctx = (duk_hthread *) thr;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(tv != NULL);
 
    switch (DUK_TVAL_GET_TAG(tv)) {
    case DUK_TAG_UNDEFINED: {
        /* return a specific NaN (although not strictly necessary) */
        duk_double_union du;
        DUK_DBLUNION_SET_NAN(&du);
        DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du));
        return du.d;
    }
    case DUK_TAG_NULL: {
        /* +0.0 */
        return 0.0;
    }
    case DUK_TAG_BOOLEAN: {
        if (DUK_TVAL_IS_BOOLEAN_TRUE(tv)) {
            return 1.0;
        }
        return 0.0;
    }
    case DUK_TAG_STRING: {
        duk_hstring *h = DUK_TVAL_GET_STRING(tv);
        duk_push_hstring(ctx, h);
        return duk__tonumber_string_raw(thr);
    }
    case DUK_TAG_OBJECT: {
        /* Note: ToPrimitive(object,hint) == [[DefaultValue]](object,hint),
         * so use [[DefaultValue]] directly.
         */
        duk_double_t d;
        duk_push_tval(ctx, tv);
        duk_to_defaultvalue(ctx, -1, DUK_HINT_NUMBER);  /* 'tv' becomes invalid */
 
        /* recursive call for a primitive value (guaranteed not to cause second
         * recursion).
         */
        d = duk_js_tonumber(thr, duk_require_tval(ctx, -1));
 
        duk_pop(ctx);
        return d;
    }
    case DUK_TAG_BUFFER: {
        /* Coerce like a string.  This makes sense because addition also treats
         * buffers like strings.
         */
        duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
        duk_push_hbuffer(ctx, h);
        duk_to_string(ctx, -1);  /* XXX: expensive, but numconv now expects to see a string */
        return duk__tonumber_string_raw(thr);
    }
    case DUK_TAG_POINTER: {
        /* Coerce like boolean */
        void *p = DUK_TVAL_GET_POINTER(tv);
        return (p != NULL ? 1.0 : 0.0);
    }
    case DUK_TAG_LIGHTFUNC: {
        /* +(function(){}) -> NaN */
        return DUK_DOUBLE_NAN;
    }
#if defined(DUK_USE_FASTINT)
    case DUK_TAG_FASTINT:
        return (duk_double_t) DUK_TVAL_GET_FASTINT(tv);
#endif
    default: {
        /* number */
        DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv));
        DUK_ASSERT(DUK_TVAL_IS_DOUBLE(tv));
        return DUK_TVAL_GET_DOUBLE(tv);
    }
    }
 
    DUK_UNREACHABLE();
}

References duk_double_union::d, duk__tonumber_string_raw(), DUK_ASSERT, DUK_DBLUNION_IS_NORMALIZED, DUK_DBLUNION_SET_NAN, DUK_DOUBLE_NAN, DUK_HINT_NUMBER, duk_js_tonumber(), duk_pop(), duk_push_hbuffer(), duk_push_hstring(), duk_push_tval(), 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_to_defaultvalue(), duk_to_string(), DUK_TVAL_GET_BUFFER, DUK_TVAL_GET_DOUBLE, DUK_TVAL_GET_POINTER, DUK_TVAL_GET_STRING, DUK_TVAL_GET_TAG, DUK_TVAL_IS_BOOLEAN_TRUE, DUK_TVAL_IS_DOUBLE, DUK_TVAL_IS_UNUSED, DUK_UNREACHABLE, and NULL.

Referenced by duk_js_toint32(), duk_js_tointeger(), duk_js_tonumber(), and duk_js_touint32().

duk_js_touint16()

DUK_INTERNAL duk_uint16_t duk_js_touint16	(	duk_hthread *	thr,
		duk_tval *	tv )

Definition at line 363 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                          {
    /* should be a safe way to compute this */
    return (duk_uint16_t) (duk_js_touint32(thr, tv) & 0x0000ffffU);
}

References duk_js_touint32().

duk_js_touint32()

DUK_INTERNAL duk_uint32_t duk_js_touint32	(	duk_hthread *	thr,
		duk_tval *	tv )

Definition at line 345 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                          {
    duk_double_t d;
 
#if defined(DUK_USE_FASTINT)
    if (DUK_TVAL_IS_FASTINT(tv)) {
        return DUK_TVAL_GET_FASTINT_U32(tv);
    }
#endif
 
    d = duk_js_tonumber(thr, tv);  /* invalidates tv */
    d = duk__toint32_touint32_helper(d, 0);
    DUK_ASSERT(DUK_FPCLASSIFY(d) == DUK_FP_ZERO || DUK_FPCLASSIFY(d) == DUK_FP_NORMAL);
    DUK_ASSERT(d >= 0.0 && d <= 4294967295.0);  /* [0x00000000, 0xffffffff] */
    DUK_ASSERT(d == ((duk_double_t) ((duk_uint32_t) d)));  /* whole, won't clip */
    return (duk_uint32_t) d;
 
}

References duk__toint32_touint32_helper(), DUK_ASSERT, DUK_FP_NORMAL, DUK_FP_ZERO, DUK_FPCLASSIFY, and duk_js_tonumber().

Referenced by duk_js_touint16().

duk_js_typeof()

DUK_INTERNAL duk_hstring * duk_js_typeof	(	duk_hthread *	thr,
		duk_tval *	tv_x )

Definition at line 1244 of file duktape-1.5.2/src-separate/duk_js_ops.c.

                                                                          {
    duk_small_int_t stridx = 0;
 
    DUK_UNREF(thr);
 
    switch (DUK_TVAL_GET_TAG(tv_x)) {
    case DUK_TAG_UNDEFINED: {
        stridx = DUK_STRIDX_LC_UNDEFINED;
        break;
    }
    case DUK_TAG_NULL: {
        /* Note: not a typo, "object" is returned for a null value */
        stridx = DUK_STRIDX_LC_OBJECT;
        break;
    }
    case DUK_TAG_BOOLEAN: {
        stridx = DUK_STRIDX_LC_BOOLEAN;
        break;
    }
    case DUK_TAG_POINTER: {
        /* implementation specific */
        stridx = DUK_STRIDX_LC_POINTER;
        break;
    }
    case DUK_TAG_STRING: {
        stridx = DUK_STRIDX_LC_STRING;
        break;
    }
    case DUK_TAG_OBJECT: {
        duk_hobject *obj = DUK_TVAL_GET_OBJECT(tv_x);
        DUK_ASSERT(obj != NULL);
        if (DUK_HOBJECT_IS_CALLABLE(obj)) {
            stridx = DUK_STRIDX_LC_FUNCTION;
        } else {
            stridx = DUK_STRIDX_LC_OBJECT;
        }
        break;
    }
    case DUK_TAG_BUFFER: {
        /* implementation specific */
        stridx = DUK_STRIDX_LC_BUFFER;
        break;
    }
    case DUK_TAG_LIGHTFUNC: {
        stridx = DUK_STRIDX_LC_FUNCTION;
        break;
    }
#if defined(DUK_USE_FASTINT)
    case DUK_TAG_FASTINT:
#endif
    default: {
        /* number */
        DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv_x));
        DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_x));
        stridx = DUK_STRIDX_LC_NUMBER;
        break;
    }
    }
 
    DUK_ASSERT(stridx >= 0 && stridx < DUK_HEAP_NUM_STRINGS);
    return DUK_HTHREAD_GET_STRING(thr, stridx);
}

References DUK_ASSERT, DUK_HEAP_NUM_STRINGS, DUK_HOBJECT_IS_CALLABLE, DUK_HTHREAD_GET_STRING, DUK_STRIDX_LC_BOOLEAN, DUK_STRIDX_LC_BUFFER, DUK_STRIDX_LC_FUNCTION, DUK_STRIDX_LC_NUMBER, DUK_STRIDX_LC_OBJECT, DUK_STRIDX_LC_POINTER, DUK_STRIDX_LC_STRING, DUK_STRIDX_LC_UNDEFINED, 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_OBJECT, DUK_TVAL_GET_TAG, DUK_TVAL_IS_NUMBER, DUK_TVAL_IS_UNUSED, DUK_UNREF, and NULL.