Make Audacity build in C++17 ...

... Fixing many conditional operators with explicit construction of wxString
instead of simple string literals;

And fixing allocation of more strictly aligned structures on Mac, without need
for 10.14 as the minimum SDK, by means of some class-specific operators new
and delete.

libraries/lib-utility/MemoryX.cpp

@@ -1,5 +1,58 @@
+/**********************************************************************
+ 
+ Audacity: A Digital Audio Editor
+ 
+ MemoryX.cpp
+ 
+ Paul Licameli
+ 
+ **********************************************************************/
+
 #include "MemoryX.h"
 
 // Make the symbol table non-empty
 UTILITY_API void lib_utility_dummy_symbol()
 {}
+
+#ifdef __APPLE__
+
+constexpr auto sizeof_align_val = sizeof(std::align_val_t);
+
+void *NonInterferingBase::operator new(std::size_t count, std::align_val_t al)
+{
+   using namespace std;
+   // Get an allocation with sufficient extra space to remember the alignment
+   // (And to do that, adjust the alignment to be not less than the alignment of
+   // an alignment value!).
+   // Also increase the allocation by one entire alignment.
+   al = max( al, static_cast<align_val_t>( alignof(align_val_t) ) );
+   const auto al_as_size = static_cast<size_t>(al);
+   auto ptr = static_cast<char*>(
+      ::operator new( count + sizeof_align_val + al_as_size ) );
+
+   // Adjust the pointer to a properly aligned one, with a space just before it
+   // to remember the adjustment
+   ptr += sizeof_align_val;
+   auto integer = reinterpret_cast<uintptr_t>(ptr);
+   const auto partial = integer % al_as_size;
+   auto adjustment = partial ? al_as_size - partial : 0;
+   integer += adjustment;
+   ptr = reinterpret_cast<char*>(integer);
+
+   // Remember the adjustment
+   *(reinterpret_cast<size_t*>(ptr) - 1) = adjustment;
+
+   return ptr;
+}
+
+void NonInterferingBase::operator delete(void *ptr, std::align_val_t al)
+{
+   // Find the adjustment
+   auto adjustment = *(reinterpret_cast<size_t*>(ptr) - 1);
+   // Apply the adjustment
+   auto p = reinterpret_cast<char*>(ptr) - adjustment - sizeof_align_val;
+   // Call through to default operator
+   ::operator delete(p);
+}
+
+#endif

libraries/lib-utility/MemoryX.h

@@ -4,6 +4,7 @@
 // C++ standard header <memory> with a few extensions
 #include <iterator>
 #include <memory>
+#include <new> // align_val_t and hardware_destructive_interference_size
 #include <cstdlib> // Needed for free.
 #ifndef safenew
 #define safenew new
@@ -579,6 +580,36 @@ OutContainer transform_container( InContainer &inContainer, Function &&fn )
       inContainer.begin(), inContainer.end(), fn );
 }
 
+//! Non-template helper for class template NonInterfering
+/*!
+ If a structure contains any members with large alignment, this base class may also allow it to work in
+ macOS builds under current limitations of the C++17 standard implementation.
+ */
+struct UTILITY_API alignas(
+#ifdef __WIN32__
+   std::hardware_destructive_interference_size
+#else
+   // That constant isn't defined for the other builds yet
+   64 /* ? */
+#endif
+)
+NonInterferingBase {
+#ifdef __APPLE__
+   static void *operator new(std::size_t count, std::align_val_t al);
+   static void operator delete(void *ptr, std::align_val_t al);
+#endif
+};
+
+/*! Given a structure type T, derive a structure with sufficient padding so that there is not false sharing of
+ cache lines between successive elements of an array of those structures.
+ */
+template< typename T > struct NonInterfering
+   : NonInterferingBase // Inherit operators; use empty base class optimization
+   , T
+{
+   using T::T;
+};
+
 // These macros are used widely, so declared here.
 #define QUANTIZED_TIME(time, rate) (floor(((double)(time) * (rate)) + 0.5) / (rate))
 // dB - linear amplitude conversions