Add m-esr52 at 52.6.0

1 files changed, 495 insertions, 0 deletions

diff --git a/js/src/jsstr.h b/js/src/jsstr.h
new file mode 100644
index 000000000..3b92aa21b
--- /dev/null
+++ b/js/src/jsstr.h
@@ -0,0 +1,495 @@
+/* -*- 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 jsstr_h
+#define jsstr_h
+
+#include "mozilla/HashFunctions.h"
+#include "mozilla/PodOperations.h"
+
+#include <stdio.h>
+
+#include "jsutil.h"
+#include "NamespaceImports.h"
+
+#include "gc/Rooting.h"
+#include "js/RootingAPI.h"
+#include "js/UniquePtr.h"
+#include "vm/Printer.h"
+#include "vm/Unicode.h"
+
+class JSAutoByteString;
+class JSLinearString;
+
+namespace js {
+
+class StringBuffer;
+
+template <AllowGC allowGC>
+extern JSString*
+ConcatStrings(ExclusiveContext* cx,
+              typename MaybeRooted<JSString*, allowGC>::HandleType left,
+              typename MaybeRooted<JSString*, allowGC>::HandleType right);
+
+// Return s advanced past any Unicode white space characters.
+template <typename CharT>
+static inline const CharT*
+SkipSpace(const CharT* s, const CharT* end)
+{
+    MOZ_ASSERT(s <= end);
+
+    while (s < end && unicode::IsSpace(*s))
+        s++;
+
+    return s;
+}
+
+// Return less than, equal to, or greater than zero depending on whether
+// s1 is less than, equal to, or greater than s2.
+template <typename Char1, typename Char2>
+inline int32_t
+CompareChars(const Char1* s1, size_t len1, const Char2* s2, size_t len2)
+{
+    size_t n = Min(len1, len2);
+    for (size_t i = 0; i < n; i++) {
+        if (int32_t cmp = s1[i] - s2[i])
+            return cmp;
+    }
+
+    return int32_t(len1 - len2);
+}
+
+extern int32_t
+CompareChars(const char16_t* s1, size_t len1, JSLinearString* s2);
+
+}  /* namespace js */
+
+struct JSSubString {
+    JSLinearString* base;
+    size_t          offset;
+    size_t          length;
+
+    JSSubString() { mozilla::PodZero(this); }
+
+    void initEmpty(JSLinearString* base) {
+        this->base = base;
+        offset = length = 0;
+    }
+    void init(JSLinearString* base, size_t offset, size_t length) {
+        this->base = base;
+        this->offset = offset;
+        this->length = length;
+    }
+};
+
+/*
+ * Shorthands for ASCII (7-bit) decimal and hex conversion.
+ * Manually inline isdigit for performance; MSVC doesn't do this for us.
+ */
+#define JS7_ISDEC(c)    ((((unsigned)(c)) - '0') <= 9)
+#define JS7_UNDEC(c)    ((c) - '0')
+#define JS7_ISOCT(c)    ((((unsigned)(c)) - '0') <= 7)
+#define JS7_UNOCT(c)    (JS7_UNDEC(c))
+#define JS7_ISHEX(c)    ((c) < 128 && isxdigit(c))
+#define JS7_UNHEX(c)    (unsigned)(JS7_ISDEC(c) ? (c) - '0' : 10 + tolower(c) - 'a')
+#define JS7_ISLET(c)    ((c) < 128 && isalpha(c))
+
+extern size_t
+js_strlen(const char16_t* s);
+
+extern int32_t
+js_strcmp(const char16_t* lhs, const char16_t* rhs);
+
+template <typename CharT>
+extern const CharT*
+js_strchr_limit(const CharT* s, char16_t c, const CharT* limit);
+
+static MOZ_ALWAYS_INLINE void
+js_strncpy(char16_t* dst, const char16_t* src, size_t nelem)
+{
+    return mozilla::PodCopy(dst, src, nelem);
+}
+
+extern int32_t
+js_fputs(const char16_t* s, FILE* f);
+
+namespace js {
+
+/* Initialize the String class, returning its prototype object. */
+extern JSObject*
+InitStringClass(JSContext* cx, HandleObject obj);
+
+/*
+ * Convert a value to a printable C string.
+ */
+extern const char*
+ValueToPrintable(JSContext* cx, const Value&, JSAutoByteString* bytes, bool asSource = false);
+
+extern UniqueChars
+DuplicateString(ExclusiveContext* cx, const char* s);
+
+extern UniqueTwoByteChars
+DuplicateString(ExclusiveContext* cx, const char16_t* s);
+
+/*
+ * These variants do not report OOMs, you must arrange for OOMs to be reported
+ * yourself.
+ */
+extern UniqueChars
+DuplicateString(const char* s);
+
+extern UniqueChars
+DuplicateString(const char* s, size_t n);
+
+extern UniqueTwoByteChars
+DuplicateString(const char16_t* s);
+
+extern UniqueTwoByteChars
+DuplicateString(const char16_t* s, size_t n);
+
+/*
+ * Convert a non-string value to a string, returning null after reporting an
+ * error, otherwise returning a new string reference.
+ */
+template <AllowGC allowGC>
+extern JSString*
+ToStringSlow(ExclusiveContext* cx, typename MaybeRooted<Value, allowGC>::HandleType arg);
+
+/*
+ * Convert the given value to a string.  This method includes an inline
+ * fast-path for the case where the value is already a string; if the value is
+ * known not to be a string, use ToStringSlow instead.
+ */
+template <AllowGC allowGC>
+static MOZ_ALWAYS_INLINE JSString*
+ToString(JSContext* cx, JS::HandleValue v)
+{
+    if (v.isString())
+        return v.toString();
+    return ToStringSlow<allowGC>(cx, v);
+}
+
+/*
+ * This function implements E-262-3 section 9.8, toString. Convert the given
+ * value to a string of characters appended to the given buffer. On error, the
+ * passed buffer may have partial results appended.
+ */
+inline bool
+ValueToStringBuffer(JSContext* cx, const Value& v, StringBuffer& sb);
+
+/*
+ * Convert a value to its source expression, returning null after reporting
+ * an error, otherwise returning a new string reference.
+ */
+extern JSString*
+ValueToSource(JSContext* cx, HandleValue v);
+
+/*
+ * Convert a JSString to its source expression; returns null after reporting an
+ * error, otherwise returns a new string reference. No Handle needed since the
+ * input is dead after the GC.
+ */
+extern JSString*
+StringToSource(JSContext* cx, JSString* str);
+
+/*
+ * Test if strings are equal. The caller can call the function even if str1
+ * or str2 are not GC-allocated things.
+ */
+extern bool
+EqualStrings(JSContext* cx, JSString* str1, JSString* str2, bool* result);
+
+/* Use the infallible method instead! */
+extern bool
+EqualStrings(JSContext* cx, JSLinearString* str1, JSLinearString* str2, bool* result) = delete;
+
+/* EqualStrings is infallible on linear strings. */
+extern bool
+EqualStrings(JSLinearString* str1, JSLinearString* str2);
+
+extern bool
+EqualChars(JSLinearString* str1, JSLinearString* str2);
+
+/*
+ * Return less than, equal to, or greater than zero depending on whether
+ * str1 is less than, equal to, or greater than str2.
+ */
+extern bool
+CompareStrings(JSContext* cx, JSString* str1, JSString* str2, int32_t* result);
+
+/*
+ * Same as CompareStrings but for atoms.  Don't use this to just test
+ * for equality; use this when you need an ordering on atoms.
+ */
+extern int32_t
+CompareAtoms(JSAtom* atom1, JSAtom* atom2);
+
+/*
+ * Return true if the string matches the given sequence of ASCII bytes.
+ */
+extern bool
+StringEqualsAscii(JSLinearString* str, const char* asciiBytes);
+
+/* Return true if the string contains a pattern anywhere inside it. */
+extern bool
+StringHasPattern(JSLinearString* text, const char16_t* pat, uint32_t patlen);
+
+extern int
+StringFindPattern(JSLinearString* text, JSLinearString* pat, size_t start);
+
+/* Return true if the string contains a pattern at |start|. */
+extern bool
+HasSubstringAt(JSLinearString* text, JSLinearString* pat, size_t start);
+
+template <typename Char1, typename Char2>
+inline bool
+EqualChars(const Char1* s1, const Char2* s2, size_t len);
+
+template <typename Char1>
+inline bool
+EqualChars(const Char1* s1, const Char1* s2, size_t len)
+{
+    return mozilla::PodEqual(s1, s2, len);
+}
+
+template <typename Char1, typename Char2>
+inline bool
+EqualChars(const Char1* s1, const Char2* s2, size_t len)
+{
+    for (const Char1* s1end = s1 + len; s1 < s1end; s1++, s2++) {
+        if (*s1 != *s2)
+            return false;
+    }
+    return true;
+}
+
+/*
+ * Computes |str|'s substring for the range [beginInt, beginInt + lengthInt).
+ * Negative, overlarge, swapped, etc. |beginInt| and |lengthInt| are forbidden
+ * and constitute API misuse.
+ */
+JSString*
+SubstringKernel(JSContext* cx, HandleString str, int32_t beginInt, int32_t lengthInt);
+
+/*
+ * Inflate bytes in ASCII encoding to char16_t code units. Return null on error,
+ * otherwise return the char16_t buffer that was malloc'ed. length is updated to
+ * the length of the new string (in char16_t code units). A null char is
+ * appended, but it is not included in the length.
+ */
+extern char16_t*
+InflateString(ExclusiveContext* cx, const char* bytes, size_t* length);
+
+/*
+ * Inflate bytes to JS chars in an existing buffer. 'dst' must be large
+ * enough for 'srclen' char16_t code units. The buffer is NOT null-terminated.
+ */
+inline void
+CopyAndInflateChars(char16_t* dst, const char* src, size_t srclen)
+{
+    for (size_t i = 0; i < srclen; i++)
+        dst[i] = (unsigned char) src[i];
+}
+
+inline void
+CopyAndInflateChars(char16_t* dst, const JS::Latin1Char* src, size_t srclen)
+{
+    for (size_t i = 0; i < srclen; i++)
+        dst[i] = src[i];
+}
+
+/*
+ * Deflate JS chars to bytes into a buffer. 'bytes' must be large enough for
+ * 'length chars. The buffer is NOT null-terminated. The destination length
+ * must to be initialized with the buffer size and will contain on return the
+ * number of copied bytes.
+ */
+template <typename CharT>
+extern bool
+DeflateStringToBuffer(JSContext* maybecx, const CharT* chars,
+                      size_t charsLength, char* bytes, size_t* length);
+
+extern bool
+str_fromCharCode(JSContext* cx, unsigned argc, Value* vp);
+
+extern bool
+str_fromCharCode_one_arg(JSContext* cx, HandleValue code, MutableHandleValue rval);
+
+extern bool
+str_fromCodePoint(JSContext* cx, unsigned argc, Value* vp);
+
+extern bool
+str_fromCodePoint_one_arg(JSContext* cx, HandleValue code, MutableHandleValue rval);
+
+/* String methods exposed so they can be installed in the self-hosting global. */
+
+extern bool
+str_includes(JSContext* cx, unsigned argc, Value* vp);
+
+extern bool
+str_indexOf(JSContext* cx, unsigned argc, Value* vp);
+
+extern bool
+str_lastIndexOf(JSContext* cx, unsigned argc, Value* vp);
+
+extern bool
+str_startsWith(JSContext* cx, unsigned argc, Value* vp);
+
+extern bool
+str_toLowerCase(JSContext* cx, unsigned argc, Value* vp);
+
+extern bool
+str_toUpperCase(JSContext* cx, unsigned argc, Value* vp);
+
+extern bool
+str_toString(JSContext* cx, unsigned argc, Value* vp);
+
+extern bool
+str_charAt(JSContext* cx, unsigned argc, Value* vp);
+
+extern bool
+str_charCodeAt_impl(JSContext* cx, HandleString string, HandleValue index, MutableHandleValue res);
+
+extern bool
+str_charCodeAt(JSContext* cx, unsigned argc, Value* vp);
+
+extern bool
+str_contains(JSContext *cx, unsigned argc, Value *vp);
+
+extern bool
+str_endsWith(JSContext* cx, unsigned argc, Value* vp);
+
+extern bool
+str_trim(JSContext* cx, unsigned argc, Value* vp);
+
+extern bool
+str_trimLeft(JSContext* cx, unsigned argc, Value* vp);
+
+extern bool
+str_trimRight(JSContext* cx, unsigned argc, Value* vp);
+
+extern bool
+str_toLocaleLowerCase(JSContext* cx, unsigned argc, Value* vp);
+
+extern bool
+str_toLocaleUpperCase(JSContext* cx, unsigned argc, Value* vp);
+
+#if !EXPOSE_INTL_API
+extern bool
+str_localeCompare(JSContext* cx, unsigned argc, Value* vp);
+#else
+extern bool
+str_normalize(JSContext* cx, unsigned argc, Value* vp);
+#endif
+
+extern bool
+str_concat(JSContext* cx, unsigned argc, Value* vp);
+
+/*
+ * Convert one UCS-4 char and write it into a UTF-8 buffer, which must be at
+ * least 4 bytes long.  Return the number of UTF-8 bytes of data written.
+ */
+extern uint32_t
+OneUcs4ToUtf8Char(uint8_t* utf8Buffer, uint32_t ucs4Char);
+
+extern size_t
+PutEscapedStringImpl(char* buffer, size_t size, GenericPrinter* out, JSLinearString* str,
+                     uint32_t quote);
+
+template <typename CharT>
+extern size_t
+PutEscapedStringImpl(char* buffer, size_t bufferSize, GenericPrinter* out, const CharT* chars,
+                     size_t length, uint32_t quote);
+
+/*
+ * Write str into buffer escaping any non-printable or non-ASCII character
+ * using \escapes for JS string literals.
+ * Guarantees that a NUL is at the end of the buffer unless size is 0. Returns
+ * the length of the written output, NOT including the NUL. Thus, a return
+ * value of size or more means that the output was truncated. If buffer
+ * is null, just returns the length of the output. If quote is not 0, it must
+ * be a single or double quote character that will quote the output.
+*/
+inline size_t
+PutEscapedString(char* buffer, size_t size, JSLinearString* str, uint32_t quote)
+{
+    size_t n = PutEscapedStringImpl(buffer, size, nullptr, str, quote);
+
+    /* PutEscapedStringImpl can only fail with a file. */
+    MOZ_ASSERT(n != size_t(-1));
+    return n;
+}
+
+template <typename CharT>
+inline size_t
+PutEscapedString(char* buffer, size_t bufferSize, const CharT* chars, size_t length, uint32_t quote)
+{
+    size_t n = PutEscapedStringImpl(buffer, bufferSize, nullptr, chars, length, quote);
+
+    /* PutEscapedStringImpl can only fail with a file. */
+    MOZ_ASSERT(n != size_t(-1));
+    return n;
+}
+
+inline bool
+EscapedStringPrinter(GenericPrinter& out, JSLinearString* str, uint32_t quote)
+{
+    return PutEscapedStringImpl(nullptr, 0, &out, str, quote) != size_t(-1);
+}
+
+inline bool
+EscapedStringPrinter(GenericPrinter& out, const char* chars, size_t length, uint32_t quote)
+{
+    return PutEscapedStringImpl(nullptr, 0, &out, chars, length, quote) != size_t(-1);
+}
+
+/*
+ * Write str into file escaping any non-printable or non-ASCII character.
+ * If quote is not 0, it must be a single or double quote character that
+ * will quote the output.
+*/
+inline bool
+FileEscapedString(FILE* fp, JSLinearString* str, uint32_t quote)
+{
+    Fprinter out(fp);
+    bool res = EscapedStringPrinter(out, str, quote);
+    out.finish();
+    return res;
+}
+
+inline bool
+FileEscapedString(FILE* fp, const char* chars, size_t length, uint32_t quote)
+{
+    Fprinter out(fp);
+    bool res = EscapedStringPrinter(out, chars, length, quote);
+    out.finish();
+    return res;
+}
+
+JSObject*
+str_split_string(JSContext* cx, HandleObjectGroup group, HandleString str, HandleString sep,
+                 uint32_t limit);
+
+JSString *
+str_flat_replace_string(JSContext *cx, HandleString string, HandleString pattern,
+                        HandleString replacement);
+
+JSString*
+str_replace_string_raw(JSContext* cx, HandleString string, HandleString pattern,
+                       HandleString replacement);
+
+extern bool
+StringConstructor(JSContext* cx, unsigned argc, Value* vp);
+
+extern bool
+FlatStringMatch(JSContext* cx, unsigned argc, Value* vp);
+
+extern bool
+FlatStringSearch(JSContext* cx, unsigned argc, Value* vp);
+
+} /* namespace js */
+
+#endif /* jsstr_h */