ICU-66108.tar.gz

[apple/icu.git] / icuSources / i18n / double-conversion-utils.h

diff --git a/icuSources/i18n/double-conversion-utils.h b/icuSources/i18n/double-conversion-utils.h
index 1e44fcaa0e398dcdf31609ac0dfb130f0f70871a..099298460c63d97b282928bb5b3808c16185c604 100644 (file)
--- a/icuSources/i18n/double-conversion-utils.h
+++ b/icuSources/i18n/double-conversion-utils.h
@@ -42,10 +42,12 @@
 
 // ICU PATCH: Use U_ASSERT instead of <assert.h>
 #include "uassert.h"
 
 // ICU PATCH: Use U_ASSERT instead of <assert.h>
 #include "uassert.h"

-#define ASSERT U_ASSERT
-
-#ifndef UNIMPLEMENTED
-#define UNIMPLEMENTED() (abort())
+#ifndef DOUBLE_CONVERSION_ASSERT
+#define DOUBLE_CONVERSION_ASSERT(condition)         \
+    U_ASSERT(condition);
+#endif
+#ifndef DOUBLE_CONVERSION_UNIMPLEMENTED
+#define DOUBLE_CONVERSION_UNIMPLEMENTED() (abort())

 #endif
 #ifndef DOUBLE_CONVERSION_NO_RETURN
 #ifdef _MSC_VER
 #endif
 #ifndef DOUBLE_CONVERSION_NO_RETURN
 #ifdef _MSC_VER


@@ -54,16 +56,23 @@
 #define DOUBLE_CONVERSION_NO_RETURN __attribute__((noreturn))
 #endif
 #endif
 #define DOUBLE_CONVERSION_NO_RETURN __attribute__((noreturn))
 #endif
 #endif

-#ifndef UNREACHABLE
+#ifndef DOUBLE_CONVERSION_UNREACHABLE

 #ifdef _MSC_VER
 void DOUBLE_CONVERSION_NO_RETURN abort_noreturn();
 inline void abort_noreturn() { abort(); }
 #ifdef _MSC_VER
 void DOUBLE_CONVERSION_NO_RETURN abort_noreturn();
 inline void abort_noreturn() { abort(); }

-#define UNREACHABLE()   (abort_noreturn())
+#define DOUBLE_CONVERSION_UNREACHABLE()   (abort_noreturn())

 #else
 #else

-#define UNREACHABLE()   (abort())
+#define DOUBLE_CONVERSION_UNREACHABLE()   (abort())

 #endif
 #endif
 
 #endif
 #endif
 

+#ifndef DOUBLE_CONVERSION_UNUSED
+#ifdef __GNUC__
+#define DOUBLE_CONVERSION_UNUSED __attribute__((unused))
+#else
+#define DOUBLE_CONVERSION_UNUSED
+#endif
+#endif

 
 // Double operations detection based on target architecture.
 // Linux uses a 80bit wide floating point stack on x86. This induces double
 
 // Double operations detection based on target architecture.
 // Linux uses a 80bit wide floating point stack on x86. This induces double


@@ -99,9 +108,9 @@ int main(int argc, char** argv) {
     defined(_POWER) || defined(_ARCH_PPC) || defined(_ARCH_PPC64) || \
     defined(__sparc__) || defined(__sparc) || defined(__s390__) || \
     defined(__SH4__) || defined(__alpha__) || \
     defined(_POWER) || defined(_ARCH_PPC) || defined(_ARCH_PPC64) || \
     defined(__sparc__) || defined(__sparc) || defined(__s390__) || \
     defined(__SH4__) || defined(__alpha__) || \

-    defined(_MIPS_ARCH_MIPS32R2) || \
+    defined(_MIPS_ARCH_MIPS32R2) || defined(__ARMEB__) ||\

     defined(__AARCH64EL__) || defined(__aarch64__) || defined(__AARCH64EB__) || \
     defined(__AARCH64EL__) || defined(__aarch64__) || defined(__AARCH64EB__) || \

-    defined(__riscv) || \
+    defined(__riscv) || defined(__e2k__) || \

     defined(__or1k__) || defined(__arc__) || \
     defined(__EMSCRIPTEN__)
 #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
     defined(__or1k__) || defined(__arc__) || \
     defined(__EMSCRIPTEN__)
 #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1


@@ -141,24 +150,24 @@ typedef uint16_t uc16;
 
 // The following macro works on both 32 and 64-bit platforms.
 // Usage: instead of writing 0x1234567890123456
 
 // The following macro works on both 32 and 64-bit platforms.
 // Usage: instead of writing 0x1234567890123456

-//      write UINT64_2PART_C(0x12345678,90123456);
-#define UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
+//      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 ARRAY_SIZE(a) is a compile-time constant of type
+// 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
 // size_t which represents the number of elements of the given

-// array. You should only use ARRAY_SIZE on statically allocated
+// array. You should only use DOUBLE_CONVERSION_ARRAY_SIZE on statically allocated

 // arrays.
 // arrays.

-#ifndef ARRAY_SIZE
-#define ARRAY_SIZE(a)                                   \
+#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
   ((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 DC_DISALLOW_COPY_AND_ASSIGN
-#define DC_DISALLOW_COPY_AND_ASSIGN(TypeName)      \
+#ifndef DOUBLE_CONVERSION_DISALLOW_COPY_AND_ASSIGN
+#define DOUBLE_CONVERSION_DISALLOW_COPY_AND_ASSIGN(TypeName)      \

   TypeName(const TypeName&);                    \
   void operator=(const TypeName&)
 #endif
   TypeName(const TypeName&);                    \
   void operator=(const TypeName&)
 #endif


@@ -169,10 +178,10 @@ typedef uint16_t uc16;
 // 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.
 // 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 DC_DISALLOW_IMPLICIT_CONSTRUCTORS
-#define DC_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
+#ifndef DOUBLE_CONVERSION_DISALLOW_IMPLICIT_CONSTRUCTORS
+#define DOUBLE_CONVERSION_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \

   TypeName();                                    \
   TypeName();                                    \

-  DC_DISALLOW_COPY_AND_ASSIGN(TypeName)
+  DOUBLE_CONVERSION_DISALLOW_COPY_AND_ASSIGN(TypeName)

 #endif
 
 // ICU PATCH: Wrap in ICU namespace
 #endif
 
 // ICU PATCH: Wrap in ICU namespace


@@ -180,25 +189,9 @@ U_NAMESPACE_BEGIN
 
 namespace double_conversion {
 
 
 namespace double_conversion {
 

-static const int kCharSize = sizeof(char);
-
-// Returns the maximum of the two parameters.
-template <typename T>
-static T Max(T a, T b) {
-  return a < b ? b : a;
-}
-
-
-// Returns the minimum of the two parameters.
-template <typename T>
-static T Min(T a, T b) {
-  return a < b ? a : b;
-}
-
-

 inline int StrLength(const char* string) {
   size_t length = strlen(string);
 inline int StrLength(const char* string) {
   size_t length = strlen(string);

-  ASSERT(length == static_cast<size_t>(static_cast<int>(length)));
+  DOUBLE_CONVERSION_ASSERT(length == static_cast<size_t>(static_cast<int>(length)));

   return static_cast<int>(length);
 }
 
   return static_cast<int>(length);
 }
 


@@ -208,15 +201,15 @@ class Vector {
  public:
   Vector() : start_(NULL), length_(0) {}
   Vector(T* data, int len) : start_(data), length_(len) {
  public:
   Vector() : start_(NULL), length_(0) {}
   Vector(T* data, int len) : start_(data), length_(len) {

-    ASSERT(len == 0 || (len > 0 && data != NULL));
+    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) {
   }
 
   // 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) {

-    ASSERT(to <= length_);
-    ASSERT(from < to);
-    ASSERT(0 <= from);
+    DOUBLE_CONVERSION_ASSERT(to <= length_);
+    DOUBLE_CONVERSION_ASSERT(from < to);
+    DOUBLE_CONVERSION_ASSERT(0 <= from);

     return Vector<T>(start() + from, to - from);
   }
 
     return Vector<T>(start() + from, to - from);
   }
 


@@ -231,7 +224,7 @@ class Vector {
 
   // Access individual vector elements - checks bounds in debug mode.
   T& operator[](int index) const {
 
   // Access individual vector elements - checks bounds in debug mode.
   T& operator[](int index) const {

-    ASSERT(0 <= index && index < length_);
+    DOUBLE_CONVERSION_ASSERT(0 <= index && index < length_);

     return start_[index];
   }
 
     return start_[index];
   }
 


@@ -239,6 +232,11 @@ class Vector {
 
   T& last() { return start_[length_ - 1]; }
 
 
   T& last() { return start_[length_ - 1]; }
 

+  void pop_back() {
+    DOUBLE_CONVERSION_ASSERT(!is_empty());
+    --length_;
+  }
+

  private:
   T* start_;
   int length_;
  private:
   T* start_;
   int length_;


@@ -259,7 +257,7 @@ class StringBuilder {
 
   // Get the current position in the builder.
   int position() const {
 
   // Get the current position in the builder.
   int position() const {

-    ASSERT(!is_finalized());
+    DOUBLE_CONVERSION_ASSERT(!is_finalized());

     return position_;
   }
 
     return position_;
   }
 


@@ -270,8 +268,8 @@ class StringBuilder {
   // 0-characters; use the Finalize() method to terminate the string
   // instead.
   void AddCharacter(char c) {
   // 0-characters; use the Finalize() method to terminate the string
   // instead.
   void AddCharacter(char c) {

-    ASSERT(c != '\0');
-    ASSERT(!is_finalized() && position_ < buffer_.length());
+    DOUBLE_CONVERSION_ASSERT(c != '\0');
+    DOUBLE_CONVERSION_ASSERT(!is_finalized() && position_ < buffer_.length());

     buffer_[position_++] = c;
   }
 
     buffer_[position_++] = c;
   }
 


@@ -284,9 +282,9 @@ class StringBuilder {
   // 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) {
   // 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) {

-    ASSERT(!is_finalized() && position_ + n < buffer_.length());
-    ASSERT(static_cast<size_t>(n) <= strlen(s));
-    memmove(&buffer_[position_], s, n * kCharSize);
+    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;
   }
 
     position_ += n;
   }
 


@@ -301,13 +299,13 @@ class StringBuilder {
 
   // Finalize the string by 0-terminating it and returning the buffer.
   char* Finalize() {
 
   // Finalize the string by 0-terminating it and returning the buffer.
   char* Finalize() {

-    ASSERT(!is_finalized() && position_ < buffer_.length());
+    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.
     buffer_[position_] = '\0';
     // Make sure nobody managed to add a 0-character to the
     // buffer while building the string.

-    ASSERT(strlen(buffer_.start()) == static_cast<size_t>(position_));
+    DOUBLE_CONVERSION_ASSERT(strlen(buffer_.start()) == static_cast<size_t>(position_));

     position_ = -1;
     position_ = -1;

-    ASSERT(is_finalized());
+    DOUBLE_CONVERSION_ASSERT(is_finalized());

     return buffer_.start();
   }
 
     return buffer_.start();
   }
 


@@ -317,7 +315,7 @@ class StringBuilder {
 
   bool is_finalized() const { return position_ < 0; }
 
 
   bool is_finalized() const { return position_ < 0; }
 

-  DC_DISALLOW_IMPLICIT_CONSTRUCTORS(StringBuilder);
+  DOUBLE_CONVERSION_DISALLOW_IMPLICIT_CONSTRUCTORS(StringBuilder);

 };
 
 // The type-based aliasing rule allows the compiler to assume that pointers of
 };
 
 // The type-based aliasing rule allows the compiler to assume that pointers of


@@ -345,13 +343,14 @@ class StringBuilder {
 // 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>
 // 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>

-inline Dest BitCast(const Source& 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
   // 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
 
   typedef char VerifySizesAreEqual[sizeof(Dest) == sizeof(Source) ? 1 : -1];
 #endif
 


@@ -361,7 +360,7 @@ inline Dest BitCast(const Source& source) {
 }
 
 template <class Dest, class Source>
 }
 
 template <class Dest, class Source>

-inline Dest BitCast(Source* source) {
+Dest BitCast(Source* source) {

   return BitCast<Dest>(reinterpret_cast<uintptr_t>(source));
 }
 
   return BitCast<Dest>(reinterpret_cast<uintptr_t>(source));
 }