/* -*- 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 util_Text_h

#define util_Text_h

#include "mozilla/Assertions.h"

#include "mozilla/Attributes.h"

#include <ctype.h>

#include <stddef.h>

#include <stdint.h>

#include <stdio.h>

#include <string>

#include "jsutil.h"

#include "NamespaceImports.h"

#include "js/Utility.h"

#include "util/Unicode.h"

#include "vm/Printer.h"

class JSLinearString;

/*

 * Shorthands for ASCII (7-bit) decimal and hex conversion.

 * Manually inline isdigit and isxdigit for performance; MSVC doesn't do this

 * for us.

 */

#define JS7_ISDEC(c) ((((unsigned)(c)) - '0') <= 9)

#define JS7_ISA2F(c) \

  ((((((unsigned)(c)) - 'a') <= 5) || (((unsigned)(c)) - 'A') <= 5))

#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 && (JS7_ISDEC(c) || JS7_ISA2F(c)))

#define JS7_UNHEX(c) \

  (unsigned)(JS7_ISDEC(c) ? (c) - '0' : 10 + tolower(c) - 'a')

static MOZ_ALWAYS_INLINE size_t js_strlen(const char16_t* s) {

  return std::char_traits<char16_t>::length(s);

}

template <typename CharT>

extern const CharT* js_strchr_limit(const CharT* s, char16_t c,

                                    const CharT* limit);

extern int32_t js_fputs(const char16_t* s, FILE* f);

namespace js {

class StringBuffer;

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;

}

// 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);

}

// 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;

}

extern UniqueChars DuplicateString(JSContext* cx, const char* s);

extern UniqueTwoByteChars DuplicateString(JSContext* 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);

/*

 * Inflate bytes in ASCII encoding to char16_t code units. Return null on error,

 * otherwise return the char16_t buffer that was malloc'ed. A null char is

 * appended.

 */

extern char16_t* InflateString(JSContext* 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);

/*

 * 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;

}

bool EncodeURI(JSContext* cx, StringBuffer& sb, const char* chars,

               size_t length);

}  // namespace js

#endif  // util_Text_h