Back to index

lightning-sunbird  0.9+nobinonly
Classes | Defines | Typedefs | Functions | Variables
jsnum.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

union  jsdpun
struct  jsdpun.s

Defines

#define JSDOUBLE_HI32(x)   (((uint32 *)&(x))[0])
#define JSDOUBLE_LO32(x)   (((uint32 *)&(x))[1])
#define JSDOUBLE_SET_HI32(x, y)   (JSDOUBLE_HI32(x)=(y))
#define JSDOUBLE_SET_LO32(x, y)   (JSDOUBLE_LO32(x)=(y))
#define JSDOUBLE_HI32_SIGNBIT   0x80000000
#define JSDOUBLE_HI32_EXPMASK   0x7ff00000
#define JSDOUBLE_HI32_MANTMASK   0x000fffff
#define JSDOUBLE_IS_NaN(x)
#define JSDOUBLE_IS_INFINITE(x)
#define JSDOUBLE_IS_FINITE(x)   ((JSDOUBLE_HI32(x) & JSDOUBLE_HI32_EXPMASK) != JSDOUBLE_HI32_EXPMASK)
#define JSDOUBLE_IS_NEGZERO(d)
#define JSDOUBLE_IS_INT(d, i)
#define JSDOUBLE_COMPARE(LVAL, OP, RVAL, IFNAN)   ((LVAL) OP (RVAL))

Typedefs

typedef JS_BEGIN_EXTERN_C
union jsdpun 
jsdpun

Functions

JSBool js_InitRuntimeNumberState (JSContext *cx)
void js_FinishRuntimeNumberState (JSContext *cx)
JSObjectjs_InitNumberClass (JSContext *cx, JSObject *obj)
jsdoublejs_NewDouble (JSContext *cx, jsdouble d, uintN gcflag)
void js_FinalizeDouble (JSContext *cx, jsdouble *dp)
JSBool js_NewDoubleValue (JSContext *cx, jsdouble d, jsval *rval)
JSBool js_NewNumberValue (JSContext *cx, jsdouble d, jsval *rval)
JSObjectjs_NumberToObject (JSContext *cx, jsdouble d)
JSStringjs_NumberToString (JSContext *cx, jsdouble d)
JSBool js_ValueToNumber (JSContext *cx, jsval v, jsdouble *dp)
JSBool js_ValueToECMAInt32 (JSContext *cx, jsval v, int32 *ip)
JSBool js_DoubleToECMAInt32 (JSContext *cx, jsdouble d, int32 *ip)
JSBool js_ValueToECMAUint32 (JSContext *cx, jsval v, uint32 *ip)
JSBool js_DoubleToECMAUint32 (JSContext *cx, jsdouble d, uint32 *ip)
JSBool js_ValueToInt32 (JSContext *cx, jsval v, int32 *ip)
JSBool js_ValueToUint16 (JSContext *cx, jsval v, uint16 *ip)
jsdouble js_DoubleToInteger (jsdouble d)
JSBool js_strtod (JSContext *cx, const jschar *s, const jschar **ep, jsdouble *dp)
JSBool js_strtointeger (JSContext *cx, const jschar *s, const jschar **ep, jsint radix, jsdouble *dp)

Variables

JSClass js_NumberClass
const char js_Infinity_str []
const char js_NaN_str []
const char js_isNaN_str []
const char js_isFinite_str []
const char js_parseFloat_str []
const char js_parseInt_str []

Class Documentation

union jsdpun

Definition at line 69 of file jsnum.h.

Class Members
jsdouble d
struct jsdpun s
struct jsdpun.s

Definition at line 70 of file jsnum.h.

Class Members
uint32 hi
uint32 lo

Define Documentation

#define JSDOUBLE_COMPARE (   LVAL,
  OP,
  RVAL,
  IFNAN 
)    ((LVAL) OP (RVAL))

Definition at line 147 of file jsnum.h.

#define JSDOUBLE_HI32 (   x)    (((uint32 *)&(x))[0])

Definition at line 104 of file jsnum.h.

#define JSDOUBLE_HI32_EXPMASK   0x7ff00000

Definition at line 114 of file jsnum.h.

#define JSDOUBLE_HI32_MANTMASK   0x000fffff

Definition at line 115 of file jsnum.h.

#define JSDOUBLE_HI32_SIGNBIT   0x80000000

Definition at line 113 of file jsnum.h.

Definition at line 125 of file jsnum.h.

Value:

Definition at line 121 of file jsnum.h.

#define JSDOUBLE_IS_INT (   d,
  i 
)
Value:
(JSDOUBLE_IS_FINITE(d)                          \
                               && !JSDOUBLE_IS_NEGZERO(d)                     \
                               && ((d) == (i = (jsint)(d))))

Definition at line 137 of file jsnum.h.

Value:
(JSDOUBLE_HI32(d) == JSDOUBLE_HI32_SIGNBIT && \
                                 JSDOUBLE_LO32(d) == 0)

Definition at line 128 of file jsnum.h.

#define JSDOUBLE_LO32 (   x)    (((uint32 *)&(x))[1])

Definition at line 105 of file jsnum.h.

#define JSDOUBLE_SET_HI32 (   x,
  y 
)    (JSDOUBLE_HI32(x)=(y))

Definition at line 108 of file jsnum.h.

#define JSDOUBLE_SET_LO32 (   x,
  y 
)    (JSDOUBLE_LO32(x)=(y))

Definition at line 109 of file jsnum.h.


Typedef Documentation


Function Documentation

JSBool js_DoubleToECMAInt32 ( JSContext cx,
jsdouble  d,
int32 ip 
)

Definition at line 791 of file jsnum.c.

{
    jsdouble two32 = 4294967296.0;
    jsdouble two31 = 2147483648.0;

    if (!JSDOUBLE_IS_FINITE(d) || d == 0) {
        *ip = 0;
        return JS_TRUE;
    }
    d = fmod(d, two32);
    d = (d >= 0) ? floor(d) : ceil(d) + two32;
    if (d >= two31)
        *ip = (int32)(d - two32);
    else
        *ip = (int32)d;
    return JS_TRUE;
}

Here is the caller graph for this function:

Definition at line 820 of file jsnum.c.

{
    JSBool neg;
    jsdouble two32 = 4294967296.0;

    if (!JSDOUBLE_IS_FINITE(d) || d == 0) {
        *ip = 0;
        return JS_TRUE;
    }

    neg = (d < 0);
    d = floor(neg ? -d : d);
    d = neg ? -d : d;

    d = fmod(d, two32);

    d = (d >= 0) ? d : d + two32;
    *ip = (uint32)d;
    return JS_TRUE;
}

Here is the caller graph for this function:

Definition at line 896 of file jsnum.c.

{
    JSBool neg;

    if (d == 0)
        return d;
    if (!JSDOUBLE_IS_FINITE(d)) {
        if (JSDOUBLE_IS_NaN(d))
            return 0;
        return d;
    }
    neg = (d < 0);
    d = floor(neg ? -d : d);
    return neg ? -d : d;
}

Here is the caller graph for this function:

void js_FinalizeDouble ( JSContext cx,
jsdouble dp 
)

Definition at line 666 of file jsnum.c.

{
    *dp = NaN;
}

Definition at line 599 of file jsnum.c.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 618 of file jsnum.c.

{
    JSObject *proto, *ctor;
    JSRuntime *rt;

    /* XXX must do at least once per new thread, so do it per JSContext... */
    FIX_FPU();

    if (!JS_DefineFunctions(cx, obj, number_functions))
        return NULL;

    proto = JS_InitClass(cx, obj, NULL, &js_NumberClass, Number, 1,
                         NULL, number_methods, NULL, NULL);
    if (!proto || !(ctor = JS_GetConstructor(cx, proto)))
        return NULL;
    OBJ_SET_SLOT(cx, proto, JSSLOT_PRIVATE, JSVAL_ZERO);
    if (!JS_DefineConstDoubles(cx, ctor, number_constants))
        return NULL;

    /* ECMA 15.1.1.1 */
    rt = cx->runtime;
    if (!JS_DefineProperty(cx, obj, js_NaN_str, DOUBLE_TO_JSVAL(rt->jsNaN),
                           NULL, NULL, JSPROP_PERMANENT)) {
        return NULL;
    }

    /* ECMA 15.1.1.2 */
    if (!JS_DefineProperty(cx, obj, js_Infinity_str,
                           DOUBLE_TO_JSVAL(rt->jsPositiveInfinity),
                           NULL, NULL, JSPROP_PERMANENT)) {
        return NULL;
    }
    return proto;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 551 of file jsnum.c.

{
    JSRuntime *rt;
    jsdpun u;
    struct lconv *locale;

    rt = cx->runtime;
    JS_ASSERT(!rt->jsNaN);

    FIX_FPU();

    u.s.hi = JSDOUBLE_HI32_EXPMASK | JSDOUBLE_HI32_MANTMASK;
    u.s.lo = 0xffffffff;
    number_constants[NC_NaN].dval = NaN = u.d;
    rt->jsNaN = js_NewDouble(cx, NaN, GCF_LOCK);
    if (!rt->jsNaN)
        return JS_FALSE;

    u.s.hi = JSDOUBLE_HI32_EXPMASK;
    u.s.lo = 0x00000000;
    number_constants[NC_POSITIVE_INFINITY].dval = u.d;
    rt->jsPositiveInfinity = js_NewDouble(cx, u.d, GCF_LOCK);
    if (!rt->jsPositiveInfinity)
        return JS_FALSE;

    u.s.hi = JSDOUBLE_HI32_SIGNBIT | JSDOUBLE_HI32_EXPMASK;
    u.s.lo = 0x00000000;
    number_constants[NC_NEGATIVE_INFINITY].dval = u.d;
    rt->jsNegativeInfinity = js_NewDouble(cx, u.d, GCF_LOCK);
    if (!rt->jsNegativeInfinity)
        return JS_FALSE;

    u.s.hi = 0;
    u.s.lo = 1;
    number_constants[NC_MIN_VALUE].dval = u.d;

    locale = localeconv();
    rt->thousandsSeparator =
        JS_strdup(cx, locale->thousands_sep ? locale->thousands_sep : "'");
    rt->decimalSeparator =
        JS_strdup(cx, locale->decimal_point ? locale->decimal_point : ".");
    rt->numGrouping =
        JS_strdup(cx, locale->grouping ? locale->grouping : "\3\0");

    return rt->thousandsSeparator && rt->decimalSeparator && rt->numGrouping;
}

Here is the call graph for this function:

Here is the caller graph for this function:

jsdouble* js_NewDouble ( JSContext cx,
jsdouble  d,
uintN  gcflag 
)

Definition at line 654 of file jsnum.c.

{
    jsdouble *dp;

    dp = (jsdouble *) js_NewGCThing(cx, gcflag | GCX_DOUBLE, sizeof(jsdouble));
    if (!dp)
        return NULL;
    *dp = d;
    return dp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

JSBool js_NewDoubleValue ( JSContext cx,
jsdouble  d,
jsval rval 
)

Definition at line 672 of file jsnum.c.

{
    jsdouble *dp;

    dp = js_NewDouble(cx, d, 0);
    if (!dp)
        return JS_FALSE;
    *rval = DOUBLE_TO_JSVAL(dp);
    return JS_TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

JSBool js_NewNumberValue ( JSContext cx,
jsdouble  d,
jsval rval 
)

Definition at line 684 of file jsnum.c.

{
    jsint i;

    if (JSDOUBLE_IS_INT(d, i) && INT_FITS_IN_JSVAL(i)) {
        *rval = INT_TO_JSVAL(i);
    } else {
        if (!js_NewDoubleValue(cx, d, rval))
            return JS_FALSE;
    }
    return JS_TRUE;
}

Here is the call graph for this function:

Definition at line 698 of file jsnum.c.

{
    JSObject *obj;
    jsval v;

    obj = js_NewObject(cx, &js_NumberClass, NULL, NULL);
    if (!obj)
        return NULL;
    if (!js_NewNumberValue(cx, d, &v)) {
        cx->weakRoots.newborn[GCX_OBJECT] = NULL;
        return NULL;
    }
    OBJ_SET_SLOT(cx, obj, JSSLOT_PRIVATE, v);
    return obj;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 715 of file jsnum.c.

{
    jsint i;
    char buf[DTOSTR_STANDARD_BUFFER_SIZE];
    char *numStr;

    if (JSDOUBLE_IS_INT(d, i)) {
        numStr = IntToString(i, buf, sizeof buf);
    } else {
        numStr = JS_dtostr(buf, sizeof buf, DTOSTR_STANDARD, 0, d);
        if (!numStr) {
            JS_ReportOutOfMemory(cx);
            return NULL;
        }
    }
    return JS_NewStringCopyZ(cx, numStr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

JSBool js_strtod ( JSContext cx,
const jschar s,
const jschar **  ep,
jsdouble dp 
)

Definition at line 914 of file jsnum.c.

{
    char cbuf[32];
    size_t i;
    char *cstr, *istr, *estr;
    JSBool negative;
    jsdouble d;
    const jschar *s1 = js_SkipWhiteSpace(s);
    size_t length = js_strlen(s1);

    /* Use cbuf to avoid malloc */
    if (length >= sizeof cbuf) {
        cstr = (char *) JS_malloc(cx, length + 1);
        if (!cstr)
           return JS_FALSE;
    } else {
        cstr = cbuf;
    }

    for (i = 0; i <= length; i++) {
        if (s1[i] >> 8) {
            cstr[i] = 0;
            break;
        }
        cstr[i] = (char)s1[i];
    }

    istr = cstr;
    if ((negative = (*istr == '-')) != 0 || *istr == '+')
        istr++;
    if (!strncmp(istr, js_Infinity_str, sizeof js_Infinity_str - 1)) {
        d = *(negative ? cx->runtime->jsNegativeInfinity : cx->runtime->jsPositiveInfinity);
        estr = istr + 8;
    } else {
        int err;
        d = JS_strtod(cstr, &estr, &err);
        if (err == JS_DTOA_ENOMEM) {
            JS_ReportOutOfMemory(cx);
            if (cstr != cbuf)
                JS_free(cx, cstr);
            return JS_FALSE;
        }
        if (err == JS_DTOA_ERANGE) {
            if (d == HUGE_VAL)
                d = *cx->runtime->jsPositiveInfinity;
            else if (d == -HUGE_VAL)
                d = *cx->runtime->jsNegativeInfinity;
        }
#ifdef HPUX
        if (d == 0.0 && negative) {
            /*
             * "-0", "-1e-2000" come out as positive zero
             * here on HPUX. Force a negative zero instead.
             */
            JSDOUBLE_HI32(d) = JSDOUBLE_HI32_SIGNBIT;
            JSDOUBLE_LO32(d) = 0;
        }
#endif
    }

    i = estr - cstr;
    if (cstr != cbuf)
        JS_free(cx, cstr);
    *ep = i ? s1 + i : s;
    *dp = d;
    return JS_TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

JSBool js_strtointeger ( JSContext cx,
const jschar s,
const jschar **  ep,
jsint  radix,
jsdouble dp 
)

Definition at line 1016 of file jsnum.c.

{
    JSBool negative;
    jsdouble value;
    const jschar *start;
    const jschar *s1 = js_SkipWhiteSpace(s);

    if ((negative = (*s1 == '-')) != 0 || *s1 == '+')
        s1++;

    if (base == 0) {
        /* No base supplied, or some base that evaluated to 0. */
        if (*s1 == '0') {
            /* It's either hex or octal; only increment char if str isn't '0' */
            if (s1[1] == 'X' || s1[1] == 'x') { /* Hex */
                s1 += 2;
                base = 16;
            } else {    /* Octal */
                base = 8;
            }
        } else {
            base = 10; /* Default to decimal. */
        }
    } else if (base == 16 && *s1 == '0' && (s1[1] == 'X' || s1[1] == 'x')) {
        /* If base is 16, ignore hex prefix. */
        s1 += 2;
    }

    /*
     * Done with the preliminaries; find some prefix of the string that's
     * a number in the given base.
     */
    start = s1; /* Mark - if string is empty, we return NaN. */
    value = 0.0;
    for (;;) {
        uintN digit;
        jschar c = *s1;
        if ('0' <= c && c <= '9')
            digit = c - '0';
        else if ('a' <= c && c <= 'z')
            digit = c - 'a' + 10;
        else if ('A' <= c && c <= 'Z')
            digit = c - 'A' + 10;
        else
            break;
        if (digit >= (uintN)base)
            break;
        value = value * base + digit;
        s1++;
    }

    if (value >= 9007199254740992.0) {
        if (base == 10) {
            /*
             * If we're accumulating a decimal number and the number is >=
             * 2^53, then the result from the repeated multiply-add above may
             * be inaccurate.  Call JS_strtod to get the correct answer.
             */
            size_t i;
            size_t length = s1 - start;
            char *cstr = (char *) JS_malloc(cx, length + 1);
            char *estr;
            int err=0;

            if (!cstr)
                return JS_FALSE;
            for (i = 0; i != length; i++)
                cstr[i] = (char)start[i];
            cstr[length] = 0;

            value = JS_strtod(cstr, &estr, &err);
            if (err == JS_DTOA_ENOMEM) {
                JS_ReportOutOfMemory(cx);
                JS_free(cx, cstr);
                return JS_FALSE;
            }
            if (err == JS_DTOA_ERANGE && value == HUGE_VAL)
                value = *cx->runtime->jsPositiveInfinity;
            JS_free(cx, cstr);
        } else if ((base & (base - 1)) == 0) {
            /*
             * The number may also be inaccurate for power-of-two bases.  This
             * happens if the addition in value * base + digit causes a round-
             * down to an even least significant mantissa bit when the first
             * dropped bit is a one.  If any of the following digits in the
             * number (which haven't been added in yet) are nonzero, then the
             * correct action would have been to round up instead of down.  An
             * example occurs when reading the number 0x1000000000000081, which
             * rounds to 0x1000000000000000 instead of 0x1000000000000100.
             */
            struct BinaryDigitReader bdr;
            intN bit, bit2;
            intN j;

            bdr.base = base;
            bdr.digitMask = 0;
            bdr.digits = start;
            bdr.end = s1;
            value = 0.0;

            /* Skip leading zeros. */
            do {
                bit = GetNextBinaryDigit(&bdr);
            } while (bit == 0);

            if (bit == 1) {
                /* Gather the 53 significant bits (including the leading 1) */
                value = 1.0;
                for (j = 52; j; j--) {
                    bit = GetNextBinaryDigit(&bdr);
                    if (bit < 0)
                        goto done;
                    value = value*2 + bit;
                }
                /* bit2 is the 54th bit (the first dropped from the mantissa) */
                bit2 = GetNextBinaryDigit(&bdr);
                if (bit2 >= 0) {
                    jsdouble factor = 2.0;
                    intN sticky = 0;  /* sticky is 1 if any bit beyond the 54th is 1 */
                    intN bit3;

                    while ((bit3 = GetNextBinaryDigit(&bdr)) >= 0) {
                        sticky |= bit3;
                        factor *= 2;
                    }
                    value += bit2 & (bit | sticky);
                    value *= factor;
                }
              done:;
            }
        }
    }
    /* We don't worry about inaccurate numbers for any other base. */

    if (s1 == start) {
        *dp = 0.0;
        *ep = s;
    } else {
        *dp = negative ? -value : value;
        *ep = s1;
    }
    return JS_TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

JSBool js_ValueToECMAInt32 ( JSContext cx,
jsval  v,
int32 ip 
)

Definition at line 781 of file jsnum.c.

{
    jsdouble d;

    if (!js_ValueToNumber(cx, v, &d))
        return JS_FALSE;
    return js_DoubleToECMAInt32(cx, d, ip);
}

Here is the call graph for this function:

Here is the caller graph for this function:

JSBool js_ValueToECMAUint32 ( JSContext cx,
jsval  v,
uint32 ip 
)

Definition at line 810 of file jsnum.c.

{
    jsdouble d;

    if (!js_ValueToNumber(cx, v, &d))
        return JS_FALSE;
    return js_DoubleToECMAUint32(cx, d, ip);
}

Here is the call graph for this function:

Here is the caller graph for this function:

JSBool js_ValueToInt32 ( JSContext cx,
jsval  v,
int32 ip 
)

Definition at line 842 of file jsnum.c.

{
    jsdouble d;
    JSString *str;

    if (JSVAL_IS_INT(v)) {
        *ip = JSVAL_TO_INT(v);
        return JS_TRUE;
    }
    if (!js_ValueToNumber(cx, v, &d))
        return JS_FALSE;
    if (JSDOUBLE_IS_NaN(d) || d <= -2147483649.0 || 2147483648.0 <= d) {
        str = js_DecompileValueGenerator(cx, JSDVG_SEARCH_STACK, v, NULL);
        if (str) {
            JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
                                 JSMSG_CANT_CONVERT, JS_GetStringBytes(str));

        }
        return JS_FALSE;
    }
    *ip = (int32)floor(d + 0.5);     /* Round to nearest */
    return JS_TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

JSBool js_ValueToNumber ( JSContext cx,
jsval  v,
jsdouble dp 
)

Definition at line 734 of file jsnum.c.

{
    JSObject *obj;
    JSString *str;
    const jschar *bp, *ep;

    if (JSVAL_IS_OBJECT(v)) {
        obj = JSVAL_TO_OBJECT(v);
        if (!obj) {
            *dp = 0;
            return JS_TRUE;
        }
        if (!OBJ_DEFAULT_VALUE(cx, obj, JSTYPE_NUMBER, &v))
            return JS_FALSE;
    }
    if (JSVAL_IS_INT(v)) {
        *dp = (jsdouble)JSVAL_TO_INT(v);
    } else if (JSVAL_IS_DOUBLE(v)) {
        *dp = *JSVAL_TO_DOUBLE(v);
    } else if (JSVAL_IS_STRING(v)) {
        str = JSVAL_TO_STRING(v);
        /*
         * Note that ECMA doesn't treat a string beginning with a '0' as an
         * octal number here.  This works because all such numbers will be
         * interpreted as decimal by js_strtod and will never get passed to
         * js_strtointeger (which would interpret them as octal).
         */
        /* XXXbe js_strtod shouldn't require NUL termination */
        bp = js_UndependString(cx, str);
        if (!bp)
            return JS_FALSE;
        if ((!js_strtod(cx, bp, &ep, dp) ||
             js_SkipWhiteSpace(ep) != bp + str->length) &&
            (!js_strtointeger(cx, bp, &ep, 0, dp) ||
             js_SkipWhiteSpace(ep) != bp + str->length)) {
            goto badstr;
        }
    } else if (JSVAL_IS_BOOLEAN(v)) {
        *dp = JSVAL_TO_BOOLEAN(v) ? 1 : 0;
    } else {
badstr:
        *dp = *cx->runtime->jsNaN;
    }
    return JS_TRUE;
}

Here is the call graph for this function:

JSBool js_ValueToUint16 ( JSContext cx,
jsval  v,
uint16 ip 
)

Definition at line 867 of file jsnum.c.

{
    jsdouble d;
    jsuint i, m;
    JSBool neg;

    if (!js_ValueToNumber(cx, v, &d))
        return JS_FALSE;
    if (d == 0 || !JSDOUBLE_IS_FINITE(d)) {
        *ip = 0;
        return JS_TRUE;
    }
    i = (jsuint)d;
    if ((jsdouble)i == d) {
        *ip = (uint16)i;
        return JS_TRUE;
    }
    neg = (d < 0);
    d = floor(neg ? -d : d);
    d = neg ? -d : d;
    m = JS_BIT(16);
    d = fmod(d, (double)m);
    if (d < 0)
        d += m;
    *ip = (uint16) d;
    return JS_TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 149 of file jsnum.c.

Definition at line 152 of file jsnum.c.

Definition at line 151 of file jsnum.c.

const char js_NaN_str[]

Definition at line 150 of file jsnum.c.

Definition at line 164 of file jsnum.c.

Definition at line 153 of file jsnum.c.

Definition at line 154 of file jsnum.c.