Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 394 insertions, 0 deletions

diff --git a/js/src/jsnum.h b/js/src/jsnum.h
new file mode 100644
index 0000000000..095bec08a7
--- /dev/null
+++ b/js/src/jsnum.h
@@ -0,0 +1,394 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: set ts=8 sts=2 et sw=2 tw=80:
+ * 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 "mozilla/Range.h"
+#include "mozilla/Utf8.h"
+
+#include <limits>
+
+#include "NamespaceImports.h"
+
+#include "js/Conversions.h"
+#include "js/friend/ErrorMessages.h"  // JSMSG_*
+
+#include "vm/StringType.h"
+
+namespace js {
+
+namespace frontend {
+class ParserAtomsTable;
+class TaggedParserAtomIndex;
+}  // namespace frontend
+
+class GlobalObject;
+class StringBuffer;
+
+[[nodiscard]] extern bool InitRuntimeNumberState(JSRuntime* rt);
+
+// This is a no-op if built with JS_HAS_INTL_API.
+extern void FinishRuntimeNumberState(JSRuntime* rt);
+
+/*
+ * 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 <AllowGC allowGC>
+extern JSString* NumberToString(JSContext* cx, double d);
+
+extern JSString* NumberToStringPure(JSContext* cx, double d);
+
+extern JSAtom* NumberToAtom(JSContext* cx, double d);
+
+frontend::TaggedParserAtomIndex NumberToParserAtom(
+    FrontendContext* fc, frontend::ParserAtomsTable& parserAtoms, double d);
+
+template <AllowGC allowGC>
+extern JSLinearString* Int32ToString(JSContext* cx, int32_t i);
+
+template <AllowGC allowGC>
+extern JSLinearString* Int32ToStringWithHeap(JSContext* cx, int32_t i,
+                                             gc::Heap heap);
+
+extern JSLinearString* Int32ToStringPure(JSContext* cx, int32_t i);
+
+extern JSString* Int32ToStringWithBase(JSContext* cx, int32_t i, int32_t base,
+                                       bool lowerCase);
+
+extern JSAtom* Int32ToAtom(JSContext* cx, int32_t si);
+
+frontend::TaggedParserAtomIndex Int32ToParserAtom(
+    FrontendContext* fc, frontend::ParserAtomsTable& parserAtoms, int32_t si);
+
+// ES6 15.7.3.12
+extern bool IsInteger(double d);
+
+/*
+ * Convert an integer or double (contained in the given value) to a string and
+ * append to the given buffer.
+ */
+[[nodiscard]] extern bool NumberValueToStringBuffer(const Value& v,
+                                                    StringBuffer& sb);
+
+extern JSLinearString* IndexToString(JSContext* cx, uint32_t index);
+
+struct ToCStringBuf {
+  char sbuf[JS::MaximumNumberToStringLength] = {};
+};
+
+struct Int32ToCStringBuf {
+  // The amount of space large enough to store the null-terminated result of
+  // |ToString| on any int32.
+  //
+  // We use the same amount for uint32 (base 10 and base 16), even though uint32
+  // only need 11 characters (base 10) resp. 9 characters (base 16) instead of
+  // 12 characters for int32 in base 10.
+  static constexpr size_t MaximumInt32ToStringLength =
+      std::numeric_limits<int32_t>::digits10 +
+      1 +  // account for the largest possible int32 value
+      1 +  // sign for negative numbers
+      1    // null character
+      ;
+
+  char sbuf[MaximumInt32ToStringLength] = {};
+};
+
+// Convert a number to a C string.  This function implements ToString() as
+// specified by ECMA-262-5 section 9.8.1.  It handles integral values cheaply.
+// Infallible: always returns a non-nullptr string.
+// The optional `length` out-param is set to the string length of the result.
+extern char* NumberToCString(ToCStringBuf* cbuf, double d,
+                             size_t* length = nullptr);
+
+extern char* Int32ToCString(Int32ToCStringBuf* cbuf, int32_t value,
+                            size_t* length = nullptr);
+
+extern char* Uint32ToCString(Int32ToCStringBuf* cbuf, uint32_t value,
+                             size_t* length = nullptr);
+
+// Like NumberToCString, but accepts only unsigned integers and uses base 16.
+// Infallible: always returns a non-nullptr string.
+// The optional `length` out-param is set to the string length of the result.
+extern char* Uint32ToHexCString(Int32ToCStringBuf* cbuf, uint32_t value,
+                                size_t* length = nullptr);
+
+/*
+ * The largest positive integer such that all positive integers less than it
+ * may be precisely represented using the IEEE-754 double-precision format.
+ */
+constexpr double DOUBLE_INTEGRAL_PRECISION_LIMIT = uint64_t(1) << 53;
+
+/*
+ * The smallest positive double such that all positive doubles larger or equal
+ * than it have an exact decimal representation without exponential form.
+ */
+constexpr double DOUBLE_DECIMAL_IN_SHORTEST_LOW = 1.0e-6;
+
+/*
+ * The largest positive double such that all positive doubles less than it
+ * have an exact decimal representation without exponential form.
+ */
+constexpr double DOUBLE_DECIMAL_IN_SHORTEST_HIGH = 1.0e21;
+
+/*
+ * 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
+ */
+template <typename CharT>
+extern double ParseDecimalNumber(const mozilla::Range<const CharT> chars);
+
+enum class IntegerSeparatorHandling : bool { None, SkipUnderscore };
+
+/*
+ * 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.
+ *
+ * The |separatorHandling| controls whether or not numeric separators can be
+ * part of integer string. If the option is enabled, all '_' characters in the
+ * string are ignored. Underscore characters must not appear directly next to
+ * each other, e.g. '1__2' will lead to an assertion.
+ *
+ * If [start, end) does not begin with a number with the specified base,
+ * *dp == 0 and *endp == start upon return.
+ */
+template <typename CharT>
+[[nodiscard]] extern bool GetPrefixInteger(
+    const CharT* start, const CharT* end, int base,
+    IntegerSeparatorHandling separatorHandling, const CharT** endp, double* dp);
+
+inline const char16_t* ToRawChars(const char16_t* units) { return units; }
+
+inline const unsigned char* ToRawChars(const unsigned char* units) {
+  return units;
+}
+
+inline const unsigned char* ToRawChars(const mozilla::Utf8Unit* units) {
+  return mozilla::Utf8AsUnsignedChars(units);
+}
+
+/**
+ * Like GetPrefixInteger, but [start, end) must all be digits in the given
+ * base (and so this function doesn't take a useless outparam).
+ */
+template <typename CharT>
+[[nodiscard]] extern bool GetFullInteger(
+    const CharT* start, const CharT* end, int base,
+    IntegerSeparatorHandling separatorHandling, double* dp) {
+  decltype(ToRawChars(start)) realEnd;
+  if (GetPrefixInteger(ToRawChars(start), ToRawChars(end), base,
+                       separatorHandling, &realEnd, dp)) {
+    MOZ_ASSERT(end == static_cast<const void*>(realEnd));
+    return true;
+  }
+  return false;
+}
+
+/*
+ * This is like GetPrefixInteger, but only deals with base 10, always ignores
+ * '_', and doesn't have an |endp| outparam. It should only be used when the
+ * characters are known to match |DecimalIntegerLiteral|, cf. ES2020, 11.8.3
+ * Numeric Literals.
+ */
+template <typename CharT>
+[[nodiscard]] extern bool GetDecimalInteger(const CharT* start,
+                                            const CharT* end, double* dp);
+
+/*
+ * This is like GetDecimalInteger, but also allows non-integer numbers. It
+ * should only be used when the characters are known to match |DecimalLiteral|,
+ * cf. ES2020, 11.8.3 Numeric Literals.
+ */
+template <typename CharT>
+[[nodiscard]] extern bool GetDecimal(const CharT* start, const CharT* end,
+                                     double* dp);
+
+template <typename CharT>
+double CharsToNumber(const CharT* chars, size_t length);
+
+[[nodiscard]] extern bool StringToNumber(JSContext* cx, JSString* str,
+                                         double* result);
+
+[[nodiscard]] extern bool StringToNumberPure(JSContext* cx, JSString* str,
+                                             double* result);
+
+// Infallible version of StringToNumber for linear strings.
+extern double LinearStringToNumber(JSLinearString* str);
+
+// Parse the input string as if Number.parseInt had been called.
+extern bool NumberParseInt(JSContext* cx, JS::HandleString str, int32_t radix,
+                           JS::MutableHandleValue result);
+
+/* ES5 9.3 ToNumber, overwriting *vp with the appropriate number value. */
+[[nodiscard]] 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, HandleValue v,
+                                         double* dp);
+  if (!ToNumberSlow(cx, vp, &d)) {
+    return false;
+  }
+
+  vp.setNumber(d);
+  return true;
+}
+
+bool ToNumericSlow(JSContext* cx, JS::MutableHandleValue vp);
+
+// BigInt proposal section 3.1.6
+[[nodiscard]] MOZ_ALWAYS_INLINE bool ToNumeric(JSContext* cx,
+                                               JS::MutableHandleValue vp) {
+  if (vp.isNumeric()) {
+    return true;
+  }
+  return ToNumericSlow(cx, vp);
+}
+
+bool ToInt32OrBigIntSlow(JSContext* cx, JS::MutableHandleValue vp);
+
+[[nodiscard]] MOZ_ALWAYS_INLINE bool ToInt32OrBigInt(
+    JSContext* cx, JS::MutableHandleValue vp) {
+  if (vp.isInt32()) {
+    return true;
+  }
+  return ToInt32OrBigIntSlow(cx, 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.
+ *
+ * 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 *dEnd to begin and return 0.0.
+ */
+template <typename CharT>
+[[nodiscard]] extern double js_strtod(const CharT* begin, const CharT* end,
+                                      const CharT** dEnd);
+
+namespace js {
+
+/**
+ * Like js_strtod, but for when the number always constitutes the entire range
+ * (and so |dEnd| would be a value already known).
+ */
+template <typename CharT>
+[[nodiscard]] extern double FullStringToDouble(const CharT* begin,
+                                               const CharT* end) {
+  decltype(ToRawChars(begin)) realEnd;
+  double d = js_strtod(ToRawChars(begin), ToRawChars(end), &realEnd);
+  MOZ_ASSERT(end == static_cast<const void*>(realEnd));
+  return d;
+}
+
+[[nodiscard]] extern bool ThisNumberValueForToLocaleString(JSContext* cx,
+                                                           unsigned argc,
+                                                           Value* vp);
+
+[[nodiscard]] extern bool num_valueOf(JSContext* cx, unsigned argc, Value* vp);
+
+/*
+ * 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::NumberEqualsInt32(v.toDouble(), &i) && i >= 0) {
+    *indexp = uint32_t(i);
+    return true;
+  }
+
+  if (v.isString() && v.toString()->hasIndexValue()) {
+    *indexp = v.toString()->getIndexValue();
+    return true;
+  }
+
+  return false;
+}
+
+// ES2020 draft rev 6b05bc56ba4e3c7a2b9922c4282d9eb844426d9b
+// 7.1.5 ToInteger ( argument )
+[[nodiscard]] 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 if (v.isString() && v.toString()->hasIndexValue()) {
+    *dp = v.toString()->getIndexValue();
+    return true;
+  } else {
+    extern JS_PUBLIC_API bool ToNumberSlow(JSContext * cx, HandleValue v,
+                                           double* dp);
+    if (!ToNumberSlow(cx, v, dp)) {
+      return false;
+    }
+  }
+  *dp = JS::ToInteger(*dp);
+  return true;
+}
+
+/* ES2017 draft 7.1.17 ToIndex
+ *
+ * Return true and set |*index| to the integer value if |v| is a valid
+ * integer index value. Otherwise report a RangeError and return false.
+ *
+ * The returned index will always be in the range 0 <= *index <= 2^53-1.
+ */
+[[nodiscard]] extern bool ToIndexSlow(JSContext* cx, JS::HandleValue v,
+                                      const unsigned errorNumber,
+                                      uint64_t* index);
+
+[[nodiscard]] static inline bool ToIndex(JSContext* cx, JS::HandleValue v,
+                                         const unsigned errorNumber,
+                                         uint64_t* index) {
+  if (v.isInt32()) {
+    int32_t i = v.toInt32();
+    if (i >= 0) {
+      *index = uint64_t(i);
+      return true;
+    }
+  }
+  return ToIndexSlow(cx, v, errorNumber, index);
+}
+
+[[nodiscard]] static inline bool ToIndex(JSContext* cx, JS::HandleValue v,
+                                         uint64_t* index) {
+  return ToIndex(cx, v, JSMSG_BAD_INDEX, index);
+}
+
+} /* namespace js */
+
+#endif /* jsnum_h */