The Tor Browser: js/src/jsnum.h@a63d609f5ebe (annotated)

js/src/jsnum.h@a63d609f5ebe (annotated)

js/src/jsnum.h

Thu, 15 Jan 2015 15:55:04 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 15:55:04 +0100
branch: TOR_BUG_9701
changeset 9: a63d609f5ebe
permissions: -rw-r--r--

Back out 97036ab72558 which inappropriately compared turds to third parties.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #ifndef jsnum_h
 #define jsnum_h
 #include "mozilla/FloatingPoint.h"
 #include "NamespaceImports.h"
 #include "vm/NumericConversions.h"
 namespace js {
 class StringBuffer;
 extern bool
 InitRuntimeNumberState(JSRuntime *rt);
 #if !EXPOSE_INTL_API
 extern void
 FinishRuntimeNumberState(JSRuntime *rt);
 #endif
 } /* namespace js */
 /* Initialize the Number class, returning its prototype object. */
 extern JSObject *
 js_InitNumberClass(JSContext *cx, js::HandleObject obj);
 /*
  * String constants for global function names, used in jsapi.c and jsnum.c.
  */
 extern const char js_isNaN_str[];
 extern const char js_isFinite_str[];
 extern const char js_parseFloat_str[];
 extern const char js_parseInt_str[];
 class JSAtom;
 namespace js {
 /*
  * When base == 10, this function implements ToString() as specified by
  * ECMA-262-5 section 9.8.1; but note that it handles integers specially for
  * performance.  See also js::NumberToCString().
  */
 template <js::AllowGC allowGC>
 extern JSString *
 NumberToString(js::ThreadSafeContext *cx, double d);
 extern JSAtom *
 NumberToAtom(js::ExclusiveContext *cx, double d);
 template <AllowGC allowGC>
 extern JSFlatString *
 Int32ToString(ThreadSafeContext *cx, int32_t i);
 extern JSAtom *
 Int32ToAtom(ExclusiveContext *cx, int32_t si);
 /*
  * Convert an integer or double (contained in the given value) to a string and
  * append to the given buffer.
  */
 extern bool JS_FASTCALL
 NumberValueToStringBuffer(JSContext *cx, const Value &v, StringBuffer &sb);
 /* Same as js_NumberToString, different signature. */
 extern JSFlatString *
 NumberToString(JSContext *cx, double d);
 extern JSFlatString *
 IndexToString(JSContext *cx, uint32_t index);
 /*
  * Usually a small amount of static storage is enough, but sometimes we need
  * to dynamically allocate much more.  This struct encapsulates that.
  * Dynamically allocated memory will be freed when the object is destroyed.
  */
 struct ToCStringBuf
 {
     /*
      * The longest possible result that would need to fit in sbuf is
      * (-0x80000000).toString(2), which has length 33.  Longer cases are
      * possible, but they'll go in dbuf.
      */
     static const size_t sbufSize = 34;
     char sbuf[sbufSize];
     char *dbuf;
     ToCStringBuf();
     ~ToCStringBuf();
 };
 /*
  * Convert a number to a C string.  When base==10, this function implements
  * ToString() as specified by ECMA-262-5 section 9.8.1.  It handles integral
  * values cheaply.  Return nullptr if we ran out of memory.  See also
  * js_NumberToCString().
  */
 extern char *
 NumberToCString(JSContext *cx, ToCStringBuf *cbuf, double d, int base = 10);
 /*
  * The largest positive integer such that all positive integers less than it
  * may be precisely represented using the IEEE-754 double-precision format.
  */
 const double DOUBLE_INTEGRAL_PRECISION_LIMIT = uint64_t(1) << 53;
 /*
  * Parse a decimal number encoded in |chars|.  The decimal number must be
  * sufficiently small that it will not overflow the integrally-precise range of
  * the double type -- that is, the number will be smaller than
  * DOUBLE_INTEGRAL_PRECISION_LIMIT
  */
 extern double
 ParseDecimalNumber(const JS::TwoByteChars chars);
 /*
  * Compute the positive integer of the given base described immediately at the
  * start of the range [start, end) -- no whitespace-skipping, no magical
  * leading-"0" octal or leading-"0x" hex behavior, no "+"/"-" parsing, just
  * reading the digits of the integer.  Return the index one past the end of the
  * digits of the integer in *endp, and return the integer itself in *dp.  If
  * base is 10 or a power of two the returned integer is the closest possible
  * double; otherwise extremely large integers may be slightly inaccurate.
  *
  * If [start, end) does not begin with a number with the specified base,
  * *dp == 0 and *endp == start upon return.
  */
 extern bool
 GetPrefixInteger(ThreadSafeContext *cx, const jschar *start, const jschar *end, int base,
                  const jschar **endp, double *dp);
 /*
  * This is like GetPrefixInteger, but only deals with base 10, and doesn't have
  * and |endp| outparam.  It should only be used when the jschars are known to
  * only contain digits.
  */
 extern bool
 GetDecimalInteger(ExclusiveContext *cx, const jschar *start, const jschar *end, double *dp);
 extern bool
 StringToNumber(ThreadSafeContext *cx, JSString *str, double *result);
 /* ES5 9.3 ToNumber, overwriting *vp with the appropriate number value. */
 MOZ_ALWAYS_INLINE bool
 ToNumber(JSContext *cx, JS::MutableHandleValue vp)
 {
     if (vp.isNumber())
         return true;
     double d;
     extern JS_PUBLIC_API(bool) ToNumberSlow(JSContext *cx, Value v, double *dp);
     if (!ToNumberSlow(cx, vp, &d))
         return false;
     vp.setNumber(d);
     return true;
 }
 bool
 num_parseInt(JSContext *cx, unsigned argc, Value *vp);
 }  /* namespace js */
 /*
  * Similar to strtod except that it replaces overflows with infinities of the
  * correct sign, and underflows with zeros of the correct sign.  Guaranteed to
  * return the closest double number to the given input in dp.
  *
  * Also allows inputs of the form [+|-]Infinity, which produce an infinity of
  * the appropriate sign.  The case of the "Infinity" string must match exactly.
  * If the string does not contain a number, set *ep to s and return 0.0 in dp.
  * Return false if out of memory.
  */
 extern bool
 js_strtod(js::ThreadSafeContext *cx, const jschar *s, const jschar *send,
           const jschar **ep, double *dp);
 extern bool
 js_num_toString(JSContext *cx, unsigned argc, js::Value *vp);
 extern bool
 js_num_valueOf(JSContext *cx, unsigned argc, js::Value *vp);
 namespace js {
 static MOZ_ALWAYS_INLINE bool
 ValueFitsInInt32(const Value &v, int32_t *pi)
 {
     if (v.isInt32()) {
         *pi = v.toInt32();
         return true;
     }
     return v.isDouble() && mozilla::NumberIsInt32(v.toDouble(), pi);
 }
 /*
  * Returns true if the given value is definitely an index: that is, the value
  * is a number that's an unsigned 32-bit integer.
  *
  * This method prioritizes common-case speed over accuracy in every case.  It
  * can produce false negatives (but not false positives): some values which are
  * indexes will be reported not to be indexes by this method.  Users must
  * consider this possibility when using this method.
  */
 static MOZ_ALWAYS_INLINE bool
 IsDefinitelyIndex(const Value &v, uint32_t *indexp)
 {
     if (v.isInt32() && v.toInt32() >= 0) {
         *indexp = v.toInt32();
         return true;
     }
     int32_t i;
     if (v.isDouble() && mozilla::NumberIsInt32(v.toDouble(), &i) && i >= 0) {
         *indexp = uint32_t(i);
         return true;
     }
     return false;
 }
 /* ES5 9.4 ToInteger. */
 static inline bool
 ToInteger(JSContext *cx, HandleValue v, double *dp)
 {
     if (v.isInt32()) {
         *dp = v.toInt32();
         return true;
     }
     if (v.isDouble()) {
         *dp = v.toDouble();
     } else {
         extern JS_PUBLIC_API(bool) ToNumberSlow(JSContext *cx, Value v, double *dp);
         if (!ToNumberSlow(cx, v, dp))
             return false;
     }
     *dp = ToInteger(*dp);
     return true;
 }
 inline bool
 SafeAdd(int32_t one, int32_t two, int32_t *res)
 {
     // Use unsigned for the 32-bit operation since signed overflow gets
     // undefined behavior.
     *res = uint32_t(one) + uint32_t(two);
     int64_t ores = (int64_t)one + (int64_t)two;
     return ores == (int64_t)*res;
 }
 inline bool
 SafeSub(int32_t one, int32_t two, int32_t *res)
 {
     *res = uint32_t(one) - uint32_t(two);
     int64_t ores = (int64_t)one - (int64_t)two;
     return ores == (int64_t)*res;
 }
 inline bool
 SafeMul(int32_t one, int32_t two, int32_t *res)
 {
     *res = uint32_t(one) * uint32_t(two);
     int64_t ores = (int64_t)one * (int64_t)two;
     return ores == (int64_t)*res;
 }
 extern bool
 ToNumberSlow(ExclusiveContext *cx, Value v, double *dp);
 // Variant of ToNumber which takes an ExclusiveContext instead of a JSContext.
 // ToNumber is part of the API and can't use ExclusiveContext directly.
 MOZ_ALWAYS_INLINE bool
 ToNumber(ExclusiveContext *cx, const Value &v, double *out)
 {
     if (v.isNumber()) {
         *out = v.toNumber();
         return true;
     }
     return ToNumberSlow(cx, v, out);
 }
 /*
  * Thread safe variants of number conversion functions.
  */
 bool
 NonObjectToNumberSlow(ThreadSafeContext *cx, Value v, double *out);
 inline bool
 NonObjectToNumber(ThreadSafeContext *cx, const Value &v, double *out)
 {
     if (v.isNumber()) {
         *out = v.toNumber();
         return true;
     }
     return NonObjectToNumberSlow(cx, v, out);
 }
 bool
 NonObjectToInt32Slow(ThreadSafeContext *cx, const Value &v, int32_t *out);
 inline bool
 NonObjectToInt32(ThreadSafeContext *cx, const Value &v, int32_t *out)
 {
     if (v.isInt32()) {
         *out = v.toInt32();
         return true;
     }
     return NonObjectToInt32Slow(cx, v, out);
 }
 bool
 NonObjectToUint32Slow(ThreadSafeContext *cx, const Value &v, uint32_t *out);
 MOZ_ALWAYS_INLINE bool
 NonObjectToUint32(ThreadSafeContext *cx, const Value &v, uint32_t *out)
 {
     if (v.isInt32()) {
         *out = uint32_t(v.toInt32());
         return true;
     }
     return NonObjectToUint32Slow(cx, v, out);
 }
 } /* namespace js */
 #endif /* jsnum_h */

The Tor Browser / annotate

js/src/jsnum.h@a63d609f5ebe (annotated)

js/src/jsnum.h