text: // Copyright 2010 the V8 project authors. All rights reserved.
  // Redistribution and use in source and binary forms, with or without
  // modification, are permitted provided that the following conditions are
  // met:
  //
  //     * Redistributions of source code must retain the above copyright
  //       notice, this list of conditions and the following disclaimer.
  //     * Redistributions in binary form must reproduce the above
  //       copyright notice, this list of conditions and the following
  //       disclaimer in the documentation and/or other materials provided
  //       with the distribution.
  //     * Neither the name of Google Inc. nor the names of its
  //       contributors may be used to endorse or promote products derived
  //       from this software without specific prior written permission.
  //
  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
  #ifndef DOUBLE_CONVERSION_UTILS_H_
  #define DOUBLE_CONVERSION_UTILS_H_
  
  #include <cstdlib>
  #include <cstring>
  
  #include <cassert>
  
  #ifndef DOUBLE_CONVERSION_ASSERT
  #define DOUBLE_CONVERSION_ASSERT(condition)         \
      assert(condition);
  #endif
  #ifndef DOUBLE_CONVERSION_UNIMPLEMENTED
  #define DOUBLE_CONVERSION_UNIMPLEMENTED() (abort())
  #endif
  #ifndef DOUBLE_CONVERSION_NO_RETURN
  #ifdef _MSC_VER
  #define DOUBLE_CONVERSION_NO_RETURN __declspec(noreturn)
  #else
  #define DOUBLE_CONVERSION_NO_RETURN __attribute__((noreturn))
  #endif
  #endif
  #ifndef DOUBLE_CONVERSION_UNREACHABLE
  #ifdef _MSC_VER
  void DOUBLE_CONVERSION_NO_RETURN abort_noreturn();
  inline void abort_noreturn() { abort(); }
  #define DOUBLE_CONVERSION_UNREACHABLE()   (abort_noreturn())
  #else
  #define DOUBLE_CONVERSION_UNREACHABLE()   (abort())
  #endif
  #endif
  
  // Not all compilers support __has_attribute and combining a check for both
  // ifdef and __has_attribute on the same preprocessor line isn't portable.
  #ifdef __has_attribute
  #   define DOUBLE_CONVERSION_HAS_ATTRIBUTE(x) __has_attribute(x)
  #else
  #   define DOUBLE_CONVERSION_HAS_ATTRIBUTE(x) 0
  #endif
  
  #ifndef DOUBLE_CONVERSION_UNUSED
  #if DOUBLE_CONVERSION_HAS_ATTRIBUTE(unused)
  #define DOUBLE_CONVERSION_UNUSED __attribute__((unused))
  #else
  #define DOUBLE_CONVERSION_UNUSED
  #endif
  #endif
  
  #if DOUBLE_CONVERSION_HAS_ATTRIBUTE(uninitialized)
  #define DOUBLE_CONVERSION_STACK_UNINITIALIZED __attribute__((uninitialized))
  #else
  #define DOUBLE_CONVERSION_STACK_UNINITIALIZED
  #endif
  
  // Double operations detection based on target architecture.
  // Linux uses a 80bit wide floating point stack on x86. This induces double
  // rounding, which in turn leads to wrong results.
  // An easy way to test if the floating-point operations are correct is to
  // evaluate: 89255.0/1e22. If the floating-point stack is 64 bits wide then
  // the result is equal to 89255e-22.
  // The best way to test this, is to create a division-function and to compare
  // the output of the division with the expected result. (Inlining must be
  // disabled.)
  // On Linux,x86 89255e-22 != Div_double(89255.0/1e22)
  //
  // For example:
  /*
  // -- in div.c
  double Div_double(double x, double y) { return x / y; }
  
  // -- in main.c
  double Div_double(double x, double y);  // Forward declaration.
  
  int main(int argc, char** argv) {
    return Div_double(89255.0, 1e22) == 89255e-22;
  }
  */
  // Run as follows ./main || echo "correct"
  //
  // If it prints "correct" then the architecture should be here, in the "correct" section.
  #if defined(_M_X64) || defined(__x86_64__) || \
      defined(__ARMEL__) || defined(__avr32__) || defined(_M_ARM) || defined(_M_ARM64) || \
      defined(__hppa__) || defined(__ia64__) || \
      defined(__mips__) || \
      defined(__loongarch__) || \
      defined(__nios2__) || defined(__ghs) || \
      defined(__powerpc__) || defined(__ppc__) || defined(__ppc64__) || \
      defined(_POWER) || defined(_ARCH_PPC) || defined(_ARCH_PPC64) || \
      defined(__sparc__) || defined(__sparc) || defined(__s390__) || \
      defined(__SH4__) || defined(__alpha__) || \
      defined(_MIPS_ARCH_MIPS32R2) || defined(__ARMEB__) || \
      defined(__AARCH64EL__) || defined(__aarch64__) || defined(__AARCH64EB__) || \
      defined(__riscv) || defined(__e2k__) || \
      defined(__or1k__) || defined(__arc__) || \
      defined(__microblaze__) || defined(__XTENSA__) || \
      defined(__EMSCRIPTEN__) || defined(__wasm32__)
  #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
  #elif defined(__mc68000__) || \
      defined(__pnacl__) || defined(__native_client__)
  #undef DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS
  #elif defined(_M_IX86) || defined(__i386__) || defined(__i386)
  #if defined(_WIN32)
  // Windows uses a 64bit wide floating point stack.
  #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
  #else
  #undef DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS
  #endif  // _WIN32
  #else
  #error Target architecture was not detected as supported by Double-Conversion.
  #endif
  
  #if defined(_WIN32) && !defined(__MINGW32__)
  
  typedef signed char int8_t;
  typedef unsigned char uint8_t;
  typedef short int16_t;  // NOLINT
  typedef unsigned short uint16_t;  // NOLINT
  typedef int int32_t;
  typedef unsigned int uint32_t;
  typedef __int64 int64_t;
  typedef unsigned __int64 uint64_t;
  // intptr_t and friends are defined in crtdefs.h through stdio.h.
  
  #else
  
  #include <stdint.h>
  
  #endif
  
  typedef uint16_t uc16;
  
  // The following macro works on both 32 and 64-bit platforms.
  // Usage: instead of writing 0x1234567890123456
  //      write DOUBLE_CONVERSION_UINT64_2PART_C(0x12345678,90123456);
  #define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  
  
  // The expression DOUBLE_CONVERSION_ARRAY_SIZE(a) is a compile-time constant of type
  // size_t which represents the number of elements of the given
  // array. You should only use DOUBLE_CONVERSION_ARRAY_SIZE on statically allocated
  // arrays.
  #ifndef DOUBLE_CONVERSION_ARRAY_SIZE
  #define DOUBLE_CONVERSION_ARRAY_SIZE(a)                                   \
    ((sizeof(a) / sizeof(*(a))) /                         \
    static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))
  #endif
  
  // A macro to disallow the evil copy constructor and operator= functions
  // This should be used in the private: declarations for a class
  #ifndef DOUBLE_CONVERSION_DISALLOW_COPY_AND_ASSIGN
  #define DOUBLE_CONVERSION_DISALLOW_COPY_AND_ASSIGN(TypeName)      \
    TypeName(const TypeName&);                    \
    void operator=(const TypeName&)
  #endif
  
  // A macro to disallow all the implicit constructors, namely the
  // default constructor, copy constructor and operator= functions.
  //
  // This should be used in the private: declarations for a class
  // that wants to prevent anyone from instantiating it. This is
  // especially useful for classes containing only static methods.
  #ifndef DOUBLE_CONVERSION_DISALLOW_IMPLICIT_CONSTRUCTORS
  #define DOUBLE_CONVERSION_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
    TypeName();                                    \
    DOUBLE_CONVERSION_DISALLOW_COPY_AND_ASSIGN(TypeName)
  #endif
  
  namespace double_conversion {
  
    inline int StrLength (const char* string) {
      size_t length = strlen (string);
      DOUBLE_CONVERSION_ASSERT(length == static_cast<size_t>(static_cast<int>(length)));
      return static_cast<int>(length);
    }
  
  // This is a simplified version of V8's Vector class.
    template <typename T>
    class Vector {
      public:
        Vector ()
            : start_ (NULL), length_ (0) {
        }
  
        Vector (T* data, int len)
            : start_ (data), length_ (len) {
          DOUBLE_CONVERSION_ASSERT(len == 0 || (len > 0 && data != NULL));
        }
  
        // Returns a vector using the same backing storage as this one,
        // spanning from and including 'from', to but not including 'to'.
        Vector<T> SubVector (int from, int to) {
          DOUBLE_CONVERSION_ASSERT(to <= length_);
          DOUBLE_CONVERSION_ASSERT(from < to);
          DOUBLE_CONVERSION_ASSERT(0 <= from);
          return Vector<T> (start () + from, to - from);
        }
  
        // Returns the length of the vector.
        int length () const {
          return length_;
        }
  
        // Returns whether or not the vector is empty.
        bool is_empty () const {
          return length_ == 0;
        }
  
        // Returns the pointer to the start of the data in the vector.
        T* start () const {
          return start_;
        }
  
        // Access individual vector elements - checks bounds in debug mode.
        T& operator [] (int index) const {
          DOUBLE_CONVERSION_ASSERT(0 <= index && index < length_);
          return start_[index];
        }
  
        T& first () {
          return start_[0];
        }
  
        T& last () {
          return start_[length_ - 1];
        }
  
        void pop_back () {
          DOUBLE_CONVERSION_ASSERT(!is_empty ());
          --length_;
        }
  
      private:
        T* start_;
        int length_;
    };
  
  // Helper class for building result strings in a character buffer. The
  // purpose of the class is to use safe operations that checks the
  // buffer bounds on all operations in debug mode.
    class StringBuilder {
      public:
        StringBuilder (char* buffer, int buffer_size)
            : buffer_ (buffer, buffer_size), position_ (0) {
        }
  
        ~StringBuilder () {
          if (!is_finalized ())
            Finalize ();
        }
  
        int size () const {
          return buffer_.length ();
        }
  
        // Get the current position in the builder.
        int position () const {
          DOUBLE_CONVERSION_ASSERT(!is_finalized ());
          return position_;
        }
  
        // Reset the position.
        void Reset () {
          position_ = 0;
        }
  
        // Add a single character to the builder. It is not allowed to add
        // 0-characters; use the Finalize() method to terminate the string
        // instead.
        void AddCharacter (char c) {
          DOUBLE_CONVERSION_ASSERT(c != '\0');
          DOUBLE_CONVERSION_ASSERT(!is_finalized () && position_ < buffer_.length ());
          buffer_[position_++] = c;
        }
  
        // Add an entire string to the builder. Uses strlen() internally to
        // compute the length of the input string.
        void AddString (const char* s) {
          AddSubstring (s, StrLength (s));
        }
  
        // Add the first 'n' characters of the given string 's' to the
        // builder. The input string must have enough characters.
        void AddSubstring (const char* s, int n) {
          DOUBLE_CONVERSION_ASSERT(!is_finalized () && position_ + n < buffer_.length ());
          DOUBLE_CONVERSION_ASSERT(static_cast<size_t>(n) <= strlen (s));
          memmove (&buffer_[position_], s, n);
          position_ += n;
        }
  
        // Add character padding to the builder. If count is non-positive,
        // nothing is added to the builder.
        void AddPadding (char c, int count) {
          for (int i = 0; i < count; i++) {
            AddCharacter (c);
          }
        }
  
        // Finalize the string by 0-terminating it and returning the buffer.
        char* Finalize () {
          DOUBLE_CONVERSION_ASSERT(!is_finalized () && position_ < buffer_.length ());
          buffer_[position_] = '\0';
          // Make sure nobody managed to add a 0-character to the
          // buffer while building the string.
          DOUBLE_CONVERSION_ASSERT(strlen (buffer_.start ()) == static_cast<size_t>(position_));
          position_ = -1;
          DOUBLE_CONVERSION_ASSERT(is_finalized ());
          return buffer_.start ();
        }
  
      private:
        Vector<char> buffer_;
        int position_;
  
        bool is_finalized () const {
          return position_ < 0;
        }
  
        DOUBLE_CONVERSION_DISALLOW_IMPLICIT_CONSTRUCTORS(StringBuilder);
    };
  
  // The type-based aliasing rule allows the compiler to assume that pointers of
  // different types (for some definition of different) never alias each other.
  // Thus the following code does not work:
  //
  // float f = foo();
  // int fbits = *(int*)(&f);
  //
  // The compiler 'knows' that the int pointer can't refer to f since the types
  // don't match, so the compiler may cache f in a register, leaving random data
  // in fbits.  Using C++ style casts makes no difference, however a pointer to
  // char data is assumed to alias any other pointer.  This is the 'memcpy
  // exception'.
  //
  // Bit_cast uses the memcpy exception to move the bits from a variable of one
  // type of a variable of another type.  Of course the end result is likely to
  // be implementation dependent.  Most compilers (gcc-4.2 and MSVC 2005)
  // will completely optimize BitCast away.
  //
  // There is an additional use for BitCast.
  // Recent gccs will warn when they see casts that may result in breakage due to
  // the type-based aliasing rule.  If you have checked that there is no breakage
  // you can use BitCast to cast one pointer type to another.  This confuses gcc
  // enough that it can no longer see that you have cast one pointer type to
  // another thus avoiding the warning.
    template <class Dest, class Source>
    Dest BitCast (const Source& source) {
      // Compile time assertion: sizeof(Dest) == sizeof(Source)
      // A compile error here means your Dest and Source have different sizes.
  #if __cplusplus >= 201103L
      static_assert (sizeof (Dest) == sizeof (Source),
                     "source and destination size mismatch");
  #else
      DOUBLE_CONVERSION_UNUSED
      typedef char VerifySizesAreEqual[sizeof(Dest) == sizeof(Source) ? 1 : -1];
  #endif
  
      Dest dest;
      memmove (&dest, &source, sizeof (dest));
      return dest;
    }
  
    template <class Dest, class Source>
    Dest BitCast (Source* source) {
      return BitCast<Dest> (reinterpret_cast<uintptr_t>(source));
    }
  
  }  // namespace double_conversion
  
  #endif  // DOUBLE_CONVERSION_UTILS_H_
  