From 8aaf029ab6046eb8cbe600a548d176c1418bd99a Mon Sep 17 00:00:00 2001 From: B Stack Date: Fri, 2 Oct 2020 14:42:30 -0400 Subject: add upstream 11.2 --- zen/basic_math.h | 9 ++-- zen/build_info.h | 9 ---- zen/file_access.cpp | 4 +- zen/file_io.cpp | 8 ++-- zen/file_io.h | 4 +- zen/format_unit.cpp | 39 ++++++++++++++++++ zen/format_unit.h | 15 +++++++ zen/legacy_compiler.cpp | 4 +- zen/legacy_compiler.h | 25 ++++++++---- zen/open_ssl.cpp | 5 ++- zen/recycler.cpp | 71 ++++++++++++++++++++++++++++++-- zen/socket.h | 1 - zen/stl_tools.h | 10 ----- zen/string_base.h | 4 +- zen/string_tools.h | 106 ++++++++++++++++++++++++------------------------ zen/sys_version.cpp | 21 ++++++---- zen/zstring.cpp | 67 +++++++++++++++--------------- zen/zstring.h | 24 +++++------ 18 files changed, 267 insertions(+), 159 deletions(-) (limited to 'zen') diff --git a/zen/basic_math.h b/zen/basic_math.h index 0e30c276..26fb9e58 100644 --- a/zen/basic_math.h +++ b/zen/basic_math.h @@ -183,18 +183,15 @@ auto integerDivideRoundUp(N numerator, D denominator) namespace { template struct PowerImpl; -/* - template -> let's use non-recursive specializations to help the compiler - struct PowerImpl { static T result(const T& value) { return PowerImpl::result(value) * value; } }; -*/ +//let's use non-recursive specializations to help the compiler template struct PowerImpl<2, T> { static T result(T value) { return value * value; } }; template struct PowerImpl<3, T> { static T result(T value) { return value * value * value; } }; } -template inline +template inline T power(T value) { - return PowerImpl::result(value); + return PowerImpl::result(value); } diff --git a/zen/build_info.h b/zen/build_info.h index 01f1aeb8..adb19f86 100644 --- a/zen/build_info.h +++ b/zen/build_info.h @@ -7,8 +7,6 @@ #ifndef BUILD_INFO_H_5928539285603428657 #define BUILD_INFO_H_5928539285603428657 - #include //std::endian - #define ZEN_ARCH_32BIT 32 #define ZEN_ARCH_64BIT 64 @@ -20,11 +18,4 @@ static_assert(ZEN_BUILD_ARCH == sizeof(void*) * 8); -//-------------------------------------------------------------------- - -constexpr bool usingLittleEndian() -{ - return std::endian::native == std::endian::little; -} - #endif //BUILD_INFO_H_5928539285603428657 diff --git a/zen/file_access.cpp b/zen/file_access.cpp index 7d3fbfc5..3269bef4 100644 --- a/zen/file_access.cpp +++ b/zen/file_access.cpp @@ -82,7 +82,7 @@ std::optional zen::getParentFolderPath(const Zstring& itemPath) if (const std::optional comp = parsePathComponents(itemPath)) { if (comp->relPath.empty()) - return {}; + return std::nullopt; const Zstring parentRelPath = beforeLast(comp->relPath, FILE_NAME_SEPARATOR, IfNotFoundReturn::none); if (parentRelPath.empty()) @@ -90,7 +90,7 @@ std::optional zen::getParentFolderPath(const Zstring& itemPath) return appendSeparator(comp->rootPath) + parentRelPath; } assert(false); - return {}; + return std::nullopt; } diff --git a/zen/file_io.cpp b/zen/file_io.cpp index 4c6602cc..33c41fbc 100644 --- a/zen/file_io.cpp +++ b/zen/file_io.cpp @@ -15,7 +15,7 @@ using namespace zen; FileBase::~FileBase() { - if (hFile_ != invalidFileHandle_) + if (hFile_ != invalidFileHandle) try { close(); //throw FileError @@ -26,9 +26,9 @@ FileBase::~FileBase() void FileBase::close() //throw FileError { - if (hFile_ == invalidFileHandle_) + if (hFile_ == invalidFileHandle) throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(getFilePath())), L"Contract error: close() called more than once."); - ZEN_ON_SCOPE_EXIT(hFile_ = invalidFileHandle_); + ZEN_ON_SCOPE_EXIT(hFile_ = invalidFileHandle); if (::close(hFile_) != 0) THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write file %x."), L"%x", fmtPath(getFilePath())), "close"); @@ -198,7 +198,7 @@ FileOutput::FileOutput(const Zstring& filePath, const IOCallback& notifyUnbuffer FileOutput::~FileOutput() { - if (getHandle() != invalidFileHandle_) //not finalized => clean up garbage + if (getHandle() != invalidFileHandle) //not finalized => clean up garbage { //"deleting while handle is open" == FILE_FLAG_DELETE_ON_CLOSE if (::unlink(getFilePath().c_str()) != 0) diff --git a/zen/file_io.h b/zen/file_io.h index 81e1e7cc..4210cc57 100644 --- a/zen/file_io.h +++ b/zen/file_io.h @@ -27,7 +27,7 @@ class FileBase { public: using FileHandle = int; - static const int invalidFileHandle_ = -1; + static const int invalidFileHandle = -1; FileHandle getHandle() { return hFile_; } @@ -48,7 +48,7 @@ private: FileBase (const FileBase&) = delete; FileBase& operator=(const FileBase&) = delete; - FileHandle hFile_ = invalidFileHandle_; + FileHandle hFile_ = invalidFileHandle; const Zstring filePath_; }; diff --git a/zen/format_unit.cpp b/zen/format_unit.cpp index 4984c1d7..0d75a9d4 100644 --- a/zen/format_unit.cpp +++ b/zen/format_unit.cpp @@ -7,12 +7,16 @@ #include "format_unit.h" #include #include +#include #include "basic_math.h" +#include "sys_error.h" #include "i18n.h" #include "time.h" #include "globals.h" #include "utf.h" + #include + #include #include //thousands separator #include "utf.h" // @@ -181,3 +185,38 @@ std::wstring zen::formatUtcToLocalTime(time_t utcTime) } + + +WeekDay impl::getFirstDayOfWeekImpl() //throw SysError +{ + /* testing: change locale via command line + --------------------------------------- + LC_TIME=en_DK.utf8 => Monday + LC_TIME=en_US.utf8 => Sunday */ + + const char* firstDay = ::nl_langinfo(_NL_TIME_FIRST_WEEKDAY); //[1-Sunday, 7-Saturday] + ASSERT_SYSERROR(firstDay && 1 <= *firstDay && *firstDay <= 7); + + const int weekDayStartSunday = *firstDay; + const int weekDayStartMonday = (weekDayStartSunday - 1 + 6) % 7; //+6 == -1 in Z_7 + // [0-Monday, 6-Sunday] + return static_cast(weekDayStartMonday); +} + + +WeekDay zen::getFirstDayOfWeek() +{ + static const WeekDay weekDay = [] + { + try + { + return impl::getFirstDayOfWeekImpl(); //throw SysError + } + catch (const SysError& e) + { + throw std::runtime_error(std::string(__FILE__) + '[' + numberTo(__LINE__) + "] Failed to get first day of the week." + "\n\n" + + utfTo(e.toString())); + } + }(); + return weekDay; +} diff --git a/zen/format_unit.h b/zen/format_unit.h index de5a0811..1c96da51 100644 --- a/zen/format_unit.h +++ b/zen/format_unit.h @@ -24,6 +24,21 @@ std::wstring formatThreeDigitPrecision(double value); //(unless value is too lar std::wstring formatNumber(int64_t n); //format integer number including thousands separator + + +enum class WeekDay +{ + monday, + tuesday, + wednesday, + thursday, + friday, + saturday, + sunday, +}; +WeekDay getFirstDayOfWeek(); + +namespace impl { WeekDay getFirstDayOfWeekImpl(); } //throw SysError } #endif diff --git a/zen/legacy_compiler.cpp b/zen/legacy_compiler.cpp index 66125b0f..81efb4dd 100644 --- a/zen/legacy_compiler.cpp +++ b/zen/legacy_compiler.cpp @@ -9,13 +9,13 @@ #error get rid of workarounds #endif -double zen::from_chars(const char* first, const char* last) +double zen::fromChars(const char* first, const char* last) { return std::strtod(std::string(first, last).c_str(), nullptr); } -const char* zen::to_chars(char* first, char* last, double num) +const char* zen::toChars(char* first, char* last, double num) { const size_t bufSize = last - first; const int charsWritten = std::snprintf(first, bufSize, "%g", num); diff --git a/zen/legacy_compiler.h b/zen/legacy_compiler.h index 82c404d8..ad5442fe 100644 --- a/zen/legacy_compiler.h +++ b/zen/legacy_compiler.h @@ -7,26 +7,37 @@ #ifndef LEGACY_COMPILER_H_839567308565656789 #define LEGACY_COMPILER_H_839567308565656789 +#include +/* C++ standard conformance: + https://en.cppreference.com/w/cpp/feature_test + https://en.cppreference.com/w/User:D41D8CD98F/feature_testing_macros + https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations + + MSVC https://docs.microsoft.com/en-us/cpp/overview/visual-cpp-language-conformance + + GCC https://gcc.gnu.org/projects/cxx-status.html + libstdc++ https://gcc.gnu.org/onlinedocs/libstdc++/manual/status.html + + Clang https://clang.llvm.org/cxx_status.html#cxx20 + libc++ https://libcxx.llvm.org/cxx2a_status.html */ -//https://en.cppreference.com/w/cpp/feature_test -//https://en.cppreference.com/w/User:D41D8CD98F/feature_testing_macros -//https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations -//https://gcc.gnu.org/onlinedocs/libstdc++/manual/status.html namespace std { + + } //--------------------------------------------------------------------------------- //constinit, consteval - #define constinit2 constinit //GCC has it + #define constinit2 constinit //GCC, clang have it #define consteval2 consteval // namespace zen { -double from_chars(const char* first, const char* last); -const char* to_chars(char* first, char* last, double num); +double fromChars(const char* first, const char* last); +const char* toChars(char* first, char* last, double num); } #endif //LEGACY_COMPILER_H_839567308565656789 diff --git a/zen/open_ssl.cpp b/zen/open_ssl.cpp index 1d0c4bf2..ea77db43 100644 --- a/zen/open_ssl.cpp +++ b/zen/open_ssl.cpp @@ -5,6 +5,7 @@ // ***************************************************************************** #include "open_ssl.h" +#include //std::endian #include #include "base64.h" #include "build_info.h" @@ -774,7 +775,7 @@ std::string zen::convertPuttyKeyToPkix(const std::string& keyStream, const std:: auto numToBeString = [](size_t n) -> std::string { - static_assert(usingLittleEndian()&& sizeof(n) >= 4); + static_assert(std::endian::native == std::endian::little&& sizeof(n) >= 4); const char* numStr = reinterpret_cast(&n); return { numStr[3], numStr[2], numStr[1], numStr[0] }; //big endian! }; @@ -806,7 +807,7 @@ std::string zen::convertPuttyKeyToPkix(const std::string& keyStream, const std:: if (itEnd - it < makeSigned(sizeof(byteCount))) throw SysError(L"String extraction failed: unexpected end of stream"); - static_assert(usingLittleEndian()); + static_assert(std::endian::native == std::endian::little); char* numStr = reinterpret_cast(&byteCount); numStr[3] = *it++; // numStr[2] = *it++; //Putty uses big endian! diff --git a/zen/recycler.cpp b/zen/recycler.cpp index b1f2c0fd..4448fd60 100644 --- a/zen/recycler.cpp +++ b/zen/recycler.cpp @@ -16,6 +16,7 @@ using namespace zen; +//*INDENT-OFF* bool zen::recycleOrDeleteIfExists(const Zstring& itemPath) //throw FileError { GFile* file = ::g_file_new_for_path(itemPath.c_str()); //never fails according to docu @@ -32,12 +33,73 @@ bool zen::recycleOrDeleteIfExists(const Zstring& itemPath) //throw FileError /* g_file_trash() can fail with different error codes/messages when trash is unavailable: Debian 8 (GLib 2.42): G_IO_ERROR_NOT_SUPPORTED: Unable to find or create trash directory - CentOS 7 (GLib 2.56): G_IO_ERROR_FAILED: Unable to find or create trash directory for file.txt + CentOS 7 (GLib 2.56): G_IO_ERROR_FAILED: Unable to find or create trash directory for file.txt => localized! >:( master (GLib 2.64): G_IO_ERROR_NOT_SUPPORTED: Trashing on system internal mounts is not supported https://gitlab.gnome.org/GNOME/glib/blob/master/gio/glocalfile.c#L2042 */ - const bool trashUnavailable = error && - ((error->domain == G_IO_ERROR && error->code == G_IO_ERROR_NOT_SUPPORTED) || - startsWith(error->message, "Unable to find or create trash directory")); + const bool trashUnavailable = error && error->domain == G_IO_ERROR && + (error->code == G_IO_ERROR_NOT_SUPPORTED || + + //yes, the following is a cluster fuck, but what can you do? + (error->code == G_IO_ERROR_FAILED && [&] + { + for (const char* msgLoc : //translations from https://gitlab.gnome.org/GNOME/glib/-/tree/master/po + { + "Unable to find or create trash directory for", + "No s'ha pogut trobar o crear el directori de la paperera per", + "Nelze nalézt nebo vytvořit složku koše pro", + "Kan ikke finde eller oprette papirkurvskatalog for", + "Αδύνατη η εύρεση ή δημιουργία του καταλόγου απορριμμάτων", + "Unable to find or create wastebasket directory for", + "Ne eblas trovi aŭ krei rubujan dosierujon", + "No se pudo encontrar o crear la carpeta de la papelera para", + "Prügikasti kataloogi pole võimalik leida või luua", + "zakarrontziaren direktorioa aurkitu edo sortu", + "Roskakori kansiota ei löydy tai sitä ei voi luoda", + "Impossible de trouver ou créer le répertoire de la corbeille pour", + "Non é posíbel atopar ou crear o directorio do lixo para", + "Nisam mogao promijeniti putanju u mapu", + "Nem található vagy nem hozható létre a Kuka könyvtár ehhez:", + "Tidak bisa menemukan atau membuat direktori tong sampah bagi", + "Impossibile trovare o creare la directory cestino per", + "のゴミ箱ディレクトリが存在しないか作成できません", + "휴지통 디렉터리를 찾을 수 없거나 만들 수 없습니다", + "Nepavyko rasti ar sukurti šiukšlių aplanko", + "Nevar atrast vai izveidot miskastes mapi priekš", + "Tidak boleh mencari atau mencipta direktori tong sampah untuk", + "Kan ikke finne eller opprette mappe for papirkurv for", + "फाइल सिर्जना गर्न असफल:", + "Impossible de trobar o crear lo repertòri de l'escobilhièr per", + "ਲਈ ਰੱਦੀ ਡਾਇਰੈਕਟਰੀ ਲੱਭਣ ਜਾਂ ਬਣਾਉਣ ਲਈ ਅਸਮਰੱਥ", + "Nie można odnaleźć lub utworzyć katalogu kosza dla", + "Impossível encontrar ou criar a pasta de lixo para", + "Não é possível localizar ou criar o diretório da lixeira para", + "Nu se poate găsi sau crea directorul coșului de gunoi pentru", + "Не удалось найти или создать каталог корзины для", + "Nepodarilo sa nájsť ani vytvoriť adresár Kôš pre", + "Ni mogoče najti oziroma ustvariti mape smeti za", + "Не могу да нађем или направим директоријум смећа за", + "Ne mogu da nađem ili napravim direktorijum smeća za", + "Kunde inte hitta eller skapa papperskorgskatalog för", + "için çöp dizini bulunamıyor ya da oluşturulamıyor", + "Не вдалося знайти або створити каталог смітника для", + "หาหรือสร้างไดเรกทอรีถังขยะสำหรับ", + }) + if (contains(error->message, msgLoc)) + return true; + + for (const auto& [msgLoc1, msgLoc2] : + { + std::pair{"Papierkorb-Ordner konnte für", "nicht gefunden oder angelegt werden"}, + std::pair{"Kan prullenbakmap voor", "niet vinden of aanmaken"}, + std::pair{"无法为", "找到或创建回收站目录"}, + std::pair{"無法找到或建立", "的垃圾桶目錄"}, + }) + if (contains(error->message, msgLoc1) && contains(error->message, msgLoc2)) + return true; + + return false; + }())); + if (trashUnavailable) //implement same behavior as on Windows: if recycler is not existing, delete permanently { if (*type == ItemType::folder) @@ -52,6 +114,7 @@ bool zen::recycleOrDeleteIfExists(const Zstring& itemPath) //throw FileError } return true; } +//*INDENT-ON* /* We really need access to a similar function to check whether a directory supports trashing and emit a warning if it does not! diff --git a/zen/socket.h b/zen/socket.h index f1d26450..62386801 100644 --- a/zen/socket.h +++ b/zen/socket.h @@ -145,7 +145,6 @@ void shutdownSocketSend(SocketType socket) //throw SysError if (::shutdown(socket, SHUT_WR) != 0) THROW_LAST_SYS_ERROR_WSA("shutdown"); } - } #endif //SOCKET_H_23498325972583947678456437 diff --git a/zen/stl_tools.h b/zen/stl_tools.h index 7d071413..495ff8d1 100644 --- a/zen/stl_tools.h +++ b/zen/stl_tools.h @@ -185,18 +185,8 @@ BidirectionalIterator1 searchLast(const BidirectionalIterator1 first1, Bid } } - -//--------------------------------------------------------------------------------------- -//http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0458r2.html - -template >> inline - bool contains(const Container& c, const ValueType& val, int dummy = 0 /*overload string_tools.h contains()*/) -{ - return c.find(val) != c.end(); -} //--------------------------------------------------------------------------------------- - //read-only variant of std::merge; input: two sorted ranges template inline void mergeTraversal(Iterator first1, Iterator last1, diff --git a/zen/string_base.h b/zen/string_base.h index 1052de56..f0899433 100644 --- a/zen/string_base.h +++ b/zen/string_base.h @@ -10,7 +10,7 @@ #include #include #include "string_tools.h" - +#include "legacy_compiler.h" //constinit2 //Zbase - a policy based string class optimizing performance and flexibility @@ -312,7 +312,6 @@ template class SP> std::strong_ordering operator<= template class SP> std::strong_ordering operator<=>(const Zbase& lhs, const Char* rhs); template class SP> std::strong_ordering operator<=>(const Char* lhs, const Zbase& rhs); - template class SP> inline Zbase operator+(const Zbase& lhs, const Zbase& rhs) { return Zbase(lhs) += rhs; } template class SP> inline Zbase operator+(const Zbase& lhs, const Char* rhs) { return Zbase(lhs) += rhs; } template class SP> inline Zbase operator+(const Zbase& lhs, Char rhs) { return Zbase(lhs) += rhs; } @@ -515,7 +514,6 @@ std::strong_ordering operator<=>(const Char* lhs, const Zbase& rhs) } - template class SP> inline size_t Zbase::length() const { diff --git a/zen/string_tools.h b/zen/string_tools.h index 2c33a4f8..fc715961 100644 --- a/zen/string_tools.h +++ b/zen/string_tools.h @@ -16,7 +16,7 @@ #include #include "stl_tools.h" #include "string_traits.h" -#include "legacy_compiler.h" // (without compiler crashes) +#include "legacy_compiler.h" // but without the compiler crashes :> //enhance *any* string class with useful non-member functions: @@ -44,12 +44,12 @@ template >> bool template bool equalString (const S& lhs, const T& rhs); template bool equalAsciiNoCase(const S& lhs, const T& rhs); - template int compareString (const S& lhs, const T& rhs); - template int compareAsciiNoCase(const S& lhs, const T& rhs); //basic case-insensitive comparison (considering A-Z only!) + // template std::strong_ordering compareString (const S& lhs, const T& rhs); + template std::weak_ordering compareAsciiNoCase(const S& lhs, const T& rhs); //basic case-insensitive comparison (considering A-Z only!) struct LessAsciiNoCase //STL container predicate { - template bool operator()(const S& lhs, const S& rhs) const { return compareAsciiNoCase(lhs, rhs) < 0; } + template bool operator()(const S& lhs, const S& rhs) const { return std::is_lt(compareAsciiNoCase(lhs, rhs)); } }; @@ -186,22 +186,22 @@ Char asciiToLower(Char c) namespace impl { -inline int strcmpWithNulls(const char* ptr1, const char* ptr2, size_t num) { return std:: memcmp(ptr1, ptr2, num); } //support embedded 0, unlike strncmp/wcsncmp! -inline int strcmpWithNulls(const wchar_t* ptr1, const wchar_t* ptr2, size_t num) { return std::wmemcmp(ptr1, ptr2, num); } // +//support embedded 0, unlike strncmp/wcsncmp: +inline std::strong_ordering strcmpWithNulls(const char* ptr1, const char* ptr2, size_t num) { return std:: memcmp(ptr1, ptr2, num) <=> 0; } +inline std::strong_ordering strcmpWithNulls(const wchar_t* ptr1, const wchar_t* ptr2, size_t num) { return std::wmemcmp(ptr1, ptr2, num) <=> 0; } template inline -int strcmpAsciiNoCase(const Char1* lhs, const Char2* rhs, size_t len) +std::weak_ordering strcmpAsciiNoCase(const Char1* lhs, const Char2* rhs, size_t len) { while (len-- > 0) { const Char1 charL = asciiToLower(*lhs++); //ordering: lower-case chars have higher code points than uppper-case const Char2 charR = asciiToLower(*rhs++); // if (charL != charR) - return static_cast(charL) - static_cast(charR); //unsigned char-comparison is the convention! - //unsigned underflow is well-defined! + return makeUnsigned(charL) <=> makeUnsigned(charR); //unsigned char-comparison is the convention! } - return 0; + return std::weak_ordering::equivalent; } } @@ -210,7 +210,7 @@ template inline bool startsWith(const S& str, const T& prefix) { const size_t pfLen = strLength(prefix); - return strLength(str) >= pfLen && impl::strcmpWithNulls(strBegin(str), strBegin(prefix), pfLen) == 0; + return strLength(str) >= pfLen && std::is_eq(impl::strcmpWithNulls(strBegin(str), strBegin(prefix), pfLen)); } @@ -218,7 +218,7 @@ template inline bool startsWithAsciiNoCase(const S& str, const T& prefix) { const size_t pfLen = strLength(prefix); - return strLength(str) >= pfLen && impl::strcmpAsciiNoCase(strBegin(str), strBegin(prefix), pfLen) == 0; + return strLength(str) >= pfLen && std::is_eq(impl::strcmpAsciiNoCase(strBegin(str), strBegin(prefix), pfLen)); } @@ -227,7 +227,7 @@ bool endsWith(const S& str, const T& postfix) { const size_t strLen = strLength(str); const size_t pfLen = strLength(postfix); - return strLen >= pfLen && impl::strcmpWithNulls(strBegin(str) + strLen - pfLen, strBegin(postfix), pfLen) == 0; + return strLen >= pfLen && std::is_eq(impl::strcmpWithNulls(strBegin(str) + strLen - pfLen, strBegin(postfix), pfLen)); } @@ -236,7 +236,7 @@ bool endsWithAsciiNoCase(const S& str, const T& postfix) { const size_t strLen = strLength(str); const size_t pfLen = strLength(postfix); - return strLen >= pfLen && impl::strcmpAsciiNoCase(strBegin(str) + strLen - pfLen, strBegin(postfix), pfLen) == 0; + return strLen >= pfLen && std::is_eq(impl::strcmpAsciiNoCase(strBegin(str) + strLen - pfLen, strBegin(postfix), pfLen)); } @@ -244,7 +244,7 @@ template inline bool equalString(const S& lhs, const T& rhs) { const size_t lhsLen = strLength(lhs); - return lhsLen == strLength(rhs) && impl::strcmpWithNulls(strBegin(lhs), strBegin(rhs), lhsLen) == 0; + return lhsLen == strLength(rhs) && std::is_eq(impl::strcmpWithNulls(strBegin(lhs), strBegin(rhs), lhsLen)); } @@ -252,34 +252,36 @@ template inline bool equalAsciiNoCase(const S& lhs, const T& rhs) { const size_t lhsLen = strLength(lhs); - return lhsLen == strLength(rhs) && impl::strcmpAsciiNoCase(strBegin(lhs), strBegin(rhs), lhsLen) == 0; + return lhsLen == strLength(rhs) && std::is_eq(impl::strcmpAsciiNoCase(strBegin(lhs), strBegin(rhs), lhsLen)); } +#if 0 template inline -int compareString(const S& lhs, const T& rhs) +std::strong_ordering compareString(const S& lhs, const T& rhs) { const size_t lhsLen = strLength(lhs); const size_t rhsLen = strLength(rhs); - //length check *after* strcmpWithNulls(): we do care about natural ordering: e.g. for "compareString(getUpperCase(lhs), getUpperCase(rhs))" - if (const int rv = impl::strcmpWithNulls(strBegin(lhs), strBegin(rhs), std::min(lhsLen, rhsLen)); - rv != 0) - return rv; - return static_cast(lhsLen) - static_cast(rhsLen); + //length check *after* strcmpWithNulls(): we DO care about natural ordering: e.g. for "compareString(getUpperCase(lhs), getUpperCase(rhs))" + if (const std::strong_ordering cmp = impl::strcmpWithNulls(strBegin(lhs), strBegin(rhs), std::min(lhsLen, rhsLen)); + std::is_neq(cmp)) + return cmp; + return lhsLen <=> rhsLen; } +#endif template inline -int compareAsciiNoCase(const S& lhs, const T& rhs) +std::weak_ordering compareAsciiNoCase(const S& lhs, const T& rhs) { const size_t lhsLen = strLength(lhs); const size_t rhsLen = strLength(rhs); - if (const int rv = impl::strcmpAsciiNoCase(strBegin(lhs), strBegin(rhs), std::min(lhsLen, rhsLen)); - rv != 0) - return rv; - return static_cast(lhsLen) - static_cast(rhsLen); + if (const std::weak_ordering cmp = impl::strcmpAsciiNoCase(strBegin(lhs), strBegin(rhs), std::min(lhsLen, rhsLen)); + std::is_neq(cmp)) + return cmp; + return lhsLen <=> rhsLen; } @@ -583,17 +585,17 @@ namespace impl { enum class NumberType { - SIGNED_INT, - UNSIGNED_INT, - FLOATING_POINT, - OTHER, + signedInt, + unsignedInt, + floatingPoint, + other, }; -template S numberTo(const Num& number, std::integral_constant) = delete; +template S numberTo(const Num& number, std::integral_constant) = delete; #if 0 //default number to string conversion using streams: convenient, but SLOW, SLOW, SLOW!!!! (~ factor of 20) template inline -S numberTo(const Num& number, std::integral_constant) +S numberTo(const Num& number, std::integral_constant) { std::basic_ostringstream> ss; ss << number; @@ -603,13 +605,13 @@ S numberTo(const Num& number, std::integral_constant inline -S numberTo(const Num& number, std::integral_constant) +S numberTo(const Num& number, std::integral_constant) { //don't use sprintf("%g"): way SLOWWWWWWER than std::to_chars() char buffer[128]; //zero-initialize? //let's give some leeway, but 24 chars should suffice: https://www.reddit.com/r/cpp/comments/dgj89g/cppcon_2019_stephan_t_lavavej_floatingpoint/f3j7d3q/ - const char* strEnd = to_chars(std::begin(buffer), std::end(buffer), number); + const char* strEnd = toChars(std::begin(buffer), std::end(buffer), number); S output; std::for_each(static_cast(buffer), strEnd, @@ -657,7 +659,7 @@ void formatPositiveInteger(Num n, OutputIterator& it) template inline -S numberTo(const Num& number, std::integral_constant) +S numberTo(const Num& number, std::integral_constant) { GetCharTypeT buffer[2 + sizeof(Num) * 241 / 100]; //zero-initialize? //it's generally faster to use a buffer than to rely on String::operator+=() (in)efficiency @@ -677,7 +679,7 @@ S numberTo(const Num& number, std::integral_constant inline -S numberTo(const Num& number, std::integral_constant) +S numberTo(const Num& number, std::integral_constant) { GetCharTypeT buffer[1 + sizeof(Num) * 241 / 100]; //zero-initialize? //required chars: ceil(ln_10(256^sizeof(n))) =~ ceil(sizeof(n) * 2.4082) <= 1 + floor(sizeof(n) * 2.41) @@ -691,10 +693,10 @@ S numberTo(const Num& number, std::integral_constant Num stringTo(const S& str, std::integral_constant) = delete; +template Num stringTo(const S& str, std::integral_constant) = delete; #if 0 //default string to number conversion using streams: convenient, but SLOW template inline -Num stringTo(const S& str, std::integral_constant) +Num stringTo(const S& str, std::integral_constant) { using CharType = GetCharTypeT; Num number = 0; @@ -708,7 +710,7 @@ inline double stringToFloat(const char* first, const char* last) { //don't use std::strtod(): 1. requires null-terminated string 2. SLOWER than std::from_chars() - return from_chars(first, last); + return fromChars(first, last); } @@ -718,12 +720,12 @@ double stringToFloat(const wchar_t* first, const wchar_t* last) std::string buf(last - first, '\0'); std::transform(first, last, buf.begin(), [](wchar_t c) { return static_cast(c); }); - return from_chars(buf.c_str(), buf.c_str() + buf.size()); + return fromChars(buf.c_str(), buf.c_str() + buf.size()); } template inline -Num stringTo(const S& str, std::integral_constant) +Num stringTo(const S& str, std::integral_constant) { const auto* const first = strBegin(str); const auto* const last = first + strLength(str); @@ -771,7 +773,7 @@ Num extractInteger(const S& str, bool& hasMinusSign) //very fast conversion to i template inline -Num stringTo(const S& str, std::integral_constant) +Num stringTo(const S& str, std::integral_constant) { bool hasMinusSign = false; //handle minus sign const Num number = extractInteger(str, hasMinusSign); @@ -780,7 +782,7 @@ Num stringTo(const S& str, std::integral_constant inline -Num stringTo(const S& str, std::integral_constant) //very fast conversion to integers: slightly faster than std::atoi, but more importantly: generic +Num stringTo(const S& str, std::integral_constant) //very fast conversion to integers: slightly faster than std::atoi, but more importantly: generic { bool hasMinusSign = false; //handle minus sign const Num number = extractInteger(str, hasMinusSign); @@ -798,10 +800,10 @@ template inline S numberTo(const Num& number) { using TypeTag = std::integral_constant::value ? impl::NumberType::SIGNED_INT : - IsUnsignedInt::value ? impl::NumberType::UNSIGNED_INT : - IsFloat ::value ? impl::NumberType::FLOATING_POINT : - impl::NumberType::OTHER>; + IsSignedInt ::value ? impl::NumberType::signedInt : + IsUnsignedInt::value ? impl::NumberType::unsignedInt : + IsFloat ::value ? impl::NumberType::floatingPoint : + impl::NumberType::other>; return impl::numberTo(number, TypeTag()); } @@ -811,10 +813,10 @@ template inline Num stringTo(const S& str) { using TypeTag = std::integral_constant::value ? impl::NumberType::SIGNED_INT : - IsUnsignedInt::value ? impl::NumberType::UNSIGNED_INT : - IsFloat ::value ? impl::NumberType::FLOATING_POINT : - impl::NumberType::OTHER>; + IsSignedInt ::value ? impl::NumberType::signedInt : + IsUnsignedInt::value ? impl::NumberType::unsignedInt : + IsFloat ::value ? impl::NumberType::floatingPoint : + impl::NumberType::other>; return impl::stringTo(str, TypeTag()); } diff --git a/zen/sys_version.cpp b/zen/sys_version.cpp index 46918315..d07bbc33 100644 --- a/zen/sys_version.cpp +++ b/zen/sys_version.cpp @@ -78,14 +78,17 @@ OsVersionDetail zen::getOsVersionDetail() //throw SysError OsVersion zen::getOsVersion() { - try - { - static const OsVersionDetail verDetail = getOsVersionDetail(); //throw SysError - return verDetail.version; - } - catch (const SysError& e) + static const OsVersionDetail verDetail = [] { - std::cerr << utfTo(e.toString()) << '\n'; - return {}; //sigh, it's a jungle out there: https://freefilesync.org/forum/viewtopic.php?t=7276 - } + try + { + return getOsVersionDetail(); //throw SysError + } + catch (const SysError& e) + { + std::cerr << utfTo(e.toString()) << '\n'; + return OsVersionDetail{}; //sigh, it's a jungle out there: https://freefilesync.org/forum/viewtopic.php?t=7276 + } + }(); + return verDetail.version; } diff --git a/zen/zstring.cpp b/zen/zstring.cpp index 06c839e3..c9861219 100644 --- a/zen/zstring.cpp +++ b/zen/zstring.cpp @@ -106,38 +106,38 @@ Zstring replaceCpyAsciiNoCase(const Zstring& str, const Zstring& oldTerm, const /* https://docs.microsoft.com/de-de/windows/desktop/Intl/handling-sorting-in-your-applications -Perf test: compare strings 10 mio times; 64 bit build ------------------------------------------------------ - string a = "Fjk84$%kgfj$%T\\\\Gffg\\gsdgf\\fgsx----------d-" - string b = "fjK84$%kgfj$%T\\\\gfFg\\gsdgf\\fgSy----------dfdf" - -Windows (UTF16 wchar_t) - 4 ns | wcscmp - 67 ns | CompareStringOrdinalFunc+ + bIgnoreCase -314 ns | LCMapString + wmemcmp - -OS X (UTF8 char) - 6 ns | strcmp - 98 ns | strcasecmp - 120 ns | strncasecmp + std::min(sizeLhs, sizeRhs); - 856 ns | CFStringCreateWithCString + CFStringCompare(kCFCompareCaseInsensitive) -1110 ns | CFStringCreateWithCStringNoCopy + CFStringCompare(kCFCompareCaseInsensitive) -________________________ -time per call | function */ - -int compareNativePath(const Zstring& lhs, const Zstring& rhs) + Perf test: compare strings 10 mio times; 64 bit build + ----------------------------------------------------- + string a = "Fjk84$%kgfj$%T\\\\Gffg\\gsdgf\\fgsx----------d-" + string b = "fjK84$%kgfj$%T\\\\gfFg\\gsdgf\\fgSy----------dfdf" + + Windows (UTF16 wchar_t) + 4 ns | wcscmp + 67 ns | CompareStringOrdinalFunc+ + bIgnoreCase + 314 ns | LCMapString + wmemcmp + + OS X (UTF8 char) + 6 ns | strcmp + 98 ns | strcasecmp + 120 ns | strncasecmp + std::min(sizeLhs, sizeRhs); + 856 ns | CFStringCreateWithCString + CFStringCompare(kCFCompareCaseInsensitive) + 1110 ns | CFStringCreateWithCStringNoCopy + CFStringCompare(kCFCompareCaseInsensitive) + ________________________ + time per call | function */ + +std::weak_ordering compareNativePath(const Zstring& lhs, const Zstring& rhs) { assert(lhs.find(Zchar('\0')) == Zstring::npos); //don't expect embedded nulls! assert(rhs.find(Zchar('\0')) == Zstring::npos); // - return compareString(lhs, rhs); + return lhs <=> rhs; } namespace { -int compareNoCaseUtf8(const char* lhs, size_t lhsLen, const char* rhs, size_t rhsLen) +std::weak_ordering compareNoCaseUtf8(const char* lhs, size_t lhsLen, const char* rhs, size_t rhsLen) { //- strncasecmp implements ASCII CI-comparsion only! => signature is broken for UTF8-input; toupper() similarly doesn't support Unicode //- wcsncasecmp: https://opensource.apple.com/source/Libc/Libc-763.12/string/wcsncasecmp-fbsd.c @@ -150,7 +150,7 @@ int compareNoCaseUtf8(const char* lhs, size_t lhsLen, const char* rhs, size_t rh const std::optional cpL = decL.getNext(); const std::optional cpR = decR.getNext(); if (!cpL || !cpR) - return static_cast(!cpR) - static_cast(!cpL); + return !cpR <=> !cpL; static_assert(sizeof(gunichar) == sizeof(impl::CodePoint)); @@ -158,14 +158,13 @@ int compareNoCaseUtf8(const char* lhs, size_t lhsLen, const char* rhs, size_t rh const gunichar charR = ::g_unichar_toupper(*cpR); //e.g. "Σ" (upper case) can be lower-case "ς" in the end of the word or "σ" in the middle. if (charL != charR) //ordering: "to lower" converts to higher code points than "to upper" - return static_cast(charL) - static_cast(charR); //unsigned char-comparison is the convention! - //unsigned underflow is well-defined! + return makeUnsigned(charL) <=> makeUnsigned(charR); //unsigned char-comparison is the convention! } } } -int compareNatural(const Zstring& lhs, const Zstring& rhs) +std::weak_ordering compareNatural(const Zstring& lhs, const Zstring& rhs) { //Unicode normal forms: // Windows: CompareString() already ignores NFD/NFC differences: nice... @@ -192,13 +191,13 @@ int compareNatural(const Zstring& lhs, const Zstring& rhs) for (;;) { if (strL == strEndL || strR == strEndR) - return static_cast(strL != strEndL) - static_cast(strR != strEndR); //"nothing" before "something" + return (strL != strEndL) <=> (strR != strEndR); //"nothing" before "something" //note: "something" never would have been condensed to "nothing" further below => can finish evaluation here const bool wsL = isWhiteSpace(*strL); const bool wsR = isWhiteSpace(*strR); if (wsL != wsR) - return static_cast(!wsL) - static_cast(!wsR); //whitespace before non-ws! + return !wsL <=> !wsR; //whitespace before non-ws! if (wsL) { ++strL, ++strR; @@ -210,7 +209,7 @@ int compareNatural(const Zstring& lhs, const Zstring& rhs) const bool digitL = isDigit(*strL); const bool digitR = isDigit(*strR); if (digitL != digitR) - return static_cast(!digitL) - static_cast(!digitR); //number before chars! + return !digitL <=> !digitR; //numbers before chars! if (digitL) { while (strL != strEndL && *strL == '0') ++strL; @@ -222,7 +221,7 @@ int compareNatural(const Zstring& lhs, const Zstring& rhs) const bool endL = strL == strEndL || !isDigit(*strL); const bool endR = strR == strEndR || !isDigit(*strR); if (endL != endR) - return static_cast(!endL) - static_cast(!endR); //more digits means bigger number + return !endL <=> !endR; //more digits means bigger number if (endL) break; //same number of digits @@ -230,7 +229,7 @@ int compareNatural(const Zstring& lhs, const Zstring& rhs) rv = *strL - *strR; //found first digit difference comparing from left } if (rv != 0) - return rv; + return rv <=> 0; continue; } @@ -240,9 +239,9 @@ int compareNatural(const Zstring& lhs, const Zstring& rhs) while (strL != strEndL && !isWhiteSpace(*strL) && !isDigit(*strL)) ++strL; while (strR != strEndR && !isWhiteSpace(*strR) && !isDigit(*strR)) ++strR; - const int rv = compareNoCaseUtf8(textBeginL, strL - textBeginL, textBeginR, strR - textBeginR); - if (rv != 0) - return rv; + if (const std::weak_ordering cmp = compareNoCaseUtf8(textBeginL, strL - textBeginL, textBeginR, strR - textBeginR); + std::is_neq(cmp)) + return cmp; } } diff --git a/zen/zstring.h b/zen/zstring.h index 607d3859..09aa43b9 100644 --- a/zen/zstring.h +++ b/zen/zstring.h @@ -33,9 +33,9 @@ Zstring getUpperCase(const Zstring& str); //Windows, Linux: precomposed //macOS: decomposed Zstring getUnicodeNormalForm(const Zstring& str); -// "In fact, Unicode declares that there is an equivalence relationship between decomposed and composed sequences, -// and conformant software should not treat canonically equivalent sequences, whether composed or decomposed or something in between, as different." -// https://www.win.tue.nl/~aeb/linux/uc/nfc_vs_nfd.html +/* "In fact, Unicode declares that there is an equivalence relationship between decomposed and composed sequences, + and conformant software should not treat canonically equivalent sequences, whether composed or decomposed or something in between, as different." + https://www.win.tue.nl/~aeb/linux/uc/nfc_vs_nfd.html */ struct LessUnicodeNormal { bool operator()(const Zstring& lhs, const Zstring& rhs) const { return getUnicodeNormalForm(lhs) < getUnicodeNormalForm(rhs); } }; @@ -55,20 +55,20 @@ struct ZstringNoCase //use as STL container key: avoid needless upper-case conve //------------------------------------------------------------------------------------------ -//Compare *local* file paths: -// Windows: igore case -// Linux: byte-wise comparison -// macOS: ignore case + Unicode normalization forms -int compareNativePath(const Zstring& lhs, const Zstring& rhs); +/* Compare *local* file paths: + Windows: igore case + Linux: byte-wise comparison + macOS: ignore case + Unicode normalization forms */ +std::weak_ordering compareNativePath(const Zstring& lhs, const Zstring& rhs); -inline bool equalNativePath(const Zstring& lhs, const Zstring& rhs) { return compareNativePath(lhs, rhs) == 0; } +inline bool equalNativePath(const Zstring& lhs, const Zstring& rhs) { return std::is_eq(compareNativePath(lhs, rhs)); } -struct LessNativePath { bool operator()(const Zstring& lhs, const Zstring& rhs) const { return compareNativePath(lhs, rhs) < 0; } }; +struct LessNativePath { bool operator()(const Zstring& lhs, const Zstring& rhs) const { return std::is_lt(compareNativePath(lhs, rhs)); } }; //------------------------------------------------------------------------------------------ -int compareNatural(const Zstring& lhs, const Zstring& rhs); +std::weak_ordering compareNatural(const Zstring& lhs, const Zstring& rhs); -struct LessNaturalSort { bool operator()(const Zstring& lhs, const Zstring& rhs) const { return compareNatural(lhs, rhs) < 0; } }; +struct LessNaturalSort { bool operator()(const Zstring& lhs, const Zstring& rhs) const { return std::is_lt(compareNatural(lhs, rhs)); } }; //------------------------------------------------------------------------------------------ -- cgit