code cleanup

fcharlie · Nov 10, 2024 · 350b605 · 350b605
1 parent b3ac1c8
commit 350b605
Show file tree

Hide file tree

Showing 14 changed files with 56 additions and 38 deletions.
diff --git a/include/bela/__strings/int128_have_intrinsic.inc b/include/bela/__strings/int128_have_intrinsic.inc
@@ -173,27 +173,29 @@ inline int128::operator float() const {
   // complement overwhelms the precision of the mantissa.
   //
   // Also check to make sure we don't negate Int128Min()
+  constexpr float pow_2_64 = 18446744073709551616.0f;
   return v_ < 0 && *this != Int128Min()
              ? -static_cast<float>(-*this)
              : static_cast<float>(Int128Low64(*this)) +
-                   std::ldexp(static_cast<float>(Int128High64(*this)), 64);
+                    static_cast<float>(Int128High64(*this)) * pow_2_64;
 }
 
 inline int128::operator double() const {
   // See comment in int128::operator float() above.
+   constexpr double pow_2_64 = 18446744073709551616.0;
   return v_ < 0 && *this != Int128Min()
              ? -static_cast<double>(-*this)
              : static_cast<double>(Int128Low64(*this)) +
-                   std::ldexp(static_cast<double>(Int128High64(*this)), 64);
+                   static_cast<double>(Int128High64(*this)) * pow_2_64;
 }
 
 inline int128::operator long double() const {
   // See comment in int128::operator float() above.
+  constexpr long double pow_2_64 = 18446744073709551616.0L;
   return v_ < 0 && *this != Int128Min()
              ? -static_cast<long double>(-*this)
              : static_cast<long double>(Int128Low64(*this)) +
-                   std::ldexp(static_cast<long double>(Int128High64(*this)),
-                              64);
+                    static_cast<long double>(Int128High64(*this)) * pow_2_64;
 }
 #endif  // Clang on PowerPC
 

diff --git a/include/bela/__strings/int128_no_intrinsic.inc b/include/bela/__strings/int128_no_intrinsic.inc
@@ -127,21 +127,24 @@ inline int128::operator float() const {
   // complement overwhelms the precision of the mantissa.
   //
   // Also check to make sure we don't negate Int128Min()
+  constexpr float pow_2_64 = 18446744073709551616.0f;
   return hi_ < 0 && *this != Int128Min() ? -static_cast<float>(-*this)
-                                         : static_cast<float>(lo_) + std::ldexp(static_cast<float>(hi_), 64);
+                                         : static_cast<float>(lo_) + static_cast<float>(hi_) * pow_2_64;;
 }
 
 inline int128::operator double() const {
   // See comment in int128::operator float() above.
+  constexpr double pow_2_64 = 18446744073709551616.0;
   return hi_ < 0 && *this != Int128Min() ? -static_cast<double>(-*this)
-                                         : static_cast<double>(lo_) + std::ldexp(static_cast<double>(hi_), 64);
+                                         : static_cast<double>(lo_) + static_cast<double>(hi_) * pow_2_64;;
 }
 
 inline int128::operator long double() const {
   // See comment in int128::operator float() above.
+  constexpr long double pow_2_64 = 18446744073709551616.0L;
   return hi_ < 0 && *this != Int128Min()
              ? -static_cast<long double>(-*this)
-             : static_cast<long double>(lo_) + std::ldexp(static_cast<long double>(hi_), 64);
+             : static_cast<long double>(lo_) + static_cast<long double>(hi_) * pow_2_64;;
 }
 
 // Comparison operators.

diff --git a/include/bela/int128.hpp b/include/bela/int128.hpp
@@ -448,7 +448,11 @@ class int128 {
 
   // Support for bela::Hash.
   template <typename H> friend H AbslHashValue(H h, int128 v) {
-    return H::combine(std::move(h), Int128High64(v), Int128Low64(v));
+#if defined(BELA_HAVE_INTRINSIC_INT128)
+    return H::combine(std::move(h), static_cast<unsigned __int128>(v));
+#else
+    return H::combine(std::move(h), Uint128High64(v), Uint128Low64(v));
+#endif
   }
 
 private:
@@ -720,12 +724,20 @@ constexpr uint128::operator unsigned __int128() const { return (static_cast<unsi
 
 // Conversion operators to floating point types.
 
-inline uint128::operator float() const { return static_cast<float>(lo_) + std::ldexp(static_cast<float>(hi_), 64); }
+inline uint128::operator float() const {
+  // Note: This method might return Inf.
+  constexpr float pow_2_64 = 18446744073709551616.0f;
+  return static_cast<float>(lo_) + static_cast<float>(hi_) * pow_2_64;
+}
 
-inline uint128::operator double() const { return static_cast<double>(lo_) + std::ldexp(static_cast<double>(hi_), 64); }
+inline uint128::operator double() const {
+  constexpr double pow_2_64 = 18446744073709551616.0;
+  return static_cast<double>(lo_) + static_cast<double>(hi_) * pow_2_64;
+}
 
 inline uint128::operator long double() const {
-  return static_cast<long double>(lo_) + std::ldexp(static_cast<long double>(hi_), 64);
+  constexpr long double pow_2_64 = 18446744073709551616.0L;
+  return static_cast<long double>(lo_) + static_cast<long double>(hi_) * pow_2_64;
 }
 
 // Comparison operators.

diff --git a/src/bela/ascii.cc b/src/bela/ascii.cc
@@ -171,7 +171,7 @@ void RemoveExtraAsciiWhitespace(std::wstring *str) {
 
   auto input_it = stripped.begin();
   auto input_end = stripped.end();
-  auto output_it = &(*str)[0];
+  auto output_it = str->data();
   bool is_ws = false;
 
   for (; input_it < input_end; ++input_it) {
@@ -189,7 +189,7 @@ void RemoveExtraAsciiWhitespace(std::wstring *str) {
     ++output_it;
   }
 
-  str->erase(output_it - &(*str)[0]);
+  str->erase(output_it - str->data());
 }
 
 void RemoveExtraAsciiWhitespace(std::string *str) {
@@ -202,7 +202,7 @@ void RemoveExtraAsciiWhitespace(std::string *str) {
 
   auto input_it = stripped.begin();
   auto input_end = stripped.end();
-  auto output_it = &(*str)[0];
+  auto output_it = str->data();
   bool is_ws = false;
 
   for (; input_it < input_end; ++input_it) {
@@ -220,7 +220,7 @@ void RemoveExtraAsciiWhitespace(std::string *str) {
     ++output_it;
   }
 
-  str->erase(output_it - &(*str)[0]);
+  str->erase(output_it - str->data());
 }
 
 } // namespace bela
diff --git a/src/bela/int128.cc b/src/bela/int128.cc
@@ -85,7 +85,7 @@ inline void DivModImpl(uint128 dividend, uint128 divisor, uint128 *quotient_ret,
 }
 
 template <typename T> uint128 MakeUint128FromFloat(T v) {
-  static_assert(std::is_floating_point<T>::value);
+  static_assert(std::is_floating_point_v<T>);
 
   // Rounding behavior is towards zero, same as for built-in types.
 

diff --git a/src/bela/str_split.cc b/src/bela/str_split.cc
@@ -49,7 +49,7 @@ namespace bela {
 // AnyOf delimiter will use std::wstring_view::find_first_of().
 template <typename FindPolicy>
 std::wstring_view GenericFind(std::wstring_view text, std::wstring_view delimiter, size_t pos, FindPolicy find_policy) {
-  if (delimiter.empty() && text.length() > 0) {
+  if (delimiter.empty() && !text.empty()) {
     // Special case for empty std::string delimiters: always return a
     // zero-length std::wstring_view referring to the item at position 1 past
     // pos.

diff --git a/src/bela/str_split_narrow.cc b/src/bela/str_split_narrow.cc
@@ -49,7 +49,7 @@ namespace bela::narrow {
 // AnyOf delimiter will use std::string_view::find_first_of().
 template <typename FindPolicy>
 std::string_view GenericFind(std::string_view text, std::string_view delimiter, size_t pos, FindPolicy find_policy) {
-  if (delimiter.empty() && text.length() > 0) {
+  if (delimiter.empty() && !text.empty()) {
     // Special case for empty std::string delimiters: always return a
     // zero-length std::string_view referring to the item at position 1 past
     // pos.

diff --git a/src/belahash/sha256-intel.cc b/src/belahash/sha256-intel.cc
@@ -43,14 +43,16 @@ static const union {
 };
 
 // Initial hash value (see FIPS 180-4 5.3.3)
-#define H0 0x6a09e667
-#define H1 0xbb67ae85
-#define H2 0x3c6ef372
-#define H3 0xa54ff53a
-#define H4 0x510e527f
-#define H5 0x9b05688c
-#define H6 0x1f83d9ab
-#define H7 0x5be0cd19
+enum {
+  H0 = 0x6a09e667,
+  H1 = 0xbb67ae85,
+  H2 = 0x3c6ef372,
+  H3 = 0xa54ff53a,
+  H4 = 0x510e527f,
+  H5 = 0x9b05688c,
+  H6 = 0x1f83d9ab,
+  H7 = 0x5be0cd19
+};
 
 void SHA256H::Initialize() {
   h0145 = _mm_set_epi32(H0, H1, H4, H5);

diff --git a/src/belatime/dos.cc b/src/belatime/dos.cc
@@ -20,10 +20,10 @@ constexpr int sinceWindowsEpochDays(int Y) {
 // Windows Epoch start 1601
 bela::Time FromDosDateTime(uint16_t dosDate, uint16_t dosTime) {
   auto year = (static_cast<int>(dosDate) >> 9) + 1980;
-  auto mon = static_cast<int>((dosDate >> 5) & 0xf);
+  auto mon = ((dosDate >> 5) & 0xf);
   auto day = static_cast<int>(dosDate & 0x1f);
   auto hour = static_cast<int>(dosTime) >> 11;
-  auto minute = static_cast<int>((dosTime >> 5) & 0x3f);
+  auto minute = ((dosTime >> 5) & 0x3f);
   auto sec = static_cast<int>(dosTime & 0x1f) << 1;
   if (sec < 0 || sec > 59 || minute > 59 || minute < 0 || hour < 0 || hour > 23 || mon < 1 || mon > 12 || year < 1601) {
     return bela::UnixEpoch();

diff --git a/src/belawin/pe/file.cc b/src/belawin/pe/file.cc
@@ -126,7 +126,7 @@ bool File::parseFile(bela::error_code &ec) {
     if (!fd.ReadAt(sign, signoff, ec)) {
       return false;
     }
-    if (!(sign[0] == 'P' && sign[1] == 'E' && sign[2] == 0 && sign[3] == 0)) {
+    if (sign[0] != 'P' || sign[1] != 'E' || sign[2] != 0 || sign[3] != 0) {
       ec = bela::make_error_code(ErrGeneral, L"Invalid PE COFF file signature of ['", int(sign[0]), L"','",
                                  int(sign[1]), L"','", int(sign[2]), L"','", int(sign[3]), L"']");
       return false;

diff --git a/src/belawin/pe/version.cc b/src/belawin/pe/version.cc
@@ -91,7 +91,7 @@ bool VersionLoader::getValue(const wchar_t *name, std::wstring &value) const {
                                  bela::Hex(lc.codePage, bela::kZeroPad4), L"\\", name);
     LPVOID valuePtr = nullptr;
     uint32_t size;
-    if (VerQueryValueW(buffer.data(), block.data(), reinterpret_cast<LPVOID *>(&valuePtr), &size) == TRUE &&
+    if (VerQueryValueW(buffer.data(), block.data(), (&valuePtr), &size) == TRUE &&
         valuePtr != nullptr && size > 0) {
       value.assign(cleanupString(valuePtr, size - 1));
     }

diff --git a/src/belawin/realpath.cc b/src/belawin/realpath.cc
@@ -164,9 +164,9 @@ inline bool DecodeMountPoint(const REPARSE_DATA_BUFFER *buffer, std::wstring &ta
   /* but that's confusing for programs since they wouldn't be able to */
   /* actually understand such a path when returned by uv_readlink(). */
   /* UNC paths are never valid for junctions so we don't care about them. */
-  if (!(wlen >= 6 && wstr[0] == L'\\' && wstr[1] == L'?' && wstr[2] == L'?' && wstr[3] == L'\\' &&
-        ((wstr[4] >= L'A' && wstr[4] <= L'Z') || (wstr[4] >= L'a' && wstr[4] <= L'z')) && wstr[5] == L':' &&
-        (wlen == 6 || wstr[6] == L'\\'))) {
+  if (wlen < 6 || wstr[0] != L'\\' || wstr[1] != L'?' || wstr[2] != L'?' || wstr[3] != L'\\' ||
+        ((wstr[4] < L'A' || wstr[4] > L'Z') && (wstr[4] < L'a' || wstr[4] > L'z')) || wstr[5] != L':' ||
+        (wlen != 6 && wstr[6] != L'\\')) {
     return false;
   }
 

diff --git a/src/hazel/fs.cc b/src/hazel/fs.cc
@@ -95,9 +95,9 @@ static bool DecodeMountPoint(const REPARSE_DATA_BUFFER *p, FileReparsePoint &frp
   /* but that's confusing for programs since they wouldn't be able to */
   /* actually understand such a path when returned by uv_readlink(). */
   /* UNC paths are never valid for junctions so we don't care about them. */
-  if (!(wlen >= 6 && wstr[0] == L'\\' && wstr[1] == L'?' && wstr[2] == L'?' && wstr[3] == L'\\' &&
-        ((wstr[4] >= L'A' && wstr[4] <= L'Z') || (wstr[4] >= L'a' && wstr[4] <= L'z')) && wstr[5] == L':' &&
-        (wlen == 6 || wstr[6] == L'\\'))) {
+  if (wlen < 6 || wstr[0] != L'\\' || wstr[1] != L'?' || wstr[2] != L'?' || wstr[3] != L'\\' ||
+        ((wstr[4] < L'A' || wstr[4] > L'Z') && (wstr[4] < L'a' || wstr[4] > L'z')) || wstr[5] != L':' ||
+        (wlen != 6 && wstr[6] != L'\\')) {
     ec = bela::make_error_code(bela::ErrGeneral, L"Unresolved reparse point MountPoint'");
     return false;
   }

diff --git a/src/hazel/ina/text.cc b/src/hazel/ina/text.cc
@@ -1,7 +1,6 @@
 ////////////////
 #include "hazelinc.hpp"
-#define UTF8_ACCEPT 0
-#define UTF8_REJECT 1
+enum { UTF8_ACCEPT = 0, UTF8_REJECT = 1 };
 
 namespace hazel::internal {
 // check text details