Update Catch to v1.12.2 with latest bugfixes

It solves compilation errors with GCC 11.3 on Ubuntu 22.04

extlibs/headers/catch.hpp

@@ -1,6 +1,6 @@
 /*
  *  Catch v1.12.2
- *  Generated: 2018-05-14 15:10:01.112442
+ *  Generated: 2022-12-21 23:22:34.433382
  *  ----------------------------------------------------------
  *  This file has been merged from multiple headers. Please don't edit it directly
  *  Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved.
@@ -214,7 +214,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // Use variadic macros if the compiler supports them
-#if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \
+#if ( defined _MSC_VER && _MSC_VER >= 1400 && !defined __EDGE__) || \
     ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \
     ( defined __GNUC__ && __GNUC__ >= 3 ) || \
     ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L )
@@ -2129,6 +2129,9 @@ namespace Catch{
         #define CATCH_TRAP() \
                 __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
                 : : : "memory","r0","r3","r4" ) /* NOLINT */
+    #elif defined(__aarch64__)
+        // Backport of https://github.com/catchorg/Catch2/commit/a25c1a24af8bffd35727a888a307ff0280cf9387
+        #define CATCH_TRAP() __asm__(".inst 0xd4200000")
     #else
         #define CATCH_TRAP() __asm__("int $3\n" : : /* NOLINT */ )
     #endif
@@ -6392,9 +6395,12 @@ CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
 // #included from: catch_fatal_condition.hpp
 #define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED
 
+#include <cassert>
+#include <stdexcept>
+
 namespace Catch {
 
-    // Report the error condition
+    //! Signals fatal error message to the run context
     inline void reportFatal( std::string const& message ) {
         IContext& context = Catch::getCurrentContext();
         IResultCapture* resultCapture = context.getResultCapture();
@@ -6432,8 +6438,31 @@ namespace Catch {
 #  if !defined ( CATCH_CONFIG_WINDOWS_SEH )
 
 namespace Catch {
-    struct FatalConditionHandler {
+    class FatalConditionHandler {
-        void reset() {}
+        bool m_started = false;
+
+        // Install/disengage implementation for specific platform.
+        // Should be if-defed to work on current platform, can assume
+        // engage-disengage 1:1 pairing.
+        void engage_platform() {}
+        void disengage_platform() {}
+
+    public:
+        // Should also have platform-specific implementations as needed
+        FatalConditionHandler() {}
+        ~FatalConditionHandler() {}
+
+        void engage() {
+            assert(!m_started && "Handler cannot be installed twice.");
+            m_started = true;
+            engage_platform();
+        }
+
+        void disengage() {
+            assert(m_started && "Handler cannot be uninstalled without being installed first");
+            m_started = false;
+            disengage_platform();
+        }
     };
 }
 
@@ -6453,53 +6482,72 @@ namespace Catch {
         { EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" },
     };
 
-    struct FatalConditionHandler {
+    static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
-
+        for (int i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
-        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
+            if (ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) {
-            for (int i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
+                reportFatal(signalDefs[i].name);
-                if (ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) {
-                    reportFatal(signalDefs[i].name);
-                }
             }
-            // If its not an exception we care about, pass it along.
-            // This stops us from eating debugger breaks etc.
-            return EXCEPTION_CONTINUE_SEARCH;
         }
+        // If its not an exception we care about, pass it along.
+        // This stops us from eating debugger breaks etc.
+        return EXCEPTION_CONTINUE_SEARCH;
+    }
 
-        FatalConditionHandler() {
+    // Since we do not support multiple instantiations, we put these
-            isSet = true;
+    // into global variables and rely on cleaning them up in outlined
-            // 32k seems enough for Catch to handle stack overflow,
+    // constructors/destructors
-            // but the value was found experimentally, so there is no strong guarantee
+    static PVOID exceptionHandlerHandle = CATCH_NULL;
-            guaranteeSize = 32 * 1024;
+
-            exceptionHandlerHandle = CATCH_NULL;
+    class FatalConditionHandler {
+        bool m_started = false;
+
+        // Install/disengage implementation for specific platform.
+        // Should be if-defed to work on current platform, can assume
+        // engage-disengage 1:1 pairing.
+
+        void engage_platform() {
             // Register as first handler in current chain
             exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
-            // Pass in guarantee size to be filled
+            if (!exceptionHandlerHandle) {
-            SetThreadStackGuarantee(&guaranteeSize);
+                throw std::runtime_error("Could not register vectored exception handler");
-        }
-
-        static void reset() {
-            if (isSet) {
-                // Unregister handler and restore the old guarantee
-                RemoveVectoredExceptionHandler(exceptionHandlerHandle);
-                SetThreadStackGuarantee(&guaranteeSize);
-                exceptionHandlerHandle = CATCH_NULL;
-                isSet = false;
             }
         }
 
-        ~FatalConditionHandler() {
+        void disengage_platform() {
-            reset();
+            if (!RemoveVectoredExceptionHandler(exceptionHandlerHandle)) {
+                throw std::runtime_error("Could not unregister vectored exception handler");
+            }
+            exceptionHandlerHandle = CATCH_NULL;
         }
-    private:
-        static bool isSet;
-        static ULONG guaranteeSize;
-        static PVOID exceptionHandlerHandle;
-    };
 
-    bool FatalConditionHandler::isSet = false;
+    public:
-    ULONG FatalConditionHandler::guaranteeSize = 0;
+        FatalConditionHandler() {
-    PVOID FatalConditionHandler::exceptionHandlerHandle = CATCH_NULL;
+            ULONG guaranteeSize = static_cast<ULONG>(32 * 1024);
+            if (!SetThreadStackGuarantee(&guaranteeSize)) {
+                // We do not want to fully error out, because needing
+                // the stack reserve should be rare enough anyway.
+                Catch::cerr()
+                    << "Failed to reserve piece of stack."
+                    << " Stack overflows will not be reported successfully.";
+            }
+        }
+
+        // We do not attempt to unset the stack guarantee, because
+        // Windows does not support lowering the stack size guarantee.
+        ~FatalConditionHandler() {}
+
+        void engage() {
+            assert(!m_started && "Handler cannot be installed twice.");
+            m_started = true;
+            engage_platform();
+        }
+
+        void disengage() {
+            assert(m_started && "Handler cannot be uninstalled without being installed first");
+            m_started = false;
+            disengage_platform();
+        }
+    };
 
 } // namespace Catch
 
@@ -6510,8 +6558,31 @@ namespace Catch {
 #  if !defined(CATCH_CONFIG_POSIX_SIGNALS)
 
 namespace Catch {
-    struct FatalConditionHandler {
+    class FatalConditionHandler {
-        void reset() {}
+        bool m_started = false;
+
+        // Install/disengage implementation for specific platform.
+        // Should be if-defed to work on current platform, can assume
+        // engage-disengage 1:1 pairing.
+        void engage_platform() {}
+        void disengage_platform() {}
+
+    public:
+        // Should also have platform-specific implementations as needed
+        FatalConditionHandler() {}
+        ~FatalConditionHandler() {}
+
+        void engage() {
+            assert(!m_started && "Handler cannot be installed twice.");
+            m_started = true;
+            engage_platform();
+        }
+
+        void disengage() {
+            assert(m_started && "Handler cannot be uninstalled without being installed first");
+            m_started = false;
+            disengage_platform();
+        }
     };
 }
 
@@ -6535,29 +6606,56 @@ namespace Catch {
             { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
     };
 
-    struct FatalConditionHandler {
+// Older GCCs trigger -Wmissing-field-initializers for T foo = {}
+// which is zero initialization, but not explicit. We want to avoid
+// that.
+#if defined(__GNUC__)
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
 
-        static bool isSet;
+    static char* altStackMem = CATCH_NULL;
-        static struct sigaction oldSigActions [sizeof(signalDefs)/sizeof(SignalDefs)];
+    static std::size_t altStackSize = 0;
-        static stack_t oldSigStack;
+    static stack_t oldSigStack;
-        static char altStackMem[SIGSTKSZ];
+    static struct sigaction oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)];
 
-        static void handleSignal( int sig ) {
+    static void restorePreviousSignalHandlers() {
-            std::string name = "<unknown signal>";
+        // We set signal handlers back to the previous ones. Hopefully
-            for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
+        // nobody overwrote them in the meantime, and doesn't expect
-                SignalDefs &def = signalDefs[i];
+        // their signal handlers to live past ours given that they
-                if (sig == def.id) {
+        // installed them after ours..
-                    name = def.name;
+        for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
-                    break;
+            sigaction(signalDefs[i].id, &oldSigActions[i], CATCH_NULL);
-                }
-            }
-            reset();
-            reportFatal(name);
-            raise( sig );
         }
+        // Return the old stack
+        sigaltstack(&oldSigStack, CATCH_NULL);
+    }
 
-        FatalConditionHandler() {
+    static void handleSignal( int sig ) {
-            isSet = true;
+        char const * name = "<unknown signal>";
+        for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
+            SignalDefs &def = signalDefs[i];
+            if (sig == def.id) {
+                name = def.name;
+                break;
+            }
+        }
+        // We need to restore previous signal handlers and let them do
+        // their thing, so that the users can have the debugger break
+        // when a signal is raised, and so on.
+        restorePreviousSignalHandlers();
+        reportFatal( name );
+        raise( sig );
+    }
+
+    class FatalConditionHandler {
+        bool m_started = false;
+
+        // Install/disengage implementation for specific platform.
+        // Should be if-defed to work on current platform, can assume
+        // engage-disengage 1:1 pairing.
+
+        void engage_platform() {
             stack_t sigStack;
             sigStack.ss_sp = altStackMem;
             sigStack.ss_size = SIGSTKSZ;
@@ -6572,26 +6670,42 @@ namespace Catch {
             }
         }
 
-        ~FatalConditionHandler() {
+        void disengage_platform() {
-            reset();
+            restorePreviousSignalHandlers();
         }
-        static void reset() {
+
-            if( isSet ) {
+    public:
-                // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
+        FatalConditionHandler() {
-                for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
+            assert(!altStackMem && "Cannot initialize POSIX signal handler when one already exists");
-                    sigaction(signalDefs[i].id, &oldSigActions[i], CATCH_NULL);
+            if (altStackSize == 0) {
-                }
+                altStackSize = SIGSTKSZ;
-                // Return the old stack
-                sigaltstack(&oldSigStack, CATCH_NULL);
-                isSet = false;
             }
+            altStackMem = new char[altStackSize]();
+        }
+
+        ~FatalConditionHandler() {
+            delete[] altStackMem;
+            // We signal that another instance can be constructed by zeroing
+            // out the pointer.
+            altStackMem = CATCH_NULL;
+        }
+
+        void engage() {
+            assert(!m_started && "Handler cannot be installed twice.");
+            m_started = true;
+            engage_platform();
+        }
+
+        void disengage() {
+            assert(m_started && "Handler cannot be uninstalled without being installed first");
+            m_started = false;
+            disengage_platform();
         }
     };
 
-    bool FatalConditionHandler::isSet = false;
+#if defined(__GNUC__)
-    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
+#    pragma GCC diagnostic pop
-    stack_t FatalConditionHandler::oldSigStack = {};
+#endif
-    char FatalConditionHandler::altStackMem[SIGSTKSZ] = {};
 
 } // namespace Catch
 
@@ -6599,6 +6713,23 @@ namespace Catch {
 
 #endif // not Windows
 
+namespace Catch {
+
+    //! Simple RAII guard for (dis)engaging the FatalConditionHandler
+    class FatalConditionHandlerGuard {
+        FatalConditionHandler* m_handler;
+    public:
+        FatalConditionHandlerGuard(FatalConditionHandler* handler):
+            m_handler(handler) {
+            m_handler->engage();
+        }
+        ~FatalConditionHandlerGuard() {
+            m_handler->disengage();
+        }
+    };
+
+} // end namespace Catch
+
 #include <cassert>
 #include <set>
 #include <string>
@@ -6938,9 +7069,8 @@ namespace Catch {
         }
 
         void invokeActiveTestCase() {
-            FatalConditionHandler fatalConditionHandler; // Handle signals
+            FatalConditionHandlerGuard _(&m_fatalConditionhandler);
             m_activeTestCase->invoke();
-            fatalConditionHandler.reset();
         }
 
     private:
@@ -6978,6 +7108,7 @@ namespace Catch {
         std::vector<SectionEndInfo> m_unfinishedSections;
         std::vector<ITracker*> m_activeSections;
         TrackerContext m_trackerContext;
+        FatalConditionHandler m_fatalConditionhandler;
         size_t m_prevPassed;
         bool m_shouldReportUnexpected;
     };