diff options
author | V3n3RiX <venerix@redcorelinux.org> | 2021-07-17 19:04:28 +0100 |
---|---|---|
committer | V3n3RiX <venerix@redcorelinux.org> | 2021-07-17 19:04:28 +0100 |
commit | 514d1bbe260df2521fe60f1a3ec87cfcfde1a829 (patch) | |
tree | 555c194dbeb0fb2ac4ad3cde7c0f6a80fd330ce2 /app-admin/lnav/files/lnav-0.9.0-bug786456.patch | |
parent | 4df3bf9762850b34cd1ead5c80374d1a0fc3362e (diff) |
gentoo resync : 17.07.2021
Diffstat (limited to 'app-admin/lnav/files/lnav-0.9.0-bug786456.patch')
-rw-r--r-- | app-admin/lnav/files/lnav-0.9.0-bug786456.patch | 561 |
1 files changed, 561 insertions, 0 deletions
diff --git a/app-admin/lnav/files/lnav-0.9.0-bug786456.patch b/app-admin/lnav/files/lnav-0.9.0-bug786456.patch new file mode 100644 index 000000000000..e77dd17854e5 --- /dev/null +++ b/app-admin/lnav/files/lnav-0.9.0-bug786456.patch @@ -0,0 +1,561 @@ +From e6d2e2d2b95c27cc85397d4af9528111c5304d02 Mon Sep 17 00:00:00 2001 +From: Timothy Stack <timothyshanestack@gmail.com> +Date: Sun, 30 May 2021 13:33:05 -0700 +Subject: [PATCH] [logfile] add notes for automatic decisions and fix compile + errors + +Fixes #864 + +Signed-off-by: Randy Barlow <randy@electronsweatshop.com> +--- + m4/ax_cxx_compile_stdcxx.m4 | 462 +++++++++++++++++++++++++++++++++--- + src/base/result.h | 1 + + src/logfile.hh | 13 + + src/optional.hpp | 45 +++- + src/pcrepp/pcrepp.hh | 1 + + 5 files changed, 482 insertions(+), 40 deletions(-) + +diff --git a/m4/ax_cxx_compile_stdcxx.m4 b/m4/ax_cxx_compile_stdcxx.m4 +index 2c18e49c..9413da62 100644 +--- a/m4/ax_cxx_compile_stdcxx.m4 ++++ b/m4/ax_cxx_compile_stdcxx.m4 +@@ -1,5 +1,5 @@ + # =========================================================================== +-# http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html ++# https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html + # =========================================================================== + # + # SYNOPSIS +@@ -16,7 +16,7 @@ + # The second argument, if specified, indicates whether you insist on an + # extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g. + # -std=c++11). If neither is specified, you get whatever works, with +-# preference for an extended mode. ++# preference for no added switch, and then for an extended mode. + # + # The third argument, if specified 'mandatory' or if left unspecified, + # indicates that baseline support for the specified C++ standard is +@@ -33,21 +33,24 @@ + # Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com> + # Copyright (c) 2015 Paul Norman <penorman@mac.com> + # Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu> ++# Copyright (c) 2016, 2018 Krzesimir Nowak <qdlacz@gmail.com> ++# Copyright (c) 2019 Enji Cooper <yaneurabeya@gmail.com> ++# Copyright (c) 2020 Jason Merrill <jason@redhat.com> + # + # Copying and distribution of this file, with or without modification, are + # permitted in any medium without royalty provided the copyright notice + # and this notice are preserved. This file is offered as-is, without any + # warranty. + +-#serial 4 ++#serial 12 + + dnl This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro + dnl (serial version number 13). + + AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl +- m4_if([$1], [11], [], +- [$1], [14], [], +- [$1], [17], [m4_fatal([support for C++17 not yet implemented in AX_CXX_COMPILE_STDCXX])], ++ m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"], ++ [$1], [14], [ax_cxx_compile_alternatives="14 1y"], ++ [$1], [17], [ax_cxx_compile_alternatives="17 1z"], + [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl + m4_if([$2], [], [], + [$2], [ext], [], +@@ -59,18 +62,21 @@ AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl + [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])]) + AC_LANG_PUSH([C++])dnl + ac_success=no +- AC_CACHE_CHECK(whether $CXX supports C++$1 features by default, +- ax_cv_cxx_compile_cxx$1, +- [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], +- [ax_cv_cxx_compile_cxx$1=yes], +- [ax_cv_cxx_compile_cxx$1=no])]) +- if test x$ax_cv_cxx_compile_cxx$1 = xyes; then +- ac_success=yes +- fi ++ ++ m4_if([$2], [], [dnl ++ AC_CACHE_CHECK(whether $CXX supports C++$1 features by default, ++ ax_cv_cxx_compile_cxx$1, ++ [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], ++ [ax_cv_cxx_compile_cxx$1=yes], ++ [ax_cv_cxx_compile_cxx$1=no])]) ++ if test x$ax_cv_cxx_compile_cxx$1 = xyes; then ++ ac_success=yes ++ fi]) + + m4_if([$2], [noext], [], [dnl + if test x$ac_success = xno; then +- for switch in -std=gnu++$1 -std=gnu++0x; do ++ for alternative in ${ax_cxx_compile_alternatives}; do ++ switch="-std=gnu++${alternative}" + cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) + AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch, + $cachevar, +@@ -96,22 +102,27 @@ AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl + dnl HP's aCC needs +std=c++11 according to: + dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf + dnl Cray's crayCC needs "-h std=c++11" +- for switch in -std=c++$1 -std=c++0x +std=c++$1 "-h std=c++$1"; do +- cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) +- AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch, +- $cachevar, +- [ac_save_CXX="$CXX" +- CXX="$CXX $switch" +- AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], +- [eval $cachevar=yes], +- [eval $cachevar=no]) +- CXX="$ac_save_CXX"]) +- if eval test x\$$cachevar = xyes; then +- CXX="$CXX $switch" +- if test -n "$CXXCPP" ; then +- CXXCPP="$CXXCPP $switch" ++ for alternative in ${ax_cxx_compile_alternatives}; do ++ for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do ++ cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) ++ AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch, ++ $cachevar, ++ [ac_save_CXX="$CXX" ++ CXX="$CXX $switch" ++ AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], ++ [eval $cachevar=yes], ++ [eval $cachevar=no]) ++ CXX="$ac_save_CXX"]) ++ if eval test x\$$cachevar = xyes; then ++ CXX="$CXX $switch" ++ if test -n "$CXXCPP" ; then ++ CXXCPP="$CXXCPP $switch" ++ fi ++ ac_success=yes ++ break + fi +- ac_success=yes ++ done ++ if test x$ac_success = xyes; then + break + fi + done +@@ -148,6 +159,11 @@ m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 + ) + ++m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17], ++ _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 ++ _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 ++ _AX_CXX_COMPILE_STDCXX_testbody_new_in_17 ++) + + dnl Tests for new features in C++11 + +@@ -185,11 +201,13 @@ namespace cxx11 + + struct Base + { ++ virtual ~Base() {} + virtual void f() {} + }; + + struct Derived : public Base + { ++ virtual ~Derived() override {} + virtual void f() override {} + }; + +@@ -518,7 +536,7 @@ namespace cxx14 + + } + +- namespace test_digit_seperators ++ namespace test_digit_separators + { + + constexpr auto ten_million = 100'000'000; +@@ -560,3 +578,385 @@ namespace cxx14 + #endif // __cplusplus >= 201402L + + ]]) ++ ++ ++dnl Tests for new features in C++17 ++ ++m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[ ++ ++// If the compiler admits that it is not ready for C++17, why torture it? ++// Hopefully, this will speed up the test. ++ ++#ifndef __cplusplus ++ ++#error "This is not a C++ compiler" ++ ++#elif __cplusplus < 201703L ++ ++#error "This is not a C++17 compiler" ++ ++#else ++ ++#include <initializer_list> ++#include <utility> ++#include <type_traits> ++ ++namespace cxx17 ++{ ++ ++ namespace test_constexpr_lambdas ++ { ++ ++ constexpr int foo = [](){return 42;}(); ++ ++ } ++ ++ namespace test::nested_namespace::definitions ++ { ++ ++ } ++ ++ namespace test_fold_expression ++ { ++ ++ template<typename... Args> ++ int multiply(Args... args) ++ { ++ return (args * ... * 1); ++ } ++ ++ template<typename... Args> ++ bool all(Args... args) ++ { ++ return (args && ...); ++ } ++ ++ } ++ ++ namespace test_extended_static_assert ++ { ++ ++ static_assert (true); ++ ++ } ++ ++ namespace test_auto_brace_init_list ++ { ++ ++ auto foo = {5}; ++ auto bar {5}; ++ ++ static_assert(std::is_same<std::initializer_list<int>, decltype(foo)>::value); ++ static_assert(std::is_same<int, decltype(bar)>::value); ++ } ++ ++ namespace test_typename_in_template_template_parameter ++ { ++ ++ template<template<typename> typename X> struct D; ++ ++ } ++ ++ namespace test_fallthrough_nodiscard_maybe_unused_attributes ++ { ++ ++ int f1() ++ { ++ return 42; ++ } ++ ++ [[nodiscard]] int f2() ++ { ++ [[maybe_unused]] auto unused = f1(); ++ ++ switch (f1()) ++ { ++ case 17: ++ f1(); ++ [[fallthrough]]; ++ case 42: ++ f1(); ++ } ++ return f1(); ++ } ++ ++ } ++ ++ namespace test_extended_aggregate_initialization ++ { ++ ++ struct base1 ++ { ++ int b1, b2 = 42; ++ }; ++ ++ struct base2 ++ { ++ base2() { ++ b3 = 42; ++ } ++ int b3; ++ }; ++ ++ struct derived : base1, base2 ++ { ++ int d; ++ }; ++ ++ derived d1 {{1, 2}, {}, 4}; // full initialization ++ derived d2 {{}, {}, 4}; // value-initialized bases ++ ++ } ++ ++ namespace test_general_range_based_for_loop ++ { ++ ++ struct iter ++ { ++ int i; ++ ++ int& operator* () ++ { ++ return i; ++ } ++ ++ const int& operator* () const ++ { ++ return i; ++ } ++ ++ iter& operator++() ++ { ++ ++i; ++ return *this; ++ } ++ }; ++ ++ struct sentinel ++ { ++ int i; ++ }; ++ ++ bool operator== (const iter& i, const sentinel& s) ++ { ++ return i.i == s.i; ++ } ++ ++ bool operator!= (const iter& i, const sentinel& s) ++ { ++ return !(i == s); ++ } ++ ++ struct range ++ { ++ iter begin() const ++ { ++ return {0}; ++ } ++ ++ sentinel end() const ++ { ++ return {5}; ++ } ++ }; ++ ++ void f() ++ { ++ range r {}; ++ ++ for (auto i : r) ++ { ++ [[maybe_unused]] auto v = i; ++ } ++ } ++ ++ } ++ ++ namespace test_lambda_capture_asterisk_this_by_value ++ { ++ ++ struct t ++ { ++ int i; ++ int foo() ++ { ++ return [*this]() ++ { ++ return i; ++ }(); ++ } ++ }; ++ ++ } ++ ++ namespace test_enum_class_construction ++ { ++ ++ enum class byte : unsigned char ++ {}; ++ ++ byte foo {42}; ++ ++ } ++ ++ namespace test_constexpr_if ++ { ++ ++ template <bool cond> ++ int f () ++ { ++ if constexpr(cond) ++ { ++ return 13; ++ } ++ else ++ { ++ return 42; ++ } ++ } ++ ++ } ++ ++ namespace test_selection_statement_with_initializer ++ { ++ ++ int f() ++ { ++ return 13; ++ } ++ ++ int f2() ++ { ++ if (auto i = f(); i > 0) ++ { ++ return 3; ++ } ++ ++ switch (auto i = f(); i + 4) ++ { ++ case 17: ++ return 2; ++ ++ default: ++ return 1; ++ } ++ } ++ ++ } ++ ++ namespace test_template_argument_deduction_for_class_templates ++ { ++ ++ template <typename T1, typename T2> ++ struct pair ++ { ++ pair (T1 p1, T2 p2) ++ : m1 {p1}, ++ m2 {p2} ++ {} ++ ++ T1 m1; ++ T2 m2; ++ }; ++ ++ void f() ++ { ++ [[maybe_unused]] auto p = pair{13, 42u}; ++ } ++ ++ } ++ ++ namespace test_non_type_auto_template_parameters ++ { ++ ++ template <auto n> ++ struct B ++ {}; ++ ++ B<5> b1; ++ B<'a'> b2; ++ ++ } ++ ++ namespace test_structured_bindings ++ { ++ ++ int arr[2] = { 1, 2 }; ++ std::pair<int, int> pr = { 1, 2 }; ++ ++ auto f1() -> int(&)[2] ++ { ++ return arr; ++ } ++ ++ auto f2() -> std::pair<int, int>& ++ { ++ return pr; ++ } ++ ++ struct S ++ { ++ int x1 : 2; ++ volatile double y1; ++ }; ++ ++ S f3() ++ { ++ return {}; ++ } ++ ++ auto [ x1, y1 ] = f1(); ++ auto& [ xr1, yr1 ] = f1(); ++ auto [ x2, y2 ] = f2(); ++ auto& [ xr2, yr2 ] = f2(); ++ const auto [ x3, y3 ] = f3(); ++ ++ } ++ ++ namespace test_exception_spec_type_system ++ { ++ ++ struct Good {}; ++ struct Bad {}; ++ ++ void g1() noexcept; ++ void g2(); ++ ++ template<typename T> ++ Bad ++ f(T*, T*); ++ ++ template<typename T1, typename T2> ++ Good ++ f(T1*, T2*); ++ ++ static_assert (std::is_same_v<Good, decltype(f(g1, g2))>); ++ ++ } ++ ++ namespace test_inline_variables ++ { ++ ++ template<class T> void f(T) ++ {} ++ ++ template<class T> inline T g(T) ++ { ++ return T{}; ++ } ++ ++ template<> inline void f<>(int) ++ {} ++ ++ template<> int g<>(int) ++ { ++ return 5; ++ } ++ ++ } ++ ++} // namespace cxx17 ++ ++#endif // __cplusplus < 201703L ++ ++]]) |