From a89fe1060bbaf68edba17520c36052d51f31d56b Mon Sep 17 00:00:00 2001 From: Denis 'GNUtoo' Carikli Date: Mon, 8 May 2023 15:04:48 +0200 Subject: [PATCH] gnu: cpp-mustache: fix build with newer glibc * gnu/packages/cpp.scm (cpp-mustache)[source]: Add patch. * gnu/packages/patches/cpp-mustache-update-catch2-library.patch: New file. * gnu/packages/patches/cpp-mustache-remove-unused-variables.patch: New file. * gnu/local.mk (dist_patch_DATA): Add patches. Signed-off-by: Denis 'GNUtoo' Carikli --- gnu/local.mk | 2 + gnu/packages/cpp.scm | 6 +- ...cpp-mustache-remove-unused-variables.patch | 37 + .../cpp-mustache-update-catch2-library.patch | 26903 ++++++++++++++++ 4 files changed, 26947 insertions(+), 1 deletion(-) create mode 100644 gnu/packages/patches/cpp-mustache-remove-unused-variables.patch create mode 100644 gnu/packages/patches/cpp-mustache-update-catch2-library.patch diff --git a/gnu/local.mk b/gnu/local.mk index dde0af9537..b8f6975dec 100644 --- a/gnu/local.mk +++ b/gnu/local.mk @@ -1018,6 +1018,8 @@ dist_patch_DATA = \ %D%/packages/patches/cool-retro-term-wctype.patch \ %D%/packages/patches/coreutils-gnulib-tests.patch \ %D%/packages/patches/coq-fix-envvars.patch \ + %D%/packages/patches/cpp-mustache-update-catch2-library.patch \ + %D%/packages/patches/cpp-mustache-remove-unused-variables.patch \ %D%/packages/patches/cppcheck-disable-char-signedness-test.patch \ %D%/packages/patches/cpuinfo-system-libraries.patch \ %D%/packages/patches/cpulimit-with-glib-2.32.patch \ diff --git a/gnu/packages/cpp.scm b/gnu/packages/cpp.scm index 023d1c0337..ab881c9748 100644 --- a/gnu/packages/cpp.scm +++ b/gnu/packages/cpp.scm @@ -2024,7 +2024,11 @@ (define-public cpp-mustache (file-name (git-file-name name version)) (sha256 (base32 - "0r9rbk6v1wpld2ismfsk2lkhbyv3dkf0p03hkjivbj05qkfhvlbb")))) + "0r9rbk6v1wpld2ismfsk2lkhbyv3dkf0p03hkjivbj05qkfhvlbb"))) + (patches + (search-patches + "cpp-mustache-update-catch2-library.patch" + "cpp-mustache-remove-unused-variables.patch"))) (build-system cmake-build-system) (arguments (list #:phases diff --git a/gnu/packages/patches/cpp-mustache-remove-unused-variables.patch b/gnu/packages/patches/cpp-mustache-remove-unused-variables.patch new file mode 100644 index 0000000000..1015f1f44c --- /dev/null +++ b/gnu/packages/patches/cpp-mustache-remove-unused-variables.patch @@ -0,0 +1,37 @@ +From: Kevin Wojniak +Subject: Remove unused variables. +Without that fix tests.cpp fail to build in Guix with the following errors: +error: unused variable ‘stream’ [-Werror=unused-variable] +error: unused variable ‘root_children’ [-Werror=unused-variable] +Forwarded: not-needed +Origin: upstream, +https://github.com/kainjow/Mustache/commit/a790aae190f6744c3abe6a4c8325005377c2b72c +Applied-Upstream: https://github.com/kainjow/Mustache/commit/a790aae190f6744c3abe6a4c8325005377c2b72c +--- + tests.cpp | 3 +-- + 1 file changed, 1 insertion(+), 2 deletions(-) + +diff --git a/tests.cpp b/tests.cpp +index 84b4abe..e013d45 100644 +--- a/tests.cpp ++++ b/tests.cpp +@@ -1158,7 +1158,7 @@ TEST_CASE("custom_context") { + SECTION("basic") { + my_context ctx; + mustache tmpl("Hello {{what}}"); +- std::ostream& stream = tmpl.render(ctx, std::cout) << std::endl; ++ tmpl.render(ctx, std::cout) << std::endl; + CHECK(tmpl.is_valid()); + CHECK(tmpl.error_message() == ""); + CHECK(tmpl.render(ctx) == "Hello Steve"); +@@ -1218,7 +1218,6 @@ TEST_CASE("standalone_lines") { + context_internal context{ctx}; + parser{input, context, root_component, error_message}; + CHECK(error_message.empty()); +- const auto& root_children = root_component.children; + const std::vector text_components{"\n", "\r\n", "\t", " ", "\n", "\n", "\r"}; + REQUIRE(root_component.children.size() == 7); + REQUIRE(root_component.children.size() == text_components.size()); +-- +2.39.1 + diff --git a/gnu/packages/patches/cpp-mustache-update-catch2-library.patch b/gnu/packages/patches/cpp-mustache-update-catch2-library.patch new file mode 100644 index 0000000000..3394522b84 --- /dev/null +++ b/gnu/packages/patches/cpp-mustache-update-catch2-library.patch @@ -0,0 +1,26903 @@ +From: Adrian Stratulat and Kevin Wojniak +Subject: Backport upstream patch to fix compilation with newer glibc. +I (Denis Carikli) made this patch was made by combining the +c54b11840371fe7deea2af9668a29c2d67129b3f and +a35c69ed5dba7bce7e91de7a0028da1e5258b759 patch to update the catch2 library. +Forwarded: not-needed +Origin: upstream, +https://github.com/kainjow/Mustache/commit/c54b11840371fe7deea2af9668a29c2d67129b3f, +https://github.com/kainjow/Mustache/commit/a35c69ed5dba7bce7e91de7a0028da1e5258b759 +Bug: https://github.com/kainjow/Mustache/pull/58 +Applied-Upstream: https://github.com/kainjow/Mustache/commit/c54b11840371fe7deea2af9668a29c2d67129b3f +--- + catch.hpp | 24312 +++++++++++++++++++++++++++++++++------------------- + tests.cpp | 2 +- + 2 files changed, 15292 insertions(+), 9022 deletions(-) + +diff --git a/catch.hpp b/catch.hpp +index fdb046f..7e706f9 100644 +--- a/catch.hpp ++++ b/catch.hpp +@@ -1,17 +1,21 @@ + /* +- * Catch v1.12.2 +- * Generated: 2018-05-14 15:10:01.112442 ++ * Catch v2.13.7 ++ * Generated: 2021-07-28 20:29:27.753164 + * ---------------------------------------------------------- + * This file has been merged from multiple headers. Please don't edit it directly +- * Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved. ++ * Copyright (c) 2021 Two Blue Cubes Ltd. All rights reserved. + * + * Distributed under the Boost Software License, Version 1.0. (See accompanying + * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + */ + #ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED + #define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED ++// start catch.hpp + +-#define TWOBLUECUBES_CATCH_HPP_INCLUDED ++ ++#define CATCH_VERSION_MAJOR 2 ++#define CATCH_VERSION_MINOR 13 ++#define CATCH_VERSION_PATCH 7 + + #ifdef __clang__ + # pragma clang system_header +@@ -19,36 +23,69 @@ + # pragma GCC system_header + #endif + +-// #included from: internal/catch_suppress_warnings.h ++// start catch_suppress_warnings.h + + #ifdef __clang__ + # ifdef __ICC // icpc defines the __clang__ macro + # pragma warning(push) + # pragma warning(disable: 161 1682) + # else // __ICC +-# pragma clang diagnostic ignored "-Wglobal-constructors" +-# pragma clang diagnostic ignored "-Wvariadic-macros" +-# pragma clang diagnostic ignored "-Wc99-extensions" +-# pragma clang diagnostic ignored "-Wunused-variable" + # pragma clang diagnostic push + # pragma clang diagnostic ignored "-Wpadded" +-# pragma clang diagnostic ignored "-Wc++98-compat" +-# pragma clang diagnostic ignored "-Wc++98-compat-pedantic" + # pragma clang diagnostic ignored "-Wswitch-enum" + # pragma clang diagnostic ignored "-Wcovered-switch-default" + # endif + #elif defined __GNUC__ +-# pragma GCC diagnostic ignored "-Wvariadic-macros" +-# pragma GCC diagnostic ignored "-Wunused-variable" +-# pragma GCC diagnostic ignored "-Wparentheses" ++ // Because REQUIREs trigger GCC's -Wparentheses, and because still ++ // supported version of g++ have only buggy support for _Pragmas, ++ // Wparentheses have to be suppressed globally. ++# pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details + + # pragma GCC diagnostic push ++# pragma GCC diagnostic ignored "-Wunused-variable" + # pragma GCC diagnostic ignored "-Wpadded" + #endif ++// end catch_suppress_warnings.h + #if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER) + # define CATCH_IMPL ++# define CATCH_CONFIG_ALL_PARTS ++#endif ++ ++// In the impl file, we want to have access to all parts of the headers ++// Can also be used to sanely support PCHs ++#if defined(CATCH_CONFIG_ALL_PARTS) ++# define CATCH_CONFIG_EXTERNAL_INTERFACES ++# if defined(CATCH_CONFIG_DISABLE_MATCHERS) ++# undef CATCH_CONFIG_DISABLE_MATCHERS ++# endif ++# if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER) ++# define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER ++# endif ++#endif ++ ++#if !defined(CATCH_CONFIG_IMPL_ONLY) ++// start catch_platform.h ++ ++// See e.g.: ++// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html ++#ifdef __APPLE__ ++# include ++# if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \ ++ (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1) ++# define CATCH_PLATFORM_MAC ++# elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1) ++# define CATCH_PLATFORM_IPHONE ++# endif ++ ++#elif defined(linux) || defined(__linux) || defined(__linux__) ++# define CATCH_PLATFORM_LINUX ++ ++#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__) ++# define CATCH_PLATFORM_WINDOWS + #endif + ++// end catch_platform.h ++ + #ifdef CATCH_IMPL + # ifndef CLARA_CONFIG_MAIN + # define CLARA_CONFIG_MAIN_NOT_DEFINED +@@ -56,93 +93,106 @@ + # endif + #endif + +-// #included from: internal/catch_notimplemented_exception.h +-#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED ++// start catch_user_interfaces.h + +-// #included from: catch_common.h +-#define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED ++namespace Catch { ++ unsigned int rngSeed(); ++} ++ ++// end catch_user_interfaces.h ++// start catch_tag_alias_autoregistrar.h + +-// #included from: catch_compiler_capabilities.h +-#define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED ++// start catch_common.h + +-// Detect a number of compiler features - mostly C++11/14 conformance - by compiler ++// start catch_compiler_capabilities.h ++ ++// Detect a number of compiler features - by compiler + // The following features are defined: + // +-// CATCH_CONFIG_CPP11_NULLPTR : is nullptr supported? +-// CATCH_CONFIG_CPP11_NOEXCEPT : is noexcept supported? +-// CATCH_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods +-// CATCH_CONFIG_CPP11_IS_ENUM : std::is_enum is supported? +-// CATCH_CONFIG_CPP11_TUPLE : std::tuple is supported +-// CATCH_CONFIG_CPP11_LONG_LONG : is long long supported? +-// CATCH_CONFIG_CPP11_OVERRIDE : is override supported? +-// CATCH_CONFIG_CPP11_UNIQUE_PTR : is unique_ptr supported (otherwise use auto_ptr) +-// CATCH_CONFIG_CPP11_SHUFFLE : is std::shuffle supported? +-// CATCH_CONFIG_CPP11_TYPE_TRAITS : are type_traits and enable_if supported? +- +-// CATCH_CONFIG_CPP11_OR_GREATER : Is C++11 supported? +- +-// CATCH_CONFIG_VARIADIC_MACROS : are variadic macros supported? + // CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported? + // CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported? + // CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported? ++// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled? + // **************** + // Note to maintainers: if new toggles are added please document them + // in configuration.md, too + // **************** + + // In general each macro has a _NO_ form +-// (e.g. CATCH_CONFIG_CPP11_NO_NULLPTR) which disables the feature. ++// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature. + // Many features, at point of detection, define an _INTERNAL_ macro, so they + // can be combined, en-mass, with the _NO_ forms later. + +-// All the C++11 features can be disabled with CATCH_CONFIG_NO_CPP11 +- + #ifdef __cplusplus + +-# if __cplusplus >= 201103L +-# define CATCH_CPP11_OR_GREATER ++# if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L) ++# define CATCH_CPP14_OR_GREATER + # endif + +-# if __cplusplus >= 201402L +-# define CATCH_CPP14_OR_GREATER ++# if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) ++# define CATCH_CPP17_OR_GREATER + # endif + + #endif + +-#ifdef __clang__ ++// Only GCC compiler should be used in this block, so other compilers trying to ++// mask themselves as GCC should be ignored. ++#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__) ++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" ) ++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic pop" ) + +-# if __has_feature(cxx_nullptr) +-# define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR +-# endif ++# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) ++ ++#endif + +-# if __has_feature(cxx_noexcept) +-# define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT ++#if defined(__clang__) ++ ++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" ) ++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic pop" ) ++ ++// As of this writing, IBM XL's implementation of __builtin_constant_p has a bug ++// which results in calls to destructors being emitted for each temporary, ++// without a matching initialization. In practice, this can result in something ++// like `std::string::~string` being called on an uninitialized value. ++// ++// For example, this code will likely segfault under IBM XL: ++// ``` ++// REQUIRE(std::string("12") + "34" == "1234") ++// ``` ++// ++// Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented. ++# if !defined(__ibmxl__) && !defined(__CUDACC__) ++# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */ + # endif + +-# if defined(CATCH_CPP11_OR_GREATER) +-# define CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \ +- _Pragma( "clang diagnostic push" ) \ +- _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) +-# define CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \ +- _Pragma( "clang diagnostic pop" ) +- +-# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \ +- _Pragma( "clang diagnostic push" ) \ +- _Pragma( "clang diagnostic ignored \"-Wparentheses\"" ) +-# define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \ +- _Pragma( "clang diagnostic pop" ) +-# endif ++# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ ++ _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \ ++ _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"") ++ ++# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \ ++ _Pragma( "clang diagnostic ignored \"-Wparentheses\"" ) ++ ++# define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \ ++ _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" ) ++ ++# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \ ++ _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" ) ++ ++# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \ ++ _Pragma( "clang diagnostic ignored \"-Wunused-template\"" ) + + #endif // __clang__ + + //////////////////////////////////////////////////////////////////////////////// +-// We know some environments not to support full POSIX signals +-#if defined(__CYGWIN__) || defined(__QNX__) +- +-# if !defined(CATCH_CONFIG_POSIX_SIGNALS) +-# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS +-# endif ++// Assume that non-Windows platforms support posix signals by default ++#if !defined(CATCH_PLATFORM_WINDOWS) ++ #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS ++#endif + ++//////////////////////////////////////////////////////////////////////////////// ++// We know some environments not to support full POSIX signals ++#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__) ++ #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS + #endif + + #ifdef __OS400__ +@@ -151,225 +201,268 @@ + #endif + + //////////////////////////////////////////////////////////////////////////////// +-// Cygwin +-#ifdef __CYGWIN__ +- +-// Required for some versions of Cygwin to declare gettimeofday +-// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin +-# define _BSD_SOURCE +- +-#endif // __CYGWIN__ +- +-//////////////////////////////////////////////////////////////////////////////// +-// Borland +-#ifdef __BORLANDC__ +- +-#endif // __BORLANDC__ ++// Android somehow still does not support std::to_string ++#if defined(__ANDROID__) ++# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING ++# define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE ++#endif + + //////////////////////////////////////////////////////////////////////////////// +-// EDG +-#ifdef __EDG_VERSION__ +- +-#endif // __EDG_VERSION__ ++// Not all Windows environments support SEH properly ++#if defined(__MINGW32__) ++# define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH ++#endif + + //////////////////////////////////////////////////////////////////////////////// +-// Digital Mars +-#ifdef __DMC__ +- +-#endif // __DMC__ ++// PS4 ++#if defined(__ORBIS__) ++# define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE ++#endif + + //////////////////////////////////////////////////////////////////////////////// +-// GCC +-#ifdef __GNUC__ ++// Cygwin ++#ifdef __CYGWIN__ + +-# if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__) +-# define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR +-# endif ++// Required for some versions of Cygwin to declare gettimeofday ++// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin ++# define _BSD_SOURCE ++// some versions of cygwin (most) do not support std::to_string. Use the libstd check. ++// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813 ++# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \ ++ && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF)) + +-// - otherwise more recent versions define __cplusplus >= 201103L +-// and will get picked up below ++# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING + +-#endif // __GNUC__ ++# endif ++#endif // __CYGWIN__ + + //////////////////////////////////////////////////////////////////////////////// + // Visual C++ +-#ifdef _MSC_VER ++#if defined(_MSC_VER) + +-#define CATCH_INTERNAL_CONFIG_WINDOWS_SEH ++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) ) ++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION __pragma( warning(pop) ) + +-#if (_MSC_VER >= 1600) +-# define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR +-# define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR +-#endif ++// Universal Windows platform does not support SEH ++// Or console colours (or console at all...) ++# if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP) ++# define CATCH_CONFIG_COLOUR_NONE ++# else ++# define CATCH_INTERNAL_CONFIG_WINDOWS_SEH ++# endif + +-#if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015)) +-#define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT +-#define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS +-#define CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE +-#define CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS +-#endif ++// MSVC traditional preprocessor needs some workaround for __VA_ARGS__ ++// _MSVC_TRADITIONAL == 0 means new conformant preprocessor ++// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor ++# if !defined(__clang__) // Handle Clang masquerading for msvc ++# if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL) ++# define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR ++# endif // MSVC_TRADITIONAL ++# endif // __clang__ + + #endif // _MSC_VER + +-//////////////////////////////////////////////////////////////////////////////// ++#if defined(_REENTRANT) || defined(_MSC_VER) ++// Enable async processing, as -pthread is specified or no additional linking is required ++# define CATCH_INTERNAL_CONFIG_USE_ASYNC ++#endif // _MSC_VER + +-// Use variadic macros if the compiler supports them +-#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 ) ++//////////////////////////////////////////////////////////////////////////////// ++// Check if we are compiled with -fno-exceptions or equivalent ++#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND) ++# define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED ++#endif + +-#define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS ++//////////////////////////////////////////////////////////////////////////////// ++// DJGPP ++#ifdef __DJGPP__ ++# define CATCH_INTERNAL_CONFIG_NO_WCHAR ++#endif // __DJGPP__ + ++//////////////////////////////////////////////////////////////////////////////// ++// Embarcadero C++Build ++#if defined(__BORLANDC__) ++ #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN + #endif + +-// Use __COUNTER__ if the compiler supports it +-#if ( defined _MSC_VER && _MSC_VER >= 1300 ) || \ +- ( defined __GNUC__ && ( __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3 )) ) || \ +- ( defined __clang__ && __clang_major__ >= 3 ) ++//////////////////////////////////////////////////////////////////////////////// + +-// Use of __COUNTER__ is suppressed during code analysis in CLion/AppCode 2017.2.x and former, +-// because __COUNTER__ is not properly handled by it. +-// This does not affect compilation +-#if ( !defined __JETBRAINS_IDE__ || __JETBRAINS_IDE__ >= 20170300L ) ++// Use of __COUNTER__ is suppressed during code analysis in ++// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly ++// handled by it. ++// Otherwise all supported compilers support COUNTER macro, ++// but user still might want to turn it off ++#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L ) + #define CATCH_INTERNAL_CONFIG_COUNTER + #endif + +-#endif +- + //////////////////////////////////////////////////////////////////////////////// +-// C++ language feature support +- +-// catch all support for C++11 +-#if defined(CATCH_CPP11_OR_GREATER) + +-# if !defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR) +-# define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR +-# endif ++// RTX is a special version of Windows that is real time. ++// This means that it is detected as Windows, but does not provide ++// the same set of capabilities as real Windows does. ++#if defined(UNDER_RTSS) || defined(RTX64_BUILD) ++ #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH ++ #define CATCH_INTERNAL_CONFIG_NO_ASYNC ++ #define CATCH_CONFIG_COLOUR_NONE ++#endif + +-# ifndef CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT +-# define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT +-# endif ++#if !defined(_GLIBCXX_USE_C99_MATH_TR1) ++#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER ++#endif + +-# ifndef CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS +-# define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS +-# endif ++// Various stdlib support checks that require __has_include ++#if defined(__has_include) ++ // Check if string_view is available and usable ++ #if __has_include() && defined(CATCH_CPP17_OR_GREATER) ++ # define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW ++ #endif ++ ++ // Check if optional is available and usable ++ # if __has_include() && defined(CATCH_CPP17_OR_GREATER) ++ # define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL ++ # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) ++ ++ // Check if byte is available and usable ++ # if __has_include() && defined(CATCH_CPP17_OR_GREATER) ++ # include ++ # if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0) ++ # define CATCH_INTERNAL_CONFIG_CPP17_BYTE ++ # endif ++ # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) ++ ++ // Check if variant is available and usable ++ # if __has_include() && defined(CATCH_CPP17_OR_GREATER) ++ # if defined(__clang__) && (__clang_major__ < 8) ++ // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852 ++ // fix should be in clang 8, workaround in libstdc++ 8.2 ++ # include ++ # if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9) ++ # define CATCH_CONFIG_NO_CPP17_VARIANT ++ # else ++ # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT ++ # endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9) ++ # else ++ # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT ++ # endif // defined(__clang__) && (__clang_major__ < 8) ++ # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) ++#endif // defined(__has_include) + +-# ifndef CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM +-# define CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM +-# endif ++#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER) ++# define CATCH_CONFIG_COUNTER ++#endif ++#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH) ++# define CATCH_CONFIG_WINDOWS_SEH ++#endif ++// This is set by default, because we assume that unix compilers are posix-signal-compatible by default. ++#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS) ++# define CATCH_CONFIG_POSIX_SIGNALS ++#endif ++// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions. ++#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR) ++# define CATCH_CONFIG_WCHAR ++#endif + +-# ifndef CATCH_INTERNAL_CONFIG_CPP11_TUPLE +-# define CATCH_INTERNAL_CONFIG_CPP11_TUPLE +-# endif ++#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING) ++# define CATCH_CONFIG_CPP11_TO_STRING ++#endif + +-# ifndef CATCH_INTERNAL_CONFIG_VARIADIC_MACROS +-# define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS +-# endif ++#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL) ++# define CATCH_CONFIG_CPP17_OPTIONAL ++#endif + +-# if !defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG) +-# define CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG +-# endif ++#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW) ++# define CATCH_CONFIG_CPP17_STRING_VIEW ++#endif + +-# if !defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE) +-# define CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE +-# endif +-# if !defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) +-# define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR +-# endif +-# if !defined(CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE) +-# define CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE +-# endif +-# if !defined(CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS) +-# define CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS +-# endif ++#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT) ++# define CATCH_CONFIG_CPP17_VARIANT ++#endif + +-#endif // __cplusplus >= 201103L ++#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE) ++# define CATCH_CONFIG_CPP17_BYTE ++#endif + +-// Now set the actual defines based on the above + anything the user has configured +-#if defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NO_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_NULLPTR ++#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT) ++# define CATCH_INTERNAL_CONFIG_NEW_CAPTURE + #endif +-#if defined(CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NO_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_NOEXCEPT ++ ++#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE) ++# define CATCH_CONFIG_NEW_CAPTURE + #endif +-#if defined(CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_GENERATED_METHODS ++ ++#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) ++# define CATCH_CONFIG_DISABLE_EXCEPTIONS + #endif +-#if defined(CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_NO_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_IS_ENUM ++ ++#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN) ++# define CATCH_CONFIG_POLYFILL_ISNAN + #endif +-#if defined(CATCH_INTERNAL_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_CPP11_NO_TUPLE) && !defined(CATCH_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_TUPLE ++ ++#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC) && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC) ++# define CATCH_CONFIG_USE_ASYNC + #endif +-#if defined(CATCH_INTERNAL_CONFIG_VARIADIC_MACROS) && !defined(CATCH_CONFIG_NO_VARIADIC_MACROS) && !defined(CATCH_CONFIG_VARIADIC_MACROS) +-# define CATCH_CONFIG_VARIADIC_MACROS ++ ++#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE) ++# define CATCH_CONFIG_ANDROID_LOGWRITE + #endif +-#if defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_CPP11_NO_LONG_LONG) && !defined(CATCH_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_LONG_LONG ++ ++#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER) ++# define CATCH_CONFIG_GLOBAL_NEXTAFTER + #endif +-#if defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_CPP11_NO_OVERRIDE) && !defined(CATCH_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_OVERRIDE ++ ++// Even if we do not think the compiler has that warning, we still have ++// to provide a macro that can be used by the code. ++#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION) ++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION + #endif +-#if defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_NO_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_UNIQUE_PTR ++#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION) ++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION + #endif +-#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER) +-# define CATCH_CONFIG_COUNTER ++#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS) ++# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS + #endif +-#if defined(CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_NO_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_SHUFFLE ++#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS) ++# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS + #endif +-# if defined(CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_NO_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_TYPE_TRAITS +-# endif +-#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) +-# define CATCH_CONFIG_WINDOWS_SEH ++#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS) ++# define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS + #endif +-// This is set by default, because we assume that unix compilers are posix-signal-compatible by default. +-#if !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS) +-# define CATCH_CONFIG_POSIX_SIGNALS ++#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS) ++# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS + #endif + +-#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS) +-# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS +-# define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS +-#endif +-#if !defined(CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS) +-# define CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS +-# define CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS ++// The goal of this macro is to avoid evaluation of the arguments, but ++// still have the compiler warn on problems inside... ++#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN) ++# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) + #endif + +-// noexcept support: +-#if defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_NOEXCEPT) +-# define CATCH_NOEXCEPT noexcept +-# define CATCH_NOEXCEPT_IS(x) noexcept(x) +-#else +-# define CATCH_NOEXCEPT throw() +-# define CATCH_NOEXCEPT_IS(x) ++#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10) ++# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS ++#elif defined(__clang__) && (__clang_major__ < 5) ++# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS + #endif + +-// nullptr support +-#ifdef CATCH_CONFIG_CPP11_NULLPTR +-# define CATCH_NULL nullptr +-#else +-# define CATCH_NULL NULL ++#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS) ++# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS + #endif + +-// override support +-#ifdef CATCH_CONFIG_CPP11_OVERRIDE +-# define CATCH_OVERRIDE override ++#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) ++#define CATCH_TRY if ((true)) ++#define CATCH_CATCH_ALL if ((false)) ++#define CATCH_CATCH_ANON(type) if ((false)) + #else +-# define CATCH_OVERRIDE ++#define CATCH_TRY try ++#define CATCH_CATCH_ALL catch (...) ++#define CATCH_CATCH_ANON(type) catch (type) + #endif + +-// unique_ptr support +-#ifdef CATCH_CONFIG_CPP11_UNIQUE_PTR +-# define CATCH_AUTO_PTR( T ) std::unique_ptr +-#else +-# define CATCH_AUTO_PTR( T ) std::auto_ptr ++#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) ++#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR + #endif + ++// end catch_compiler_capabilities.h + #define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line + #define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) + #ifdef CATCH_CONFIG_COUNTER +@@ -378,95 +471,48 @@ + # define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ ) + #endif + +-#define INTERNAL_CATCH_STRINGIFY2( expr ) #expr +-#define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr ) ++#include ++#include ++#include + +-#include +-#include ++// We need a dummy global operator<< so we can bring it into Catch namespace later ++struct Catch_global_namespace_dummy {}; ++std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy); + + namespace Catch { + +- struct IConfig; +- + struct CaseSensitive { enum Choice { + Yes, + No + }; }; + + class NonCopyable { +-#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS + NonCopyable( NonCopyable const& ) = delete; + NonCopyable( NonCopyable && ) = delete; + NonCopyable& operator = ( NonCopyable const& ) = delete; + NonCopyable& operator = ( NonCopyable && ) = delete; +-#else +- NonCopyable( NonCopyable const& info ); +- NonCopyable& operator = ( NonCopyable const& ); +-#endif + + protected: +- NonCopyable() {} ++ NonCopyable(); + virtual ~NonCopyable(); + }; + +- class SafeBool { +- public: +- typedef void (SafeBool::*type)() const; +- +- static type makeSafe( bool value ) { +- return value ? &SafeBool::trueValue : 0; +- } +- private: +- void trueValue() const {} +- }; +- +- template +- void deleteAll( ContainerT& container ) { +- typename ContainerT::const_iterator it = container.begin(); +- typename ContainerT::const_iterator itEnd = container.end(); +- for(; it != itEnd; ++it ) +- delete *it; +- } +- template +- void deleteAllValues( AssociativeContainerT& container ) { +- typename AssociativeContainerT::const_iterator it = container.begin(); +- typename AssociativeContainerT::const_iterator itEnd = container.end(); +- for(; it != itEnd; ++it ) +- delete it->second; +- } +- +- bool startsWith( std::string const& s, std::string const& prefix ); +- bool startsWith( std::string const& s, char prefix ); +- bool endsWith( std::string const& s, std::string const& suffix ); +- bool endsWith( std::string const& s, char suffix ); +- bool contains( std::string const& s, std::string const& infix ); +- void toLowerInPlace( std::string& s ); +- std::string toLower( std::string const& s ); +- std::string trim( std::string const& str ); +- bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ); +- +- struct pluralise { +- pluralise( std::size_t count, std::string const& label ); +- +- friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ); ++ struct SourceLineInfo { + +- std::size_t m_count; +- std::string m_label; +- }; ++ SourceLineInfo() = delete; ++ SourceLineInfo( char const* _file, std::size_t _line ) noexcept ++ : file( _file ), ++ line( _line ) ++ {} + +- struct SourceLineInfo { ++ SourceLineInfo( SourceLineInfo const& other ) = default; ++ SourceLineInfo& operator = ( SourceLineInfo const& ) = default; ++ SourceLineInfo( SourceLineInfo&& ) noexcept = default; ++ SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default; + +- SourceLineInfo(); +- SourceLineInfo( char const* _file, std::size_t _line ); +-# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS +- SourceLineInfo(SourceLineInfo const& other) = default; +- SourceLineInfo( SourceLineInfo && ) = default; +- SourceLineInfo& operator = ( SourceLineInfo const& ) = default; +- SourceLineInfo& operator = ( SourceLineInfo && ) = default; +-# endif +- bool empty() const; +- bool operator == ( SourceLineInfo const& other ) const; +- bool operator < ( SourceLineInfo const& other ) const; ++ bool empty() const noexcept { return file[0] == '\0'; } ++ bool operator == ( SourceLineInfo const& other ) const noexcept; ++ bool operator < ( SourceLineInfo const& other ) const noexcept; + + char const* file; + std::size_t line; +@@ -474,24 +520,17 @@ namespace Catch { + + std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ); + +- // This is just here to avoid compiler warnings with macro constants and boolean literals +- inline bool isTrue( bool value ){ return value; } +- inline bool alwaysTrue() { return true; } +- inline bool alwaysFalse() { return false; } +- +- void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ); +- +- void seedRng( IConfig const& config ); +- unsigned int rngSeed(); ++ // Bring in operator<< from global namespace into Catch namespace ++ // This is necessary because the overload of operator<< above makes ++ // lookup stop at namespace Catch ++ using ::operator<<; + + // Use this in variadic streaming macros to allow + // >> +StreamEndStop + // as well as + // >> stuff +StreamEndStop + struct StreamEndStop { +- std::string operator+() { +- return std::string(); +- } ++ std::string operator+() const; + }; + template + T const& operator + ( T const& value, StreamEndStop ) { +@@ -499,363 +538,812 @@ namespace Catch { + } + } + +-#define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) ) +-#define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_INTERNAL_LINEINFO ); ++#define CATCH_INTERNAL_LINEINFO \ ++ ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) ) + ++// end catch_common.h + namespace Catch { + +- class NotImplementedException : public std::exception +- { +- public: +- NotImplementedException( SourceLineInfo const& lineInfo ); +- +- virtual ~NotImplementedException() CATCH_NOEXCEPT {} +- +- virtual const char* what() const CATCH_NOEXCEPT; +- +- private: +- std::string m_what; +- SourceLineInfo m_lineInfo; ++ struct RegistrarForTagAliases { ++ RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ); + }; + + } // end namespace Catch + +-/////////////////////////////////////////////////////////////////////////////// +-#define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException( CATCH_INTERNAL_LINEINFO ) ++#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \ ++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ ++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ ++ namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \ ++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION + +-// #included from: internal/catch_context.h +-#define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED ++// end catch_tag_alias_autoregistrar.h ++// start catch_test_registry.h + +-// #included from: catch_interfaces_generators.h +-#define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED ++// start catch_interfaces_testcase.h + +-#include ++#include + + namespace Catch { + +- struct IGeneratorInfo { +- virtual ~IGeneratorInfo(); +- virtual bool moveNext() = 0; +- virtual std::size_t getCurrentIndex() const = 0; ++ class TestSpec; ++ ++ struct ITestInvoker { ++ virtual void invoke () const = 0; ++ virtual ~ITestInvoker(); + }; + +- struct IGeneratorsForTest { +- virtual ~IGeneratorsForTest(); ++ class TestCase; ++ struct IConfig; + +- virtual IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) = 0; +- virtual bool moveNext() = 0; ++ struct ITestCaseRegistry { ++ virtual ~ITestCaseRegistry(); ++ virtual std::vector const& getAllTests() const = 0; ++ virtual std::vector const& getAllTestsSorted( IConfig const& config ) const = 0; + }; + +- IGeneratorsForTest* createGeneratorsForTest(); ++ bool isThrowSafe( TestCase const& testCase, IConfig const& config ); ++ bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ); ++ std::vector filterTests( std::vector const& testCases, TestSpec const& testSpec, IConfig const& config ); ++ std::vector const& getAllTestCasesSorted( IConfig const& config ); + +-} // end namespace Catch ++} + +-// #included from: catch_ptr.hpp +-#define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED ++// end catch_interfaces_testcase.h ++// start catch_stringref.h + +-#ifdef __clang__ +-#pragma clang diagnostic push +-#pragma clang diagnostic ignored "-Wpadded" +-#endif ++#include ++#include ++#include ++#include + + namespace Catch { + +- // An intrusive reference counting smart pointer. +- // T must implement addRef() and release() methods +- // typically implementing the IShared interface +- template +- class Ptr { ++ /// A non-owning string class (similar to the forthcoming std::string_view) ++ /// Note that, because a StringRef may be a substring of another string, ++ /// it may not be null terminated. ++ class StringRef { + public: +- Ptr() : m_p( CATCH_NULL ){} +- Ptr( T* p ) : m_p( p ){ +- if( m_p ) +- m_p->addRef(); +- } +- Ptr( Ptr const& other ) : m_p( other.m_p ){ +- if( m_p ) +- m_p->addRef(); +- } +- ~Ptr(){ +- if( m_p ) +- m_p->release(); +- } +- void reset() { +- if( m_p ) +- m_p->release(); +- m_p = CATCH_NULL; +- } +- Ptr& operator = ( T* p ){ +- Ptr temp( p ); +- swap( temp ); +- return *this; +- } +- Ptr& operator = ( Ptr const& other ){ +- Ptr temp( other ); +- swap( temp ); +- return *this; +- } +- void swap( Ptr& other ) { std::swap( m_p, other.m_p ); } +- T* get() const{ return m_p; } +- T& operator*() const { return *m_p; } +- T* operator->() const { return m_p; } +- bool operator !() const { return m_p == CATCH_NULL; } +- operator SafeBool::type() const { return SafeBool::makeSafe( m_p != CATCH_NULL ); } ++ using size_type = std::size_t; ++ using const_iterator = const char*; + + private: +- T* m_p; +- }; ++ static constexpr char const* const s_empty = ""; + +- struct IShared : NonCopyable { +- virtual ~IShared(); +- virtual void addRef() const = 0; +- virtual void release() const = 0; +- }; ++ char const* m_start = s_empty; ++ size_type m_size = 0; + +- template +- struct SharedImpl : T { ++ public: // construction ++ constexpr StringRef() noexcept = default; + +- SharedImpl() : m_rc( 0 ){} ++ StringRef( char const* rawChars ) noexcept; ++ ++ constexpr StringRef( char const* rawChars, size_type size ) noexcept ++ : m_start( rawChars ), ++ m_size( size ) ++ {} ++ ++ StringRef( std::string const& stdString ) noexcept ++ : m_start( stdString.c_str() ), ++ m_size( stdString.size() ) ++ {} + +- virtual void addRef() const { +- ++m_rc; ++ explicit operator std::string() const { ++ return std::string(m_start, m_size); + } +- virtual void release() const { +- if( --m_rc == 0 ) +- delete this; ++ ++ public: // operators ++ auto operator == ( StringRef const& other ) const noexcept -> bool; ++ auto operator != (StringRef const& other) const noexcept -> bool { ++ return !(*this == other); + } + +- mutable unsigned int m_rc; +- }; ++ auto operator[] ( size_type index ) const noexcept -> char { ++ assert(index < m_size); ++ return m_start[index]; ++ } + +-} // end namespace Catch ++ public: // named queries ++ constexpr auto empty() const noexcept -> bool { ++ return m_size == 0; ++ } ++ constexpr auto size() const noexcept -> size_type { ++ return m_size; ++ } + +-#ifdef __clang__ +-#pragma clang diagnostic pop +-#endif ++ // Returns the current start pointer. If the StringRef is not ++ // null-terminated, throws std::domain_exception ++ auto c_str() const -> char const*; + +-namespace Catch { ++ public: // substrings and searches ++ // Returns a substring of [start, start + length). ++ // If start + length > size(), then the substring is [start, size()). ++ // If start > size(), then the substring is empty. ++ auto substr( size_type start, size_type length ) const noexcept -> StringRef; + +- class TestCase; +- class Stream; +- struct IResultCapture; +- struct IRunner; +- struct IGeneratorsForTest; +- struct IConfig; ++ // Returns the current start pointer. May not be null-terminated. ++ auto data() const noexcept -> char const*; + +- struct IContext +- { +- virtual ~IContext(); ++ constexpr auto isNullTerminated() const noexcept -> bool { ++ return m_start[m_size] == '\0'; ++ } + +- virtual IResultCapture* getResultCapture() = 0; +- virtual IRunner* getRunner() = 0; +- virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) = 0; +- virtual bool advanceGeneratorsForCurrentTest() = 0; +- virtual Ptr getConfig() const = 0; ++ public: // iterators ++ constexpr const_iterator begin() const { return m_start; } ++ constexpr const_iterator end() const { return m_start + m_size; } + }; + +- struct IMutableContext : IContext +- { +- virtual ~IMutableContext(); +- virtual void setResultCapture( IResultCapture* resultCapture ) = 0; +- virtual void setRunner( IRunner* runner ) = 0; +- virtual void setConfig( Ptr const& config ) = 0; +- }; ++ auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&; ++ auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&; + +- IContext& getCurrentContext(); +- IMutableContext& getCurrentMutableContext(); +- void cleanUpContext(); +- Stream createStream( std::string const& streamName ); ++ constexpr auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef { ++ return StringRef( rawChars, size ); ++ } ++} // namespace Catch + ++constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef { ++ return Catch::StringRef( rawChars, size ); + } + +-// #included from: internal/catch_test_registry.hpp +-#define TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED +- +-// #included from: catch_interfaces_testcase.h +-#define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED ++// end catch_stringref.h ++// start catch_preprocessor.hpp + +-#include + +-namespace Catch { ++#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__ ++#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__))) ++#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__))) ++#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__))) ++#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__))) ++#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__))) + +- class TestSpec; ++#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR ++#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__ ++// MSVC needs more evaluations ++#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__))) ++#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__)) ++#else ++#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL5(__VA_ARGS__) ++#endif + +- struct ITestCase : IShared { +- virtual void invoke () const = 0; +- protected: +- virtual ~ITestCase(); +- }; ++#define CATCH_REC_END(...) ++#define CATCH_REC_OUT ++ ++#define CATCH_EMPTY() ++#define CATCH_DEFER(id) id CATCH_EMPTY() ++ ++#define CATCH_REC_GET_END2() 0, CATCH_REC_END ++#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2 ++#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1 ++#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT ++#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0) ++#define CATCH_REC_NEXT(test, next) CATCH_REC_NEXT1(CATCH_REC_GET_END test, next) ++ ++#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ ) ++#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ ) ++#define CATCH_REC_LIST2(f, x, peek, ...) f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ ) ++ ++#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ ) ++#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ ) ++#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...) f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ ) ++ ++// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results, ++// and passes userdata as the first parameter to each invocation, ++// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c) ++#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0)) ++ ++#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0)) ++ ++#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param) ++#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__ ++#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__ ++#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF ++#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__) ++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR ++#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__ ++#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) ++#else ++// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF ++#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__) ++#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__ ++#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1) ++#endif + +- class TestCase; +- struct IConfig; ++#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__ ++#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name) + +- struct ITestCaseRegistry { +- virtual ~ITestCaseRegistry(); +- virtual std::vector const& getAllTests() const = 0; +- virtual std::vector const& getAllTestsSorted( IConfig const& config ) const = 0; ++#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__) ++ ++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR ++#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper()) ++#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)) ++#else ++#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper())) ++#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))) ++#endif ++ ++#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\ ++ CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__) ++ ++#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0) ++#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1) ++#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2) ++#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3) ++#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4) ++#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5) ++#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6) ++#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7) ++#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8) ++#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9) ++#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) ++ ++#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N ++ ++#define INTERNAL_CATCH_TYPE_GEN\ ++ template struct TypeList {};\ ++ template\ ++ constexpr auto get_wrapper() noexcept -> TypeList { return {}; }\ ++ template class...> struct TemplateTypeList{};\ ++ template class...Cs>\ ++ constexpr auto get_wrapper() noexcept -> TemplateTypeList { return {}; }\ ++ template\ ++ struct append;\ ++ template\ ++ struct rewrap;\ ++ template class, typename...>\ ++ struct create;\ ++ template class, typename>\ ++ struct convert;\ ++ \ ++ template \ ++ struct append { using type = T; };\ ++ template< template class L1, typename...E1, template class L2, typename...E2, typename...Rest>\ ++ struct append, L2, Rest...> { using type = typename append, Rest...>::type; };\ ++ template< template class L1, typename...E1, typename...Rest>\ ++ struct append, TypeList, Rest...> { using type = L1; };\ ++ \ ++ template< template class Container, template class List, typename...elems>\ ++ struct rewrap, List> { using type = TypeList>; };\ ++ template< template class Container, template class List, class...Elems, typename...Elements>\ ++ struct rewrap, List, Elements...> { using type = typename append>, typename rewrap, Elements...>::type>::type; };\ ++ \ ++ template