From a2d8585c8e7b89ca276447783c93866fb76a3b6c Mon Sep 17 00:00:00 2001 From: B Stack Date: Sun, 17 May 2020 19:16:44 -0400 Subject: ffs 10.24 dpkg rc1 (gtk3) update most patches for minor syntax changes. Add major patch to revert new Zenju aggressive upstreamisms. --- .../revert_zenju_aggressive_upstreamisms.patch | 275 +++++++++++++++++++++ 1 file changed, 275 insertions(+) create mode 100644 freefilesync/debian/patches/revert_zenju_aggressive_upstreamisms.patch (limited to 'freefilesync/debian/patches/revert_zenju_aggressive_upstreamisms.patch') diff --git a/freefilesync/debian/patches/revert_zenju_aggressive_upstreamisms.patch b/freefilesync/debian/patches/revert_zenju_aggressive_upstreamisms.patch new file mode 100644 index 0000000..0da4e06 --- /dev/null +++ b/freefilesync/debian/patches/revert_zenju_aggressive_upstreamisms.patch @@ -0,0 +1,275 @@ +Author: Ben Stack +Date: 2020-05-17 14:11 -0400 +Message: Use the following command to get this old contents. Zenju must be using some newer definition of -std=c++2a than what Devuan Ceres provides as of 2020-05-17, and probably wxwidgets. This is the 10.23 code for these files. + + git checkout b4ecf755 zen/legacy_compiler.h zen/string_base.h wx+/choice_enum.h + +Unfortunately with the removal of the wxWidgets-gtk2 code from Debian, we are stuck using all available at approximately November 1, 2019 snapshot of Debian: https://snapshot.debian.org/archive/debian/20191101T211023Z/pool/main/w/wxwidgets3.0/ +libwxbase3.0-0v5_3.0.4+dfsg-14_amd64.deb +libwxbase3.0-0v5_3.0.4+dfsg-14_i386.deb +libwxbase3.0-dev_3.0.4+dfsg-14_amd64.deb +libwxbase3.0-dev_3.0.4+dfsg-14_i386.deb +libwxgtk3.0-0v5_3.0.4+dfsg-14_amd64.deb +libwxgtk3.0-0v5_3.0.4+dfsg-14_i386.deb +libwxgtk3.0-dev_3.0.4+dfsg-14_amd64.deb +libwxgtk3.0-dev_3.0.4+dfsg-14_i386.deb +wx3.0-headers_3.0.4+dfsg-14_all.deb +wx-common_3.0.4+dfsg-14_amd64.deb +wx-common_3.0.4+dfsg-14_i386.deb +diff -x '*.rej' -x '*.orig' -x '*.git*' -Naur 10.24-0/zen/legacy_compiler.h 10.24-1/zen/legacy_compiler.h +--- 10.24-0/zen/legacy_compiler.h 2020-05-17 13:44:27.542140458 -0400 ++++ 10.24-1/zen/legacy_compiler.h 2020-05-17 14:07:49.115166339 -0400 +@@ -7,9 +7,6 @@ + #ifndef LEGACY_COMPILER_H_839567308565656789 + #define LEGACY_COMPILER_H_839567308565656789 + +- #include //C++20 +- +- #include //requires C++20 + + + +@@ -21,8 +18,53 @@ + + //--------------------------------------------------------------------------------- + ++#if __cpp_lib_span ++ #error get rid of workaround: ++#endif ++ ++template ++class span ++{ ++public: ++ template ++ span(Iterator first, Iterator last) : size_(last - first), data_(first != last ? &*first : nullptr) {} ++ ++ template ++ span(Container& cont) : span(cont.begin(), cont.end()) {} ++ ++ using iterator = T*; ++ using const_iterator = const T*; ++ ++ iterator begin() { return data_; } ++ iterator end () { return data_ + size_; } ++ ++ const_iterator begin() const { return data_; } ++ const_iterator end () const { return data_ + size_; } + ++ const_iterator cbegin() const { return begin(); } ++ const_iterator cend () const { return end (); } + ++ T* data() const { return data_; } ++ size_t size() const { return size_; } ++ bool empty() const { return size_ == 0; } ++ ++private: ++ const size_t size_; ++ T* const data_; ++}; ++ ++ ++#if __cpp_lib_math_constants ++ #error get rid of workaround: ++#endif ++ ++namespace numbers ++{ ++const double pi = 3.14159265358979323846; ++const double e = 2.71828182845904523536; ++const double sqrt2 = 1.41421356237309504880; ++const double ln2 = 0.693147180559945309417; ++} + } + + +diff -x '*.rej' -x '*.orig' -x '*.git*' -Naur 10.24-0/zen/string_base.h 10.24-1/zen/string_base.h +--- 10.24-0/zen/string_base.h 2020-05-17 13:44:27.554140569 -0400 ++++ 10.24-1/zen/string_base.h 2020-05-17 14:09:44.164244361 -0400 +@@ -12,7 +12,9 @@ + #include + #include + #include "string_tools.h" ++#if __cpp_impl_three_way_comparison && __cpp_lib_three_way_comparison + #include ++#endif + + + //Zbase - a policy based string class optimizing performance and flexibility +@@ -293,15 +295,29 @@ + }; + + ++#if __cpp_impl_three_way_comparison && __cpp_lib_three_way_comparison ++ #error implement! ++#endif ++ + + template class SP> bool operator==(const Zbase& lhs, const Zbase& rhs); + template class SP> bool operator==(const Zbase& lhs, const Char* rhs); + template class SP> inline bool operator==(const Char* lhs, const Zbase& rhs) { return operator==(rhs, lhs); } + ++#if __cpp_impl_three_way_comparison && __cpp_lib_three_way_comparison + template class SP> std::strong_ordering operator<=>(const Zbase& lhs, const Zbase& rhs); + 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); + ++#else ++template class SP> inline bool operator!=(const Zbase& lhs, const Zbase& rhs) { return !operator==(lhs, rhs); } ++template class SP> inline bool operator!=(const Zbase& lhs, const Char* rhs) { return !operator==(lhs, rhs); } ++template class SP> inline bool operator!=(const Char* lhs, const Zbase& rhs) { return !operator==(lhs, rhs); } ++ ++template class SP> bool operator<(const Zbase& lhs, const Zbase& rhs); ++template class SP> bool operator<(const Zbase& lhs, const Char* rhs); ++template class SP> bool operator<(const Char* lhs, const Zbase& rhs); ++#endif + + 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; } +@@ -482,11 +498,12 @@ + } + + ++#if __cpp_impl_three_way_comparison && __cpp_lib_three_way_comparison + template class SP> inline + std::strong_ordering operator<=>(const Zbase& lhs, const Zbase& rhs) + { +- return std::lexicographical_compare_three_way(lhs.begin(), lhs.end(), //respect embedded 0 +- rhs.begin(), rhs.end()); // ++ return std::lexicographical_compare_three_way(lhs.begin(), lhs.end(), //respect embedded 0 ++ rhs.begin(), rhs.end()); + } + + +@@ -501,11 +518,35 @@ + template class SP> inline + std::strong_ordering operator<=>(const Char* lhs, const Zbase& rhs) + { +- return std::lexicographical_compare_three_way(lhs, lhs + strLength(lhs), +- rhs.begin(), rhs.end()); //respect embedded 0 ++ return std::lexicographical_compare_three_way(lhs, lhs + strLength(lhs), //respect embedded 0 ++ rhs.begin(), rhs.end()); ++} ++ ++#else ++template class SP> inline ++bool operator<(const Zbase& lhs, const Zbase& rhs) ++{ ++ return std::lexicographical_compare(lhs.begin(), lhs.end(), //respect embedded 0 ++ rhs.begin(), rhs.end()); + } + + ++template class SP> inline ++bool operator<(const Zbase& lhs, const Char* rhs) ++{ ++ return std::lexicographical_compare(lhs.begin(), lhs.end(), //respect embedded 0 ++ rhs, rhs + strLength(rhs)); ++} ++ ++ ++template class SP> inline ++bool operator<(const Char* lhs, const Zbase& rhs) ++{ ++ return std::lexicographical_compare(lhs, lhs + strLength(lhs), //respect embedded 0 ++ rhs.begin(), rhs.end()); ++} ++#endif ++ + + template class SP> inline + size_t Zbase::length() const +diff -x '*.rej' -x '*.orig' -x '*.git*' -Naur 10.24-0/wx+/choice_enum.h 10.24-1/wx+/choice_enum.h +--- 10.24-0/wx+/choice_enum.h 2020-05-17 18:30:59.441499418 -0400 ++++ 10.24-1/wx+/choice_enum.h 2020-05-17 18:53:59.893685507 -0400 +@@ -7,7 +7,6 @@ + #ifndef CHOICE_ENUM_H_132413545345687 + #define CHOICE_ENUM_H_132413545345687 + +-#include + #include + #include + +@@ -44,11 +43,8 @@ + descrList.push_back({ value, { text, tooltip } }); + return *this; + } +- + using DescrList = std::vector>>; + DescrList descrList; +- +- std::unordered_map> itemsSetLast; + }; + template void setEnumVal(const EnumDescrList& mapping, wxChoice& ctrl, Enum value); + template Enum getEnumVal(const EnumDescrList& mapping, const wxChoice& ctrl); +@@ -69,34 +65,26 @@ + + //--------------- impelementation ------------------------------------------- + template +-void setEnumVal(EnumDescrList& mapping, wxChoice& ctrl, Enum value) ++void setEnumVal(const EnumDescrList& mapping, wxChoice& ctrl, Enum value) + { +- auto& itemsSetLast = mapping.itemsSetLast[&ctrl]; ++ ctrl.Clear(); + +- std::vector items; ++ int selectedPos = 0; + for (auto it = mapping.descrList.begin(); it != mapping.descrList.end(); ++it) +- items.push_back(it->second.first); +- +- if (items != itemsSetLast) + { +- ctrl.Set(items); //expensive as fuck! => only call when absolutely needed! +- itemsSetLast = std::move(items); ++ ctrl.Append(it->second.first); ++ if (it->first == value) ++ { ++ selectedPos = it - mapping.descrList.begin(); ++ ++ if (it->second.second.empty()) ++ ctrl.UnsetToolTip(); ++ else ++ ctrl.SetToolTip(it->second.second); ++ } + } +- //----------------------------------------------------------------- +- +- const auto it = std::find_if(mapping.descrList.begin(), mapping.descrList.end(), [&](const auto& mapItem) { return mapItem.first == value; }); +- if (it != mapping.descrList.end()) +- { +- if (const wxString& tooltip = it->second.second; +- !tooltip.empty()) +- ctrl.SetToolTip(tooltip); +- else +- ctrl.UnsetToolTip(); + +- const int selectedPos = it - mapping.descrList.begin(); +- ctrl.SetSelection(selectedPos); +- } +- else assert(false); ++ ctrl.SetSelection(selectedPos); + } + + template +@@ -115,17 +103,11 @@ + + template void updateTooltipEnumVal(const EnumDescrList& mapping, wxChoice& ctrl) + { +- const int selectedPos = ctrl.GetSelection(); ++ const Enum currentValue = getEnumVal(mapping, ctrl); + +- if (0 <= selectedPos && selectedPos < static_cast(mapping.descrList.size())) +- { +- if (const auto& [text, tooltip] = mapping.descrList[selectedPos].second; +- !tooltip.empty()) +- ctrl.SetToolTip(tooltip); +- else +- ctrl.UnsetToolTip(); +- } +- else assert(false); ++ for (const auto& [enumValue, textAndTooltip] : mapping.descrList) ++ if (currentValue == enumValue) ++ ctrl.SetToolTip(textAndTooltip.second); + } + } + -- cgit