diff --git a/Makefile b/Makefile index 84544ed..c9db08b 100755 --- a/Makefile +++ b/Makefile @@ -244,6 +244,7 @@ help: @echo " - Make PlantUML graph : make plantuml" @echo " - Make Doxygen docmumentation : make docu" @echo " - Make Uncrustify Code Beautifier : make uncrustify" + @echo " - Enable compatibility with non-C++17 : make non-c++17" # Download PlantUML from http://plantuml.com/download.html # and put it into the root of the project directory @@ -257,6 +258,12 @@ uncrustify: uncrustify -c SatPI.uncrustify --replace $(HEADERS) @echo uncrustify Done +# Enable compatibility with non-C++17 compilers +# wget -P backports/ https://github.com/Barracuda09/SATPI/pull/173.diff +non-c++17: + patch -p1 < backports/173.diff + @echo patching Done + checkcpp: ~/cppcheck/cppcheck -DENIGMA -DLIBDVBCSA -DDVB_API_VERSION=5 -DDVB_API_VERSION_MINOR=5 -I ./src --enable=all --std=posix --std=c++11 ./src 1> cppcheck.log 2>&1 diff --git a/README.md b/README.md index b67864a..73700cc 100644 --- a/README.md +++ b/README.md @@ -129,6 +129,10 @@ Build - To buils just run (Or some other build you like)
`make debug`
+- If you see building errors, then perhaps your toolchain is not C++17 compatible. In this case try this before compiling: + + `make non-c++17`
+ - If you like to build the documentation, use: `make docu (!! you need Doxygen and Graphviz/dot !!)`
diff --git a/backports/173.diff b/backports/173.diff new file mode 100644 index 0000000..8d8da5a --- /dev/null +++ b/backports/173.diff @@ -0,0 +1,1949 @@ +diff --git a/Makefile b/Makefile +index 84544edf..390db9ff 100755 +--- a/Makefile ++++ b/Makefile +@@ -11,6 +11,15 @@ CXX ?= $(CXXPREFIX)g++$(CXXSUFFIX) + # Check compiler support for some functions + RESULT_HAS_NP_FUNCTIONS := $(shell $(CXX) -o npfunc checks/npfunc.cpp -pthread 2> /dev/null ; echo $$? ; rm -rf npfunc) + RESULT_HAS_ATOMIC_FUNCTIONS := $(shell $(CXX) -o atomic checks/atomic.cpp 2> /dev/null ; echo $$? ; rm -rf atomic) ++RESULT_HAS_STRING_VIEW := $(shell $(CXX) -std=c++17 -o string_view checks/string_view.cpp -pthread 2> /dev/null ; echo $$? ; rm -rf string_view) ++RESULT_HAS_AUTO_TUPLE := $(shell $(CXX) -std=c++17 -o auto_tuple checks/auto_tuple.cpp -pthread 2> /dev/null ; echo $$? ; rm -rf auto_tuple) ++ ++# Enable Backport mode (ancient compilers previous to C++17) ++ifeq "$(RESULT_HAS_STRING_VIEW)" "1" ++ CFLAGS += -isystem nonstd -DNEED_BACKPORT ++else ifeq "$(RESULT_HAS_AUTO_TUPLE)" "1" ++ CFLAGS += -isystem nonstd -DNEED_BACKPORT ++endif + + # Includes needed for proper compilation + INCLUDES += +diff --git a/checks/auto_tuple.cpp b/checks/auto_tuple.cpp +new file mode 100644 +index 00000000..97649e6a +--- /dev/null ++++ b/checks/auto_tuple.cpp +@@ -0,0 +1,6 @@ ++#include ++int main(void) { ++ std::tuple foo(0,'h'); ++ auto [c,i] = foo; ++ return 0; ++} +diff --git a/checks/string_view.cpp b/checks/string_view.cpp +new file mode 100644 +index 00000000..f2ca8f75 +--- /dev/null ++++ b/checks/string_view.cpp +@@ -0,0 +1,7 @@ ++#include ++#include ++int main(void) { ++ std::string foo("hello"); ++ std::string_view sv{foo}; ++ return foo == sv; ++} +diff --git a/nonstd/string_view b/nonstd/string_view +new file mode 100644 +index 00000000..399e264d +--- /dev/null ++++ b/nonstd/string_view +@@ -0,0 +1,18 @@ ++/* string_view ++ ++ Free public domain license ++ ++ Including string_view_lite from: ++ https://github.com/martinmoene/string-view-lite ++ wget https://raw.githubusercontent.com/martinmoene/string-view-lite/master/include/nonstd/string_view.hpp ++*/ ++#ifndef NONSTD__STRING_VIEW_ ++#define NONSTD__STRING_VIEW_ ++ ++#include "string_view.hpp" ++ ++namespace std { ++ using string_view = nonstd::string_view; ++} ++ ++#endif // NONSTD__STRING_VIEW_ +diff --git a/nonstd/string_view.hpp b/nonstd/string_view.hpp +new file mode 100644 +index 00000000..809a5a4f +--- /dev/null ++++ b/nonstd/string_view.hpp +@@ -0,0 +1,1684 @@ ++// Copyright 2017-2020 by Martin Moene ++// ++// string-view lite, a C++17-like string_view for C++98 and later. ++// For more information see https://github.com/martinmoene/string-view-lite ++// ++// Distributed under the Boost Software License, Version 1.0. ++// (See accompanying file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt) ++ ++#pragma once ++ ++#ifndef NONSTD_SV_LITE_H_INCLUDED ++#define NONSTD_SV_LITE_H_INCLUDED ++ ++#define string_view_lite_MAJOR 1 ++#define string_view_lite_MINOR 7 ++#define string_view_lite_PATCH 0 ++ ++#define string_view_lite_VERSION nssv_STRINGIFY(string_view_lite_MAJOR) "." nssv_STRINGIFY(string_view_lite_MINOR) "." nssv_STRINGIFY(string_view_lite_PATCH) ++ ++#define nssv_STRINGIFY( x ) nssv_STRINGIFY_( x ) ++#define nssv_STRINGIFY_( x ) #x ++ ++// string-view lite configuration: ++ ++#define nssv_STRING_VIEW_DEFAULT 0 ++#define nssv_STRING_VIEW_NONSTD 1 ++#define nssv_STRING_VIEW_STD 2 ++ ++// tweak header support: ++ ++#ifdef __has_include ++# if __has_include() ++# include ++# endif ++#define nssv_HAVE_TWEAK_HEADER 1 ++#else ++#define nssv_HAVE_TWEAK_HEADER 0 ++//# pragma message("string_view.hpp: Note: Tweak header not supported.") ++#endif ++ ++// string_view selection and configuration: ++ ++#if !defined( nssv_CONFIG_SELECT_STRING_VIEW ) ++# define nssv_CONFIG_SELECT_STRING_VIEW ( nssv_HAVE_STD_STRING_VIEW ? nssv_STRING_VIEW_STD : nssv_STRING_VIEW_NONSTD ) ++#endif ++ ++#ifndef nssv_CONFIG_STD_SV_OPERATOR ++# define nssv_CONFIG_STD_SV_OPERATOR 0 ++#endif ++ ++#ifndef nssv_CONFIG_USR_SV_OPERATOR ++# define nssv_CONFIG_USR_SV_OPERATOR 1 ++#endif ++ ++#ifdef nssv_CONFIG_CONVERSION_STD_STRING ++# define nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS nssv_CONFIG_CONVERSION_STD_STRING ++# define nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS nssv_CONFIG_CONVERSION_STD_STRING ++#endif ++ ++#ifndef nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS ++# define nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS 1 ++#endif ++ ++#ifndef nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS ++# define nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS 1 ++#endif ++ ++#ifndef nssv_CONFIG_NO_STREAM_INSERTION ++# define nssv_CONFIG_NO_STREAM_INSERTION 0 ++#endif ++ ++// Control presence of exception handling (try and auto discover): ++ ++#ifndef nssv_CONFIG_NO_EXCEPTIONS ++# if defined(_MSC_VER) ++# include // for _HAS_EXCEPTIONS ++# endif ++# if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || (_HAS_EXCEPTIONS) ++# define nssv_CONFIG_NO_EXCEPTIONS 0 ++# else ++# define nssv_CONFIG_NO_EXCEPTIONS 1 ++# endif ++#endif ++ ++// C++ language version detection (C++23 is speculative): ++// Note: VC14.0/1900 (VS2015) lacks too much from C++14. ++ ++#ifndef nssv_CPLUSPLUS ++# if defined(_MSVC_LANG ) && !defined(__clang__) ++# define nssv_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG ) ++# else ++# define nssv_CPLUSPLUS __cplusplus ++# endif ++#endif ++ ++#define nssv_CPP98_OR_GREATER ( nssv_CPLUSPLUS >= 199711L ) ++#define nssv_CPP11_OR_GREATER ( nssv_CPLUSPLUS >= 201103L ) ++#define nssv_CPP11_OR_GREATER_ ( nssv_CPLUSPLUS >= 201103L ) ++#define nssv_CPP14_OR_GREATER ( nssv_CPLUSPLUS >= 201402L ) ++#define nssv_CPP17_OR_GREATER ( nssv_CPLUSPLUS >= 201703L ) ++#define nssv_CPP20_OR_GREATER ( nssv_CPLUSPLUS >= 202002L ) ++#define nssv_CPP23_OR_GREATER ( nssv_CPLUSPLUS >= 202300L ) ++ ++// use C++17 std::string_view if available and requested: ++ ++#if nssv_CPP17_OR_GREATER && defined(__has_include ) ++# if __has_include( ) ++# define nssv_HAVE_STD_STRING_VIEW 1 ++# else ++# define nssv_HAVE_STD_STRING_VIEW 0 ++# endif ++#else ++# define nssv_HAVE_STD_STRING_VIEW 0 ++#endif ++ ++#define nssv_USES_STD_STRING_VIEW ( (nssv_CONFIG_SELECT_STRING_VIEW == nssv_STRING_VIEW_STD) || ((nssv_CONFIG_SELECT_STRING_VIEW == nssv_STRING_VIEW_DEFAULT) && nssv_HAVE_STD_STRING_VIEW) ) ++ ++#define nssv_HAVE_STARTS_WITH ( nssv_CPP20_OR_GREATER || !nssv_USES_STD_STRING_VIEW ) ++#define nssv_HAVE_ENDS_WITH nssv_HAVE_STARTS_WITH ++ ++// ++// Use C++17 std::string_view: ++// ++ ++#if nssv_USES_STD_STRING_VIEW ++ ++#include ++ ++// Extensions for std::string: ++ ++#if nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS ++ ++namespace nonstd { ++ ++template< class CharT, class Traits, class Allocator = std::allocator > ++std::basic_string ++to_string( std::basic_string_view v, Allocator const & a = Allocator() ) ++{ ++ return std::basic_string( v.begin(), v.end(), a ); ++} ++ ++template< class CharT, class Traits, class Allocator > ++std::basic_string_view ++to_string_view( std::basic_string const & s ) ++{ ++ return std::basic_string_view( s.data(), s.size() ); ++} ++ ++// Literal operators sv and _sv: ++ ++#if nssv_CONFIG_STD_SV_OPERATOR ++ ++using namespace std::literals::string_view_literals; ++ ++#endif ++ ++#if nssv_CONFIG_USR_SV_OPERATOR ++ ++inline namespace literals { ++inline namespace string_view_literals { ++ ++ ++constexpr std::string_view operator "" _sv( const char* str, size_t len ) noexcept // (1) ++{ ++ return std::string_view{ str, len }; ++} ++ ++constexpr std::u16string_view operator "" _sv( const char16_t* str, size_t len ) noexcept // (2) ++{ ++ return std::u16string_view{ str, len }; ++} ++ ++constexpr std::u32string_view operator "" _sv( const char32_t* str, size_t len ) noexcept // (3) ++{ ++ return std::u32string_view{ str, len }; ++} ++ ++constexpr std::wstring_view operator "" _sv( const wchar_t* str, size_t len ) noexcept // (4) ++{ ++ return std::wstring_view{ str, len }; ++} ++ ++}} // namespace literals::string_view_literals ++ ++#endif // nssv_CONFIG_USR_SV_OPERATOR ++ ++} // namespace nonstd ++ ++#endif // nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS ++ ++namespace nonstd { ++ ++using std::string_view; ++using std::wstring_view; ++using std::u16string_view; ++using std::u32string_view; ++using std::basic_string_view; ++ ++// literal "sv" and "_sv", see above ++ ++using std::operator==; ++using std::operator!=; ++using std::operator<; ++using std::operator<=; ++using std::operator>; ++using std::operator>=; ++ ++using std::operator<<; ++ ++} // namespace nonstd ++ ++#else // nssv_HAVE_STD_STRING_VIEW ++ ++// ++// Before C++17: use string_view lite: ++// ++ ++// Compiler versions: ++// ++// MSVC++ 6.0 _MSC_VER == 1200 nssv_COMPILER_MSVC_VERSION == 60 (Visual Studio 6.0) ++// MSVC++ 7.0 _MSC_VER == 1300 nssv_COMPILER_MSVC_VERSION == 70 (Visual Studio .NET 2002) ++// MSVC++ 7.1 _MSC_VER == 1310 nssv_COMPILER_MSVC_VERSION == 71 (Visual Studio .NET 2003) ++// MSVC++ 8.0 _MSC_VER == 1400 nssv_COMPILER_MSVC_VERSION == 80 (Visual Studio 2005) ++// MSVC++ 9.0 _MSC_VER == 1500 nssv_COMPILER_MSVC_VERSION == 90 (Visual Studio 2008) ++// MSVC++ 10.0 _MSC_VER == 1600 nssv_COMPILER_MSVC_VERSION == 100 (Visual Studio 2010) ++// MSVC++ 11.0 _MSC_VER == 1700 nssv_COMPILER_MSVC_VERSION == 110 (Visual Studio 2012) ++// MSVC++ 12.0 _MSC_VER == 1800 nssv_COMPILER_MSVC_VERSION == 120 (Visual Studio 2013) ++// MSVC++ 14.0 _MSC_VER == 1900 nssv_COMPILER_MSVC_VERSION == 140 (Visual Studio 2015) ++// MSVC++ 14.1 _MSC_VER >= 1910 nssv_COMPILER_MSVC_VERSION == 141 (Visual Studio 2017) ++// MSVC++ 14.2 _MSC_VER >= 1920 nssv_COMPILER_MSVC_VERSION == 142 (Visual Studio 2019) ++ ++#if defined(_MSC_VER ) && !defined(__clang__) ++# define nssv_COMPILER_MSVC_VER (_MSC_VER ) ++# define nssv_COMPILER_MSVC_VERSION (_MSC_VER / 10 - 10 * ( 5 + (_MSC_VER < 1900 ) ) ) ++#else ++# define nssv_COMPILER_MSVC_VER 0 ++# define nssv_COMPILER_MSVC_VERSION 0 ++#endif ++ ++#define nssv_COMPILER_VERSION( major, minor, patch ) ( 10 * ( 10 * (major) + (minor) ) + (patch) ) ++ ++#if defined( __apple_build_version__ ) ++# define nssv_COMPILER_APPLECLANG_VERSION nssv_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__) ++# define nssv_COMPILER_CLANG_VERSION 0 ++#elif defined( __clang__ ) ++# define nssv_COMPILER_APPLECLANG_VERSION 0 ++# define nssv_COMPILER_CLANG_VERSION nssv_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__) ++#else ++# define nssv_COMPILER_APPLECLANG_VERSION 0 ++# define nssv_COMPILER_CLANG_VERSION 0 ++#endif ++ ++#if defined(__GNUC__) && !defined(__clang__) ++# define nssv_COMPILER_GNUC_VERSION nssv_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) ++#else ++# define nssv_COMPILER_GNUC_VERSION 0 ++#endif ++ ++// half-open range [lo..hi): ++#define nssv_BETWEEN( v, lo, hi ) ( (lo) <= (v) && (v) < (hi) ) ++ ++// Presence of language and library features: ++ ++#ifdef _HAS_CPP0X ++# define nssv_HAS_CPP0X _HAS_CPP0X ++#else ++# define nssv_HAS_CPP0X 0 ++#endif ++ ++// Unless defined otherwise below, consider VC14 as C++11 for variant-lite: ++ ++#if nssv_COMPILER_MSVC_VER >= 1900 ++# undef nssv_CPP11_OR_GREATER ++# define nssv_CPP11_OR_GREATER 1 ++#endif ++ ++#define nssv_CPP11_90 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1500) ++#define nssv_CPP11_100 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1600) ++#define nssv_CPP11_110 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1700) ++#define nssv_CPP11_120 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1800) ++#define nssv_CPP11_140 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1900) ++#define nssv_CPP11_141 (nssv_CPP11_OR_GREATER_ || nssv_COMPILER_MSVC_VER >= 1910) ++ ++#define nssv_CPP14_000 (nssv_CPP14_OR_GREATER) ++#define nssv_CPP17_000 (nssv_CPP17_OR_GREATER) ++ ++// Presence of C++11 language features: ++ ++#define nssv_HAVE_CONSTEXPR_11 nssv_CPP11_140 ++#define nssv_HAVE_EXPLICIT_CONVERSION nssv_CPP11_140 ++#define nssv_HAVE_INLINE_NAMESPACE nssv_CPP11_140 ++#define nssv_HAVE_IS_DEFAULT nssv_CPP11_140 ++#define nssv_HAVE_IS_DELETE nssv_CPP11_140 ++#define nssv_HAVE_NOEXCEPT nssv_CPP11_140 ++#define nssv_HAVE_NULLPTR nssv_CPP11_100 ++#define nssv_HAVE_REF_QUALIFIER nssv_CPP11_140 ++#define nssv_HAVE_UNICODE_LITERALS nssv_CPP11_140 ++#define nssv_HAVE_USER_DEFINED_LITERALS nssv_CPP11_140 ++#define nssv_HAVE_WCHAR16_T nssv_CPP11_100 ++#define nssv_HAVE_WCHAR32_T nssv_CPP11_100 ++ ++#if ! ( ( nssv_CPP11_OR_GREATER && nssv_COMPILER_CLANG_VERSION ) || nssv_BETWEEN( nssv_COMPILER_CLANG_VERSION, 300, 400 ) ) ++# define nssv_HAVE_STD_DEFINED_LITERALS nssv_CPP11_140 ++#else ++# define nssv_HAVE_STD_DEFINED_LITERALS 0 ++#endif ++ ++// Presence of C++14 language features: ++ ++#define nssv_HAVE_CONSTEXPR_14 nssv_CPP14_000 ++ ++// Presence of C++17 language features: ++ ++#define nssv_HAVE_NODISCARD nssv_CPP17_000 ++ ++// Presence of C++ library features: ++ ++#define nssv_HAVE_STD_HASH nssv_CPP11_120 ++ ++// Presence of compiler intrinsics: ++ ++// Providing char-type specializations for compare() and length() that ++// use compiler intrinsics can improve compile- and run-time performance. ++// ++// The challenge is in using the right combinations of builtin availability ++// and its constexpr-ness. ++// ++// | compiler | __builtin_memcmp (constexpr) | memcmp (constexpr) | ++// |----------|------------------------------|---------------------| ++// | clang | 4.0 (>= 4.0 ) | any (? ) | ++// | clang-a | 9.0 (>= 9.0 ) | any (? ) | ++// | gcc | any (constexpr) | any (? ) | ++// | msvc | >= 14.2 C++17 (>= 14.2 ) | any (? ) | ++ ++#define nssv_HAVE_BUILTIN_VER ( (nssv_CPP17_000 && nssv_COMPILER_MSVC_VERSION >= 142) || nssv_COMPILER_GNUC_VERSION > 0 || nssv_COMPILER_CLANG_VERSION >= 400 || nssv_COMPILER_APPLECLANG_VERSION >= 900 ) ++#define nssv_HAVE_BUILTIN_CE ( nssv_HAVE_BUILTIN_VER ) ++ ++#define nssv_HAVE_BUILTIN_MEMCMP ( (nssv_HAVE_CONSTEXPR_14 && nssv_HAVE_BUILTIN_CE) || !nssv_HAVE_CONSTEXPR_14 ) ++#define nssv_HAVE_BUILTIN_STRLEN ( (nssv_HAVE_CONSTEXPR_11 && nssv_HAVE_BUILTIN_CE) || !nssv_HAVE_CONSTEXPR_11 ) ++ ++#ifdef __has_builtin ++# define nssv_HAVE_BUILTIN( x ) __has_builtin( x ) ++#else ++# define nssv_HAVE_BUILTIN( x ) 0 ++#endif ++ ++#if nssv_HAVE_BUILTIN(__builtin_memcmp) || nssv_HAVE_BUILTIN_VER ++# define nssv_BUILTIN_MEMCMP __builtin_memcmp ++#else ++# define nssv_BUILTIN_MEMCMP memcmp ++#endif ++ ++#if nssv_HAVE_BUILTIN(__builtin_strlen) || nssv_HAVE_BUILTIN_VER ++# define nssv_BUILTIN_STRLEN __builtin_strlen ++#else ++# define nssv_BUILTIN_STRLEN strlen ++#endif ++ ++// C++ feature usage: ++ ++#if nssv_HAVE_CONSTEXPR_11 ++# define nssv_constexpr constexpr ++#else ++# define nssv_constexpr /*constexpr*/ ++#endif ++ ++#if nssv_HAVE_CONSTEXPR_14 ++# define nssv_constexpr14 constexpr ++#else ++# define nssv_constexpr14 /*constexpr*/ ++#endif ++ ++#if nssv_HAVE_EXPLICIT_CONVERSION ++# define nssv_explicit explicit ++#else ++# define nssv_explicit /*explicit*/ ++#endif ++ ++#if nssv_HAVE_INLINE_NAMESPACE ++# define nssv_inline_ns inline ++#else ++# define nssv_inline_ns /*inline*/ ++#endif ++ ++#if nssv_HAVE_NOEXCEPT ++# define nssv_noexcept noexcept ++#else ++# define nssv_noexcept /*noexcept*/ ++#endif ++ ++//#if nssv_HAVE_REF_QUALIFIER ++//# define nssv_ref_qual & ++//# define nssv_refref_qual && ++//#else ++//# define nssv_ref_qual /*&*/ ++//# define nssv_refref_qual /*&&*/ ++//#endif ++ ++#if nssv_HAVE_NULLPTR ++# define nssv_nullptr nullptr ++#else ++# define nssv_nullptr NULL ++#endif ++ ++#if nssv_HAVE_NODISCARD ++# define nssv_nodiscard [[nodiscard]] ++#else ++# define nssv_nodiscard /*[[nodiscard]]*/ ++#endif ++ ++// Additional includes: ++ ++#include ++#include ++#include ++#include ++#include // std::char_traits<> ++ ++#if ! nssv_CONFIG_NO_STREAM_INSERTION ++# include ++#endif ++ ++#if ! nssv_CONFIG_NO_EXCEPTIONS ++# include ++#endif ++ ++#if nssv_CPP11_OR_GREATER ++# include ++#endif ++ ++// Clang, GNUC, MSVC warning suppression macros: ++ ++#if defined(__clang__) ++# pragma clang diagnostic ignored "-Wreserved-user-defined-literal" ++# pragma clang diagnostic push ++# pragma clang diagnostic ignored "-Wuser-defined-literals" ++#elif nssv_COMPILER_GNUC_VERSION >= 480 ++# pragma GCC diagnostic push ++# pragma GCC diagnostic ignored "-Wliteral-suffix" ++#endif // __clang__ ++ ++#if nssv_COMPILER_MSVC_VERSION >= 140 ++# define nssv_SUPPRESS_MSGSL_WARNING(expr) [[gsl::suppress(expr)]] ++# define nssv_SUPPRESS_MSVC_WARNING(code, descr) __pragma(warning(suppress: code) ) ++# define nssv_DISABLE_MSVC_WARNINGS(codes) __pragma(warning(push)) __pragma(warning(disable: codes)) ++#else ++# define nssv_SUPPRESS_MSGSL_WARNING(expr) ++# define nssv_SUPPRESS_MSVC_WARNING(code, descr) ++# define nssv_DISABLE_MSVC_WARNINGS(codes) ++#endif ++ ++#if defined(__clang__) ++# define nssv_RESTORE_WARNINGS() _Pragma("clang diagnostic pop") ++#elif nssv_COMPILER_GNUC_VERSION >= 480 ++# define nssv_RESTORE_WARNINGS() _Pragma("GCC diagnostic pop") ++#elif nssv_COMPILER_MSVC_VERSION >= 140 ++# define nssv_RESTORE_WARNINGS() __pragma(warning(pop )) ++#else ++# define nssv_RESTORE_WARNINGS() ++#endif ++ ++// Suppress the following MSVC (GSL) warnings: ++// - C4455, non-gsl : 'operator ""sv': literal suffix identifiers that do not ++// start with an underscore are reserved ++// - C26472, gsl::t.1 : don't use a static_cast for arithmetic conversions; ++// use brace initialization, gsl::narrow_cast or gsl::narow ++// - C26481: gsl::b.1 : don't use pointer arithmetic. Use span instead ++ ++nssv_DISABLE_MSVC_WARNINGS( 4455 26481 26472 ) ++//nssv_DISABLE_CLANG_WARNINGS( "-Wuser-defined-literals" ) ++//nssv_DISABLE_GNUC_WARNINGS( -Wliteral-suffix ) ++ ++namespace nonstd { namespace sv_lite { ++ ++// ++// basic_string_view declaration: ++// ++ ++template ++< ++ class CharT, ++ class Traits = std::char_traits ++> ++class basic_string_view; ++ ++namespace detail { ++ ++// support constexpr comparison in C++14; ++// for C++17 and later, use provided traits: ++ ++template< typename CharT > ++inline nssv_constexpr14 int compare( CharT const * s1, CharT const * s2, std::size_t count ) ++{ ++ while ( count-- != 0 ) ++ { ++ if ( *s1 < *s2 ) return -1; ++ if ( *s1 > *s2 ) return +1; ++ ++s1; ++s2; ++ } ++ return 0; ++} ++ ++#if nssv_HAVE_BUILTIN_MEMCMP ++ ++// specialization of compare() for char, see also generic compare() above: ++ ++inline nssv_constexpr14 int compare( char const * s1, char const * s2, std::size_t count ) ++{ ++ return nssv_BUILTIN_MEMCMP( s1, s2, count ); ++} ++ ++#endif ++ ++#if nssv_HAVE_BUILTIN_STRLEN ++ ++// specialization of length() for char, see also generic length() further below: ++ ++inline nssv_constexpr std::size_t length( char const * s ) ++{ ++ return nssv_BUILTIN_STRLEN( s ); ++} ++ ++#endif ++ ++#if defined(__OPTIMIZE__) ++ ++// gcc, clang provide __OPTIMIZE__ ++// Expect tail call optimization to make length() non-recursive: ++ ++template< typename CharT > ++inline nssv_constexpr std::size_t length( CharT * s, std::size_t result = 0 ) ++{ ++ return *s == '\0' ? result : length( s + 1, result + 1 ); ++} ++ ++#else // OPTIMIZE ++ ++// non-recursive: ++ ++template< typename CharT > ++inline nssv_constexpr14 std::size_t length( CharT * s ) ++{ ++ std::size_t result = 0; ++ while ( *s++ != '\0' ) ++ { ++ ++result; ++ } ++ return result; ++} ++ ++#endif // OPTIMIZE ++ ++#if nssv_CPP11_OR_GREATER && ! nssv_CPP17_OR_GREATER ++#if defined(__OPTIMIZE__) ++ ++// gcc, clang provide __OPTIMIZE__ ++// Expect tail call optimization to make search() non-recursive: ++ ++template< class CharT, class Traits = std::char_traits > ++constexpr const CharT* search( basic_string_view haystack, basic_string_view needle ) ++{ ++ return haystack.starts_with( needle ) ? haystack.begin() : ++ haystack.empty() ? haystack.end() : search( haystack.substr(1), needle ); ++} ++ ++#else // OPTIMIZE ++ ++// non-recursive: ++ ++template< class CharT, class Traits = std::char_traits > ++constexpr const CharT* search( basic_string_view haystack, basic_string_view needle ) ++{ ++ return std::search( haystack.begin(), haystack.end(), needle.begin(), needle.end() ); ++} ++ ++#endif // OPTIMIZE ++#endif // nssv_CPP11_OR_GREATER && ! nssv_CPP17_OR_GREATER ++ ++} // namespace detail ++ ++// ++// basic_string_view: ++// ++ ++template ++< ++ class CharT, ++ class Traits /* = std::char_traits */ ++> ++class basic_string_view ++{ ++public: ++ // Member types: ++ ++ typedef Traits traits_type; ++ typedef CharT value_type; ++ ++ typedef CharT * pointer; ++ typedef CharT const * const_pointer; ++ typedef CharT & reference; ++ typedef CharT const & const_reference; ++ ++ typedef const_pointer iterator; ++ typedef const_pointer const_iterator; ++ typedef std::reverse_iterator< const_iterator > reverse_iterator; ++ typedef std::reverse_iterator< const_iterator > const_reverse_iterator; ++ ++ typedef std::size_t size_type; ++ typedef std::ptrdiff_t difference_type; ++ ++ // 24.4.2.1 Construction and assignment: ++ ++ nssv_constexpr basic_string_view() nssv_noexcept ++ : data_( nssv_nullptr ) ++ , size_( 0 ) ++ {} ++ ++#if nssv_CPP11_OR_GREATER ++ nssv_constexpr basic_string_view( basic_string_view const & other ) nssv_noexcept = default; ++#else ++ nssv_constexpr basic_string_view( basic_string_view const & other ) nssv_noexcept ++ : data_( other.data_) ++ , size_( other.size_) ++ {} ++#endif ++ ++ nssv_constexpr basic_string_view( CharT const * s, size_type count ) nssv_noexcept // non-standard noexcept ++ : data_( s ) ++ , size_( count ) ++ {} ++ ++ nssv_constexpr basic_string_view( CharT const * s) nssv_noexcept // non-standard noexcept ++ : data_( s ) ++#if nssv_CPP17_OR_GREATER ++ , size_( Traits::length(s) ) ++#elif nssv_CPP11_OR_GREATER ++ , size_( detail::length(s) ) ++#else ++ , size_( Traits::length(s) ) ++#endif ++ {} ++ ++#if nssv_HAVE_NULLPTR ++# if nssv_HAVE_IS_DELETE ++ nssv_constexpr basic_string_view( std::nullptr_t ) nssv_noexcept = delete; ++# else ++ private: nssv_constexpr basic_string_view( std::nullptr_t ) nssv_noexcept; public: ++# endif ++#endif ++ ++ // Assignment: ++ ++#if nssv_CPP11_OR_GREATER ++ nssv_constexpr14 basic_string_view & operator=( basic_string_view const & other ) nssv_noexcept = default; ++#else ++ nssv_constexpr14 basic_string_view & operator=( basic_string_view const & other ) nssv_noexcept ++ { ++ data_ = other.data_; ++ size_ = other.size_; ++ return *this; ++ } ++#endif ++ ++ // 24.4.2.2 Iterator support: ++ ++ nssv_constexpr const_iterator begin() const nssv_noexcept { return data_; } ++ nssv_constexpr const_iterator end() const nssv_noexcept { return data_ + size_; } ++ ++ nssv_constexpr const_iterator cbegin() const nssv_noexcept { return begin(); } ++ nssv_constexpr const_iterator cend() const nssv_noexcept { return end(); } ++ ++ nssv_constexpr const_reverse_iterator rbegin() const nssv_noexcept { return const_reverse_iterator( end() ); } ++ nssv_constexpr const_reverse_iterator rend() const nssv_noexcept { return const_reverse_iterator( begin() ); } ++ ++ nssv_constexpr const_reverse_iterator crbegin() const nssv_noexcept { return rbegin(); } ++ nssv_constexpr const_reverse_iterator crend() const nssv_noexcept { return rend(); } ++ ++ // 24.4.2.3 Capacity: ++ ++ nssv_constexpr size_type size() const nssv_noexcept { return size_; } ++ nssv_constexpr size_type length() const nssv_noexcept { return size_; } ++ nssv_constexpr size_type max_size() const nssv_noexcept { return (std::numeric_limits< size_type >::max)(); } ++ ++ // since C++20 ++ nssv_nodiscard nssv_constexpr bool empty() const nssv_noexcept ++ { ++ return 0 == size_; ++ } ++ ++ // 24.4.2.4 Element access: ++ ++ nssv_constexpr const_reference operator[]( size_type pos ) const ++ { ++ return data_at( pos ); ++ } ++ ++ nssv_constexpr14 const_reference at( size_type pos ) const ++ { ++#if nssv_CONFIG_NO_EXCEPTIONS ++ assert( pos < size() ); ++#else ++ if ( pos >= size() ) ++ { ++ throw std::out_of_range("nonstd::string_view::at()"); ++ } ++#endif ++ return data_at( pos ); ++ } ++ ++ nssv_constexpr const_reference front() const { return data_at( 0 ); } ++ nssv_constexpr const_reference back() const { return data_at( size() - 1 ); } ++ ++ nssv_constexpr const_pointer data() const nssv_noexcept { return data_; } ++ ++ // 24.4.2.5 Modifiers: ++ ++ nssv_constexpr14 void remove_prefix( size_type n ) ++ { ++ assert( n <= size() ); ++ data_ += n; ++ size_ -= n; ++ } ++ ++ nssv_constexpr14 void remove_suffix( size_type n ) ++ { ++ assert( n <= size() ); ++ size_ -= n; ++ } ++ ++ nssv_constexpr14 void swap( basic_string_view & other ) nssv_noexcept ++ { ++ const basic_string_view tmp(other); ++ other = *this; ++ *this = tmp; ++ } ++ ++ // 24.4.2.6 String operations: ++ ++ size_type copy( CharT * dest, size_type n, size_type pos = 0 ) const ++ { ++#if nssv_CONFIG_NO_EXCEPTIONS ++ assert( pos <= size() ); ++#else ++ if ( pos > size() ) ++ { ++ throw std::out_of_range("nonstd::string_view::copy()"); ++ } ++#endif ++ const size_type rlen = (std::min)( n, size() - pos ); ++ ++ (void) Traits::copy( dest, data() + pos, rlen ); ++ ++ return rlen; ++ } ++ ++ nssv_constexpr14 basic_string_view substr( size_type pos = 0, size_type n = npos ) const ++ { ++#if nssv_CONFIG_NO_EXCEPTIONS ++ assert( pos <= size() ); ++#else ++ if ( pos > size() ) ++ { ++ throw std::out_of_range("nonstd::string_view::substr()"); ++ } ++#endif ++ return basic_string_view( data() + pos, (std::min)( n, size() - pos ) ); ++ } ++ ++ // compare(), 6x: ++ ++ nssv_constexpr14 int compare( basic_string_view other ) const nssv_noexcept // (1) ++ { ++#if nssv_CPP17_OR_GREATER ++ if ( const int result = Traits::compare( data(), other.data(), (std::min)( size(), other.size() ) ) ) ++#else ++ if ( const int result = detail::compare( data(), other.data(), (std::min)( size(), other.size() ) ) ) ++#endif ++ { ++ return result; ++ } ++ ++ return size() == other.size() ? 0 : size() < other.size() ? -1 : 1; ++ } ++ ++ nssv_constexpr int compare( size_type pos1, size_type n1, basic_string_view other ) const // (2) ++ { ++ return substr( pos1, n1 ).compare( other ); ++ } ++ ++ nssv_constexpr int compare( size_type pos1, size_type n1, basic_string_view other, size_type pos2, size_type n2 ) const // (3) ++ { ++ return substr( pos1, n1 ).compare( other.substr( pos2, n2 ) ); ++ } ++ ++ nssv_constexpr int compare( CharT const * s ) const // (4) ++ { ++ return compare( basic_string_view( s ) ); ++ } ++ ++ nssv_constexpr int compare( size_type pos1, size_type n1, CharT const * s ) const // (5) ++ { ++ return substr( pos1, n1 ).compare( basic_string_view( s ) ); ++ } ++ ++ nssv_constexpr int compare( size_type pos1, size_type n1, CharT const * s, size_type n2 ) const // (6) ++ { ++ return substr( pos1, n1 ).compare( basic_string_view( s, n2 ) ); ++ } ++ ++ // 24.4.2.7 Searching: ++ ++ // starts_with(), 3x, since C++20: ++ ++ nssv_constexpr bool starts_with( basic_string_view v ) const nssv_noexcept // (1) ++ { ++ return size() >= v.size() && compare( 0, v.size(), v ) == 0; ++ } ++ ++ nssv_constexpr bool starts_with( CharT c ) const nssv_noexcept // (2) ++ { ++ return starts_with( basic_string_view( &c, 1 ) ); ++ } ++ ++ nssv_constexpr bool starts_with( CharT const * s ) const // (3) ++ { ++ return starts_with( basic_string_view( s ) ); ++ } ++ ++ // ends_with(), 3x, since C++20: ++ ++ nssv_constexpr bool ends_with( basic_string_view v ) const nssv_noexcept // (1) ++ { ++ return size() >= v.size() && compare( size() - v.size(), npos, v ) == 0; ++ } ++ ++ nssv_constexpr bool ends_with( CharT c ) const nssv_noexcept // (2) ++ { ++ return ends_with( basic_string_view( &c, 1 ) ); ++ } ++ ++ nssv_constexpr bool ends_with( CharT const * s ) const // (3) ++ { ++ return ends_with( basic_string_view( s ) ); ++ } ++ ++ // find(), 4x: ++ ++ nssv_constexpr14 size_type find( basic_string_view v, size_type pos = 0 ) const nssv_noexcept // (1) ++ { ++ return assert( v.size() == 0 || v.data() != nssv_nullptr ) ++ , pos >= size() ++ ? npos : to_pos( ++#if nssv_CPP11_OR_GREATER && ! nssv_CPP17_OR_GREATER ++ detail::search( substr(pos), v ) ++#else ++ std::search( cbegin() + pos, cend(), v.cbegin(), v.cend(), Traits::eq ) ++#endif ++ ); ++ } ++ ++ nssv_constexpr size_type find( CharT c, size_type pos = 0 ) const nssv_noexcept // (2) ++ { ++ return find( basic_string_view( &c, 1 ), pos ); ++ } ++ ++ nssv_constexpr size_type find( CharT const * s, size_type pos, size_type n ) const // (3) ++ { ++ return find( basic_string_view( s, n ), pos ); ++ } ++ ++ nssv_constexpr size_type find( CharT const * s, size_type pos = 0 ) const // (4) ++ { ++ return find( basic_string_view( s ), pos ); ++ } ++ ++ // rfind(), 4x: ++ ++ nssv_constexpr14 size_type rfind( basic_string_view v, size_type pos = npos ) const nssv_noexcept // (1) ++ { ++ if ( size() < v.size() ) ++ { ++ return npos; ++ } ++ ++ if ( v.empty() ) ++ { ++ return (std::min)( size(), pos ); ++ } ++ ++ const_iterator last = cbegin() + (std::min)( size() - v.size(), pos ) + v.size(); ++ const_iterator result = std::find_end( cbegin(), last, v.cbegin(), v.cend(), Traits::eq ); ++ ++ return result != last ? size_type( result - cbegin() ) : npos; ++ } ++ ++ nssv_constexpr14 size_type rfind( CharT c, size_type pos = npos ) const nssv_noexcept // (2) ++ { ++ return rfind( basic_string_view( &c, 1 ), pos ); ++ } ++ ++ nssv_constexpr14 size_type rfind( CharT const * s, size_type pos, size_type n ) const // (3) ++ { ++ return rfind( basic_string_view( s, n ), pos ); ++ } ++ ++ nssv_constexpr14 size_type rfind( CharT const * s, size_type pos = npos ) const // (4) ++ { ++ return rfind( basic_string_view( s ), pos ); ++ } ++ ++ // find_first_of(), 4x: ++ ++ nssv_constexpr size_type find_first_of( basic_string_view v, size_type pos = 0 ) const nssv_noexcept // (1) ++ { ++ return pos >= size() ++ ? npos ++ : to_pos( std::find_first_of( cbegin() + pos, cend(), v.cbegin(), v.cend(), Traits::eq ) ); ++ } ++ ++ nssv_constexpr size_type find_first_of( CharT c, size_type pos = 0 ) const nssv_noexcept // (2) ++ { ++ return find_first_of( basic_string_view( &c, 1 ), pos ); ++ } ++ ++ nssv_constexpr size_type find_first_of( CharT const * s, size_type pos, size_type n ) const // (3) ++ { ++ return find_first_of( basic_string_view( s, n ), pos ); ++ } ++ ++ nssv_constexpr size_type find_first_of( CharT const * s, size_type pos = 0 ) const // (4) ++ { ++ return find_first_of( basic_string_view( s ), pos ); ++ } ++ ++ // find_last_of(), 4x: ++ ++ nssv_constexpr size_type find_last_of( basic_string_view v, size_type pos = npos ) const nssv_noexcept // (1) ++ { ++ return empty() ++ ? npos ++ : pos >= size() ++ ? find_last_of( v, size() - 1 ) ++ : to_pos( std::find_first_of( const_reverse_iterator( cbegin() + pos + 1 ), crend(), v.cbegin(), v.cend(), Traits::eq ) ); ++ } ++ ++ nssv_constexpr size_type find_last_of( CharT c, size_type pos = npos ) const nssv_noexcept // (2) ++ { ++ return find_last_of( basic_string_view( &c, 1 ), pos ); ++ } ++ ++ nssv_constexpr size_type find_last_of( CharT const * s, size_type pos, size_type count ) const // (3) ++ { ++ return find_last_of( basic_string_view( s, count ), pos ); ++ } ++ ++ nssv_constexpr size_type find_last_of( CharT const * s, size_type pos = npos ) const // (4) ++ { ++ return find_last_of( basic_string_view( s ), pos ); ++ } ++ ++ // find_first_not_of(), 4x: ++ ++ nssv_constexpr size_type find_first_not_of( basic_string_view v, size_type pos = 0 ) const nssv_noexcept // (1) ++ { ++ return pos >= size() ++ ? npos ++ : to_pos( std::find_if( cbegin() + pos, cend(), not_in_view( v ) ) ); ++ } ++ ++ nssv_constexpr size_type find_first_not_of( CharT c, size_type pos = 0 ) const nssv_noexcept // (2) ++ { ++ return find_first_not_of( basic_string_view( &c, 1 ), pos ); ++ } ++ ++ nssv_constexpr size_type find_first_not_of( CharT const * s, size_type pos, size_type count ) const // (3) ++ { ++ return find_first_not_of( basic_string_view( s, count ), pos ); ++ } ++ ++ nssv_constexpr size_type find_first_not_of( CharT const * s, size_type pos = 0 ) const // (4) ++ { ++ return find_first_not_of( basic_string_view( s ), pos ); ++ } ++ ++ // find_last_not_of(), 4x: ++ ++ nssv_constexpr size_type find_last_not_of( basic_string_view v, size_type pos = npos ) const nssv_noexcept // (1) ++ { ++ return empty() ++ ? npos ++ : pos >= size() ++ ? find_last_not_of( v, size() - 1 ) ++ : to_pos( std::find_if( const_reverse_iterator( cbegin() + pos + 1 ), crend(), not_in_view( v ) ) ); ++ } ++ ++ nssv_constexpr size_type find_last_not_of( CharT c, size_type pos = npos ) const nssv_noexcept // (2) ++ { ++ return find_last_not_of( basic_string_view( &c, 1 ), pos ); ++ } ++ ++ nssv_constexpr size_type find_last_not_of( CharT const * s, size_type pos, size_type count ) const // (3) ++ { ++ return find_last_not_of( basic_string_view( s, count ), pos ); ++ } ++ ++ nssv_constexpr size_type find_last_not_of( CharT const * s, size_type pos = npos ) const // (4) ++ { ++ return find_last_not_of( basic_string_view( s ), pos ); ++ } ++ ++ // Constants: ++ ++#if nssv_CPP17_OR_GREATER ++ static nssv_constexpr size_type npos = size_type(-1); ++#elif nssv_CPP11_OR_GREATER ++ enum : size_type { npos = size_type(-1) }; ++#else ++ enum { npos = size_type(-1) }; ++#endif ++ ++private: ++ struct not_in_view ++ { ++ const basic_string_view v; ++ ++ nssv_constexpr explicit not_in_view( basic_string_view v_ ) : v( v_ ) {} ++ ++ nssv_constexpr bool operator()( CharT c ) const ++ { ++ return npos == v.find_first_of( c ); ++ } ++ }; ++ ++ nssv_constexpr size_type to_pos( const_iterator it ) const ++ { ++ return it == cend() ? npos : size_type( it - cbegin() ); ++ } ++ ++ nssv_constexpr size_type to_pos( const_reverse_iterator it ) const ++ { ++ return it == crend() ? npos : size_type( crend() - it - 1 ); ++ } ++ ++ nssv_constexpr const_reference data_at( size_type pos ) const ++ { ++#if nssv_BETWEEN( nssv_COMPILER_GNUC_VERSION, 1, 500 ) ++ return data_[pos]; ++#else ++ return assert( pos < size() ), data_[pos]; ++#endif ++ } ++ ++private: ++ const_pointer data_; ++ size_type size_; ++ ++public: ++#if nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS ++ ++ template< class Allocator > ++ basic_string_view( std::basic_string const & s ) nssv_noexcept ++ : data_( s.data() ) ++ , size_( s.size() ) ++ {} ++ ++#if nssv_HAVE_EXPLICIT_CONVERSION ++ ++ template< class Allocator > ++ explicit operator std::basic_string() const ++ { ++ return to_string( Allocator() ); ++ } ++ ++#endif // nssv_HAVE_EXPLICIT_CONVERSION ++ ++#if nssv_CPP11_OR_GREATER ++ ++ template< class Allocator = std::allocator > ++ std::basic_string ++ to_string( Allocator const & a = Allocator() ) const ++ { ++ return std::basic_string( begin(), end(), a ); ++ } ++ ++#else ++ ++ std::basic_string ++ to_string() const ++ { ++ return std::basic_string( begin(), end() ); ++ } ++ ++ template< class Allocator > ++ std::basic_string ++ to_string( Allocator const & a ) const ++ { ++ return std::basic_string( begin(), end(), a ); ++ } ++ ++#endif // nssv_CPP11_OR_GREATER ++ ++#endif // nssv_CONFIG_CONVERSION_STD_STRING_CLASS_METHODS ++}; ++ ++// ++// Non-member functions: ++// ++ ++// 24.4.3 Non-member comparison functions: ++// lexicographically compare two string views (function template): ++ ++template< class CharT, class Traits > ++nssv_constexpr bool operator== ( ++ basic_string_view lhs, ++ basic_string_view rhs ) nssv_noexcept ++{ return lhs.size() == rhs.size() && lhs.compare( rhs ) == 0; } ++ ++template< class CharT, class Traits > ++nssv_constexpr bool operator!= ( ++ basic_string_view lhs, ++ basic_string_view rhs ) nssv_noexcept ++{ return !( lhs == rhs ); } ++ ++template< class CharT, class Traits > ++nssv_constexpr bool operator< ( ++ basic_string_view lhs, ++ basic_string_view rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) < 0; } ++ ++template< class CharT, class Traits > ++nssv_constexpr bool operator<= ( ++ basic_string_view lhs, ++ basic_string_view rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) <= 0; } ++ ++template< class CharT, class Traits > ++nssv_constexpr bool operator> ( ++ basic_string_view lhs, ++ basic_string_view rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) > 0; } ++ ++template< class CharT, class Traits > ++nssv_constexpr bool operator>= ( ++ basic_string_view lhs, ++ basic_string_view rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) >= 0; } ++ ++// Let S be basic_string_view, and sv be an instance of S. ++// Implementations shall provide sufficient additional overloads marked ++// constexpr and noexcept so that an object t with an implicit conversion ++// to S can be compared according to Table 67. ++ ++#if ! nssv_CPP11_OR_GREATER || nssv_BETWEEN( nssv_COMPILER_MSVC_VERSION, 100, 141 ) ++ ++// accommodate for older compilers: ++ ++// == ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator==( ++ basic_string_view lhs, ++ CharT const * rhs ) nssv_noexcept ++{ return lhs.size() == detail::length( rhs ) && lhs.compare( rhs ) == 0; } ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator==( ++ CharT const * lhs, ++ basic_string_view rhs ) nssv_noexcept ++{ return detail::length( lhs ) == rhs.size() && rhs.compare( lhs ) == 0; } ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator==( ++ basic_string_view lhs, ++ std::basic_string rhs ) nssv_noexcept ++{ return lhs.size() == rhs.size() && lhs.compare( rhs ) == 0; } ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator==( ++ std::basic_string rhs, ++ basic_string_view lhs ) nssv_noexcept ++{ return lhs.size() == rhs.size() && lhs.compare( rhs ) == 0; } ++ ++// != ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator!=( ++ basic_string_view lhs, ++ CharT const * rhs ) nssv_noexcept ++{ return !( lhs == rhs ); } ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator!=( ++ CharT const * lhs, ++ basic_string_view rhs ) nssv_noexcept ++{ return !( lhs == rhs ); } ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator!=( ++ basic_string_view lhs, ++ std::basic_string rhs ) nssv_noexcept ++{ return !( lhs == rhs ); } ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator!=( ++ std::basic_string rhs, ++ basic_string_view lhs ) nssv_noexcept ++{ return !( lhs == rhs ); } ++ ++// < ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator<( ++ basic_string_view lhs, ++ CharT const * rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) < 0; } ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator<( ++ CharT const * lhs, ++ basic_string_view rhs ) nssv_noexcept ++{ return rhs.compare( lhs ) > 0; } ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator<( ++ basic_string_view lhs, ++ std::basic_string rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) < 0; } ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator<( ++ std::basic_string rhs, ++ basic_string_view lhs ) nssv_noexcept ++{ return rhs.compare( lhs ) > 0; } ++ ++// <= ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator<=( ++ basic_string_view lhs, ++ CharT const * rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) <= 0; } ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator<=( ++ CharT const * lhs, ++ basic_string_view rhs ) nssv_noexcept ++{ return rhs.compare( lhs ) >= 0; } ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator<=( ++ basic_string_view lhs, ++ std::basic_string rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) <= 0; } ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator<=( ++ std::basic_string rhs, ++ basic_string_view lhs ) nssv_noexcept ++{ return rhs.compare( lhs ) >= 0; } ++ ++// > ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator>( ++ basic_string_view lhs, ++ CharT const * rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) > 0; } ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator>( ++ CharT const * lhs, ++ basic_string_view rhs ) nssv_noexcept ++{ return rhs.compare( lhs ) < 0; } ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator>( ++ basic_string_view lhs, ++ std::basic_string rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) > 0; } ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator>( ++ std::basic_string rhs, ++ basic_string_view lhs ) nssv_noexcept ++{ return rhs.compare( lhs ) < 0; } ++ ++// >= ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator>=( ++ basic_string_view lhs, ++ CharT const * rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) >= 0; } ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator>=( ++ CharT const * lhs, ++ basic_string_view rhs ) nssv_noexcept ++{ return rhs.compare( lhs ) <= 0; } ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator>=( ++ basic_string_view lhs, ++ std::basic_string rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) >= 0; } ++ ++template< class CharT, class Traits> ++nssv_constexpr bool operator>=( ++ std::basic_string rhs, ++ basic_string_view lhs ) nssv_noexcept ++{ return rhs.compare( lhs ) <= 0; } ++ ++#else // newer compilers: ++ ++#define nssv_BASIC_STRING_VIEW_I(T,U) typename std::decay< basic_string_view >::type ++ ++#if defined(_MSC_VER) // issue 40 ++# define nssv_MSVC_ORDER(x) , int=x ++#else ++# define nssv_MSVC_ORDER(x) /*, int=x*/ ++#endif ++ ++// == ++ ++template< class CharT, class Traits nssv_MSVC_ORDER(1) > ++nssv_constexpr bool operator==( ++ basic_string_view lhs, ++ nssv_BASIC_STRING_VIEW_I(CharT, Traits) rhs ) nssv_noexcept ++{ return lhs.size() == rhs.size() && lhs.compare( rhs ) == 0; } ++ ++template< class CharT, class Traits nssv_MSVC_ORDER(2) > ++nssv_constexpr bool operator==( ++ nssv_BASIC_STRING_VIEW_I(CharT, Traits) lhs, ++ basic_string_view rhs ) nssv_noexcept ++{ return lhs.size() == rhs.size() && lhs.compare( rhs ) == 0; } ++ ++// != ++ ++template< class CharT, class Traits nssv_MSVC_ORDER(1) > ++nssv_constexpr bool operator!= ( ++ basic_string_view < CharT, Traits > lhs, ++ nssv_BASIC_STRING_VIEW_I( CharT, Traits ) rhs ) nssv_noexcept ++{ return !( lhs == rhs ); } ++ ++template< class CharT, class Traits nssv_MSVC_ORDER(2) > ++nssv_constexpr bool operator!= ( ++ nssv_BASIC_STRING_VIEW_I( CharT, Traits ) lhs, ++ basic_string_view < CharT, Traits > rhs ) nssv_noexcept ++{ return !( lhs == rhs ); } ++ ++// < ++ ++template< class CharT, class Traits nssv_MSVC_ORDER(1) > ++nssv_constexpr bool operator< ( ++ basic_string_view < CharT, Traits > lhs, ++ nssv_BASIC_STRING_VIEW_I( CharT, Traits ) rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) < 0; } ++ ++template< class CharT, class Traits nssv_MSVC_ORDER(2) > ++nssv_constexpr bool operator< ( ++ nssv_BASIC_STRING_VIEW_I( CharT, Traits ) lhs, ++ basic_string_view < CharT, Traits > rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) < 0; } ++ ++// <= ++ ++template< class CharT, class Traits nssv_MSVC_ORDER(1) > ++nssv_constexpr bool operator<= ( ++ basic_string_view < CharT, Traits > lhs, ++ nssv_BASIC_STRING_VIEW_I( CharT, Traits ) rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) <= 0; } ++ ++template< class CharT, class Traits nssv_MSVC_ORDER(2) > ++nssv_constexpr bool operator<= ( ++ nssv_BASIC_STRING_VIEW_I( CharT, Traits ) lhs, ++ basic_string_view < CharT, Traits > rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) <= 0; } ++ ++// > ++ ++template< class CharT, class Traits nssv_MSVC_ORDER(1) > ++nssv_constexpr bool operator> ( ++ basic_string_view < CharT, Traits > lhs, ++ nssv_BASIC_STRING_VIEW_I( CharT, Traits ) rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) > 0; } ++ ++template< class CharT, class Traits nssv_MSVC_ORDER(2) > ++nssv_constexpr bool operator> ( ++ nssv_BASIC_STRING_VIEW_I( CharT, Traits ) lhs, ++ basic_string_view < CharT, Traits > rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) > 0; } ++ ++// >= ++ ++template< class CharT, class Traits nssv_MSVC_ORDER(1) > ++nssv_constexpr bool operator>= ( ++ basic_string_view < CharT, Traits > lhs, ++ nssv_BASIC_STRING_VIEW_I( CharT, Traits ) rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) >= 0; } ++ ++template< class CharT, class Traits nssv_MSVC_ORDER(2) > ++nssv_constexpr bool operator>= ( ++ nssv_BASIC_STRING_VIEW_I( CharT, Traits ) lhs, ++ basic_string_view < CharT, Traits > rhs ) nssv_noexcept ++{ return lhs.compare( rhs ) >= 0; } ++ ++#undef nssv_MSVC_ORDER ++#undef nssv_BASIC_STRING_VIEW_I ++ ++#endif // compiler-dependent approach to comparisons ++ ++// 24.4.4 Inserters and extractors: ++ ++#if ! nssv_CONFIG_NO_STREAM_INSERTION ++ ++namespace detail { ++ ++template< class Stream > ++void write_padding( Stream & os, std::streamsize n ) ++{ ++ for ( std::streamsize i = 0; i < n; ++i ) ++ os.rdbuf()->sputc( os.fill() ); ++} ++ ++template< class Stream, class View > ++Stream & write_to_stream( Stream & os, View const & sv ) ++{ ++ typename Stream::sentry sentry( os ); ++ ++ if ( !sentry ) ++ return os; ++ ++ const std::streamsize length = static_cast( sv.length() ); ++ ++ // Whether, and how, to pad: ++ const bool pad = ( length < os.width() ); ++ const bool left_pad = pad && ( os.flags() & std::ios_base::adjustfield ) == std::ios_base::right; ++ ++ if ( left_pad ) ++ write_padding( os, os.width() - length ); ++ ++ // Write span characters: ++ os.rdbuf()->sputn( sv.begin(), length ); ++ ++ if ( pad && !left_pad ) ++ write_padding( os, os.width() - length ); ++ ++ // Reset output stream width: ++ os.width( 0 ); ++ ++ return os; ++} ++ ++} // namespace detail ++ ++template< class CharT, class Traits > ++std::basic_ostream & ++operator<<( ++ std::basic_ostream& os, ++ basic_string_view sv ) ++{ ++ return detail::write_to_stream( os, sv ); ++} ++ ++#endif // nssv_CONFIG_NO_STREAM_INSERTION ++ ++// Several typedefs for common character types are provided: ++ ++typedef basic_string_view string_view; ++typedef basic_string_view wstring_view; ++#if nssv_HAVE_WCHAR16_T ++typedef basic_string_view u16string_view; ++typedef basic_string_view u32string_view; ++#endif ++ ++}} // namespace nonstd::sv_lite ++ ++// ++// 24.4.6 Suffix for basic_string_view literals: ++// ++ ++#if nssv_HAVE_USER_DEFINED_LITERALS ++ ++namespace nonstd { ++nssv_inline_ns namespace literals { ++nssv_inline_ns namespace string_view_literals { ++ ++#if nssv_CONFIG_STD_SV_OPERATOR && nssv_HAVE_STD_DEFINED_LITERALS ++ ++nssv_constexpr nonstd::sv_lite::string_view operator "" sv( const char* str, size_t len ) nssv_noexcept // (1) ++{ ++ return nonstd::sv_lite::string_view{ str, len }; ++} ++ ++nssv_constexpr nonstd::sv_lite::u16string_view operator "" sv( const char16_t* str, size_t len ) nssv_noexcept // (2) ++{ ++ return nonstd::sv_lite::u16string_view{ str, len }; ++} ++ ++nssv_constexpr nonstd::sv_lite::u32string_view operator "" sv( const char32_t* str, size_t len ) nssv_noexcept // (3) ++{ ++ return nonstd::sv_lite::u32string_view{ str, len }; ++} ++ ++nssv_constexpr nonstd::sv_lite::wstring_view operator "" sv( const wchar_t* str, size_t len ) nssv_noexcept // (4) ++{ ++ return nonstd::sv_lite::wstring_view{ str, len }; ++} ++ ++#endif // nssv_CONFIG_STD_SV_OPERATOR && nssv_HAVE_STD_DEFINED_LITERALS ++ ++#if nssv_CONFIG_USR_SV_OPERATOR ++ ++nssv_constexpr nonstd::sv_lite::string_view operator "" _sv( const char* str, size_t len ) nssv_noexcept // (1) ++{ ++ return nonstd::sv_lite::string_view{ str, len }; ++} ++ ++nssv_constexpr nonstd::sv_lite::u16string_view operator "" _sv( const char16_t* str, size_t len ) nssv_noexcept // (2) ++{ ++ return nonstd::sv_lite::u16string_view{ str, len }; ++} ++ ++nssv_constexpr nonstd::sv_lite::u32string_view operator "" _sv( const char32_t* str, size_t len ) nssv_noexcept // (3) ++{ ++ return nonstd::sv_lite::u32string_view{ str, len }; ++} ++ ++nssv_constexpr nonstd::sv_lite::wstring_view operator "" _sv( const wchar_t* str, size_t len ) nssv_noexcept // (4) ++{ ++ return nonstd::sv_lite::wstring_view{ str, len }; ++} ++ ++#endif // nssv_CONFIG_USR_SV_OPERATOR ++ ++}}} // namespace nonstd::literals::string_view_literals ++ ++#endif ++ ++// ++// Extensions for std::string: ++// ++ ++#if nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS ++ ++namespace nonstd { ++namespace sv_lite { ++ ++// Exclude MSVC 14 (19.00): it yields ambiguous to_string(): ++ ++#if nssv_CPP11_OR_GREATER && nssv_COMPILER_MSVC_VERSION != 140 ++ ++template< class CharT, class Traits, class Allocator = std::allocator > ++std::basic_string ++to_string( basic_string_view v, Allocator const & a = Allocator() ) ++{ ++ return std::basic_string( v.begin(), v.end(), a ); ++} ++ ++#else ++ ++template< class CharT, class Traits > ++std::basic_string ++to_string( basic_string_view v ) ++{ ++ return std::basic_string( v.begin(), v.end() ); ++} ++ ++template< class CharT, class Traits, class Allocator > ++std::basic_string ++to_string( basic_string_view v, Allocator const & a ) ++{ ++ return std::basic_string( v.begin(), v.end(), a ); ++} ++ ++#endif // nssv_CPP11_OR_GREATER ++ ++template< class CharT, class Traits, class Allocator > ++basic_string_view ++to_string_view( std::basic_string const & s ) ++{ ++ return basic_string_view( s.data(), s.size() ); ++} ++ ++}} // namespace nonstd::sv_lite ++ ++#endif // nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS ++ ++// ++// make types and algorithms available in namespace nonstd: ++// ++ ++namespace nonstd { ++ ++using sv_lite::basic_string_view; ++using sv_lite::string_view; ++using sv_lite::wstring_view; ++ ++#if nssv_HAVE_WCHAR16_T ++using sv_lite::u16string_view; ++#endif ++#if nssv_HAVE_WCHAR32_T ++using sv_lite::u32string_view; ++#endif ++ ++// literal "sv" ++ ++using sv_lite::operator==; ++using sv_lite::operator!=; ++using sv_lite::operator<; ++using sv_lite::operator<=; ++using sv_lite::operator>; ++using sv_lite::operator>=; ++ ++#if ! nssv_CONFIG_NO_STREAM_INSERTION ++using sv_lite::operator<<; ++#endif ++ ++#if nssv_CONFIG_CONVERSION_STD_STRING_FREE_FUNCTIONS ++using sv_lite::to_string; ++using sv_lite::to_string_view; ++#endif ++ ++} // namespace nonstd ++ ++// 24.4.5 Hash support (C++11): ++ ++// Note: The hash value of a string view object is equal to the hash value of ++// the corresponding string object. ++ ++#if nssv_HAVE_STD_HASH ++ ++#include ++ ++namespace std { ++ ++template<> ++struct hash< nonstd::string_view > ++{ ++public: ++ std::size_t operator()( nonstd::string_view v ) const nssv_noexcept ++ { ++ return std::hash()( std::string( v.data(), v.size() ) ); ++ } ++}; ++ ++template<> ++struct hash< nonstd::wstring_view > ++{ ++public: ++ std::size_t operator()( nonstd::wstring_view v ) const nssv_noexcept ++ { ++ return std::hash()( std::wstring( v.data(), v.size() ) ); ++ } ++}; ++ ++template<> ++struct hash< nonstd::u16string_view > ++{ ++public: ++ std::size_t operator()( nonstd::u16string_view v ) const nssv_noexcept ++ { ++ return std::hash()( std::u16string( v.data(), v.size() ) ); ++ } ++}; ++ ++template<> ++struct hash< nonstd::u32string_view > ++{ ++public: ++ std::size_t operator()( nonstd::u32string_view v ) const nssv_noexcept ++ { ++ return std::hash()( std::u32string( v.data(), v.size() ) ); ++ } ++}; ++ ++} // namespace std ++ ++#endif // nssv_HAVE_STD_HASH ++ ++nssv_RESTORE_WARNINGS() ++ ++#endif // nssv_HAVE_STD_STRING_VIEW ++#endif // NONSTD_SV_LITE_H_INCLUDED +diff --git a/src/HeaderVector.cpp b/src/HeaderVector.cpp +index e417d7b2..2a9c7313 100644 +--- a/src/HeaderVector.cpp ++++ b/src/HeaderVector.cpp +@@ -27,8 +27,13 @@ + + std::string HeaderVector::getFieldParameter(const std::string_view reqHeader) const { + for (const std::string &header : _vector) { ++#ifndef NEED_BACKPORT + const auto b = header.find(reqHeader, 0); + const auto e = header.find_first_not_of(reqHeader, b); ++#else ++ const auto b = header.find(std::string{reqHeader}, 0); ++ const auto e = header.find_first_not_of(std::string{reqHeader}, b); ++#endif + if (b != std::string::npos && reqHeader.size() == e && header[e] == ':') { + return StringConverter::trimWhitespace(header.substr(e + 1)); + } +@@ -44,7 +49,11 @@ std::string HeaderVector::getStringFieldParameter(std::string_view header, + } + StringVector params = StringConverter::split(field, ";\r\n"); + for (const std::string ¶m : params) { ++#ifndef NEED_BACKPORT + const auto p = param.find(parameter, 0); ++#else ++ const auto p = param.find(std::string{parameter}, 0); ++#endif + if (p != std::string::npos) { + StringVector r = StringConverter::split(param, "="); + return r.size() == 2 ? StringConverter::trimWhitespace(r[1]) : std::string(); +diff --git a/src/HttpcServer.cpp b/src/HttpcServer.cpp +index 74e8961d..18948a22 100644 +--- a/src/HttpcServer.cpp ++++ b/src/HttpcServer.cpp +@@ -159,7 +159,14 @@ void HttpcServer::processStreamingRequest(SocketClient &client) { + const std::string sessionID = headers.getFieldParameter("Session"); + const StreamID streamID = params.getIntParameter("stream"); + // Find the FeID with requesed StreamID ++#ifndef NEED_BACKPORT + const auto [feIndex, feID] = _streamManager.findFrontendIDWithStreamID(streamID); ++#else ++ const auto retval = _streamManager.findFrontendIDWithStreamID(streamID); ++ const auto feIndex = std::get<0>(retval); ++ const auto feID = std::get<1>(retval); ++ (void) feID; /* unused */ ++#endif + + const std::string method = client.getMethod(); + std::string httpcReply; +diff --git a/src/StreamManager.cpp b/src/StreamManager.cpp +index 796688a3..6d091ac1 100644 +--- a/src/StreamManager.cpp ++++ b/src/StreamManager.cpp +@@ -139,7 +139,13 @@ std::tuple StreamManager::findFrontendID(const Transpor + FeID feID = params.getIntParameter("fe"); + // Did we find StreamID an NO FrondendID + if (streamID != -1 && feID == -1) { ++#ifndef NEED_BACKPORT + const auto [index, feID] = findFrontendIDWithStreamID(streamID); ++#else ++ const auto retval = findFrontendIDWithStreamID(streamID); ++ const auto index = std::get<0>(retval); ++ const auto feID = std::get<1>(retval); ++#endif + return { index, feID, streamID }; + } + // Is the requested FrondendID in range, then return this +@@ -158,7 +164,14 @@ SpStream StreamManager::findStreamAndClientIDFor(SocketClient &socketClient, int + TransportParamVector params = socketClient.getTransportParameters(); + + // Now find index for FrontendID and/or StreamID of this message ++#ifndef NEED_BACKPORT + const auto [feIndex, feID, streamID] = findFrontendID(params); ++#else ++ const auto retval = findFrontendID(params); ++ const auto feIndex = std::get<0>(retval); ++ const auto feID = std::get<1>(retval); ++ const auto streamID = std::get<2>(retval); ++#endif + + std::string sessionID = headers.getFieldParameter("Session"); + bool newSession = false; +diff --git a/src/TransportParamVector.cpp b/src/TransportParamVector.cpp +index 2ea8043c..8747fcb2 100644 +--- a/src/TransportParamVector.cpp ++++ b/src/TransportParamVector.cpp +@@ -28,8 +28,13 @@ + + std::string TransportParamVector::getParameter(const std::string_view parameter) const { + for (const std::string ¶m : _vector) { ++#ifndef NEED_BACKPORT + const auto b = param.find(parameter, 0); + const auto e = param.find_first_not_of(parameter, b); ++#else ++ const auto b = param.find(std::string{parameter}, 0); ++ const auto e = param.find_first_not_of(std::string{parameter}, b); ++#endif + if (b != std::string::npos && parameter.size() == e && param[e] == '=') { + return StringConverter::trimWhitespace(param.substr(e + 1)); + } +@@ -41,12 +46,21 @@ void TransportParamVector::replaceParameter( + const std::string_view parameter, + const std::string_view value) { + for (std::string ¶m : _vector) { ++#ifndef NEED_BACKPORT + const auto b = param.find(parameter, 0); + const auto e = param.find_first_not_of(parameter, b); ++#else ++ const auto b = param.find(std::string{parameter}, 0); ++ const auto e = param.find_first_not_of(std::string{parameter}, b); ++#endif + if (b != std::string::npos && parameter.size() == e && param[e] == '=') { + // Found parameter, so change and return + param.erase(e + 1); ++#ifndef NEED_BACKPORT + param += value; ++#else ++ param += std::string{value}; ++#endif + return; + } + } +diff --git a/src/input/dvb/delivery/DiSEqcSwitch.cpp b/src/input/dvb/delivery/DiSEqcSwitch.cpp +index 20c8722a..10d65f87 100644 +--- a/src/input/dvb/delivery/DiSEqcSwitch.cpp ++++ b/src/input/dvb/delivery/DiSEqcSwitch.cpp +@@ -61,7 +61,9 @@ namespace input::dvb::delivery { + default: + cmd.msg[1] = 0x10; + cmd.msg[2] = 0x38; ++#ifndef NEED_BACKPORT + [[fallthrough]]; ++#endif + case 0x10: + switch (_switchType) { + default: +diff --git a/src/mpegts/NIT.cpp b/src/mpegts/NIT.cpp +index 43d21ac9..542f0eef 100644 +--- a/src/mpegts/NIT.cpp ++++ b/src/mpegts/NIT.cpp +@@ -260,7 +260,14 @@ mpegts::TSData NIT::generateFrom( + mpegts::TSData data; + + int prognr = 0; ++#ifndef NEED_BACKPORT + for (auto [freq, element] : info) { ++#else ++ for (auto entry : info) { ++ auto freq = entry.first; ++ auto element = entry.second; ++ (void) freq; /* unused */ ++#endif + SI_LOG_DEBUG("Frontend: @#1, Generating NIT: Prog NR: @#2 - @#3 PMT PID: @#4", + id, HEX(prognr, 4), DIGIT(prognr, 5), element.freq); + } +diff --git a/src/mpegts/PAT.cpp b/src/mpegts/PAT.cpp +index 78ce818f..f6316ee9 100644 +--- a/src/mpegts/PAT.cpp ++++ b/src/mpegts/PAT.cpp +@@ -82,7 +82,14 @@ mpegts::TSData PAT::generateFrom( + + int transportStreamID = 0; + int prognr = 0; ++#ifndef NEED_BACKPORT + for (auto [freq, element] : info) { ++#else ++ for (auto entry : info) { ++ auto freq = entry.first; ++ auto element = entry.second; ++ (void) freq; /* unused */ ++#endif + SI_LOG_DEBUG("Frontend: @#1, Generating PAT: TID: @#2 Prog NR: @#3 - @#4 PMT PID: @#5", + id, transportStreamID, HEX(prognr, 4), DIGIT(prognr, 5), element.freq); + } +diff --git a/src/upnp/ssdp/Server.cpp b/src/upnp/ssdp/Server.cpp +index 69de737e..bbe529b1 100644 +--- a/src/upnp/ssdp/Server.cpp ++++ b/src/upnp/ssdp/Server.cpp +@@ -227,7 +227,11 @@ void Server::checkDefendDeviceID( + } + } else if (servers.find(otherDeviceID) == servers.end()) { + SI_LOG_INFO("Found SAT>IP Server @#1: with DEVICEID @#2", ip_addr, otherDeviceID); ++#ifndef NEED_BACKPORT + servers[otherDeviceID] = ip_addr; ++#else ++ servers[otherDeviceID] = std::string{ip_addr}; ++#endif + } + } +