From 85580fd1ea351cbfabbfa054d9ecd89a94deeccd Mon Sep 17 00:00:00 2001 From: Rene Rivera Date: Mon, 11 Mar 2024 08:38:17 -0500 Subject: [PATCH 01/26] Make the library modular usable. --- build.jam | 32 ++++++++++++++ build/Jamfile.v2 | 3 -- example/Jamfile.v2 | 53 ++++++++++------------- test/Jamfile.v2 | 58 +++++++++++++++----------- test/config_info/regex_config_info.cpp | 2 +- test/test_consolidated.cpp | 10 ++--- 6 files changed, 92 insertions(+), 66 deletions(-) create mode 100644 build.jam diff --git a/build.jam b/build.jam new file mode 100644 index 00000000..b73dd099 --- /dev/null +++ b/build.jam @@ -0,0 +1,32 @@ +# Copyright René Ferdinand Rivera Morell 2023 +# 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) + +import project ; + +project /boost/regex + : common-requirements + /boost/assert//boost_assert + /boost/concept_check//boost_concept_check + /boost/config//boost_config + /boost/container_hash//boost_container_hash + /boost/core//boost_core + /boost/integer//boost_integer + /boost/mpl//boost_mpl + /boost/predef//boost_predef + /boost/smart_ptr//boost_smart_ptr + /boost/static_assert//boost_static_assert + /boost/throw_exception//boost_throw_exception + /boost/type_traits//boost_type_traits + include + ; + +explicit + [ alias boost_regex : build//boost_regex ] + [ alias all : boost_regex example test ] + ; + +call-if : boost-library regex + : install boost_regex + ; diff --git a/build/Jamfile.v2 b/build/Jamfile.v2 index 08f98195..755f5882 100644 --- a/build/Jamfile.v2 +++ b/build/Jamfile.v2 @@ -160,6 +160,3 @@ lib boost_regex : ../src/$(SOURCES) icu_options shared:BOOST_REGEX_DYN_LINK=1 gcc-cygwin:static ; - -boost-install boost_regex ; - diff --git a/example/Jamfile.v2 b/example/Jamfile.v2 index dd958c7d..9acf63e8 100644 --- a/example/Jamfile.v2 +++ b/example/Jamfile.v2 @@ -4,19 +4,20 @@ # http://www.boost.org/LICENSE_1_0.txt. project - : requirements + : requirements + /boost/timer//boost_timer multi shared:BOOST_REGEX_DYN_LINK=1 # There are unidentified linker problems on these platforms: mipspro-7.4:static sun-5.9:static msvc:all - gcc:all - gcc:-Wextra + gcc:extra U_USING_ICU_NAMESPACE=0 #gcc-mw:static #gcc-mingw:static gcc-cygwin:static + BOOST_TIMER_ENABLE_DEPRECATED ; rule regex-test-run ( sources + : input * : name * ) @@ -26,7 +27,7 @@ rule regex-test-run ( sources + : input * : name * ) # sources $(sources) # dependencies - ../build//boost_regex + /boost/regex//boost_regex : # additional args $(input) : # test-files @@ -37,45 +38,33 @@ rule regex-test-run ( sources + : input * : name * ) ] ; } +path-constant HERE : . ; + test-suite regex-examples : -[ regex-test-run timer/regex_timer.cpp : $(BOOST_ROOT)/libs/regex/example/timer/input_script.txt ] -[ regex-test-run grep/grep.cpp ../../program_options/build//boost_program_options/static : -n -b $(BOOST_ROOT)/boost/regex.hpp $(BOOST_ROOT)/boost/type_traits.hpp : test_grep ] +[ regex-test-run timer/regex_timer.cpp : $(HERE)/timer/input_script.txt ] +[ regex-test-run grep/grep.cpp /boost/program_options//boost_program_options/static : -n -b $(HERE)/../include/boost/regex.hpp : test_grep ] [ regex-test-run snippets/credit_card_example.cpp ] [ regex-test-run snippets/mfc_example.cpp ] [ regex-test-run snippets/icu_example.cpp ] -[ regex-test-run snippets/partial_regex_grep.cpp : $(BOOST_ROOT)/libs/regex/index.htm ] -[ regex-test-run snippets/partial_regex_iterate.cpp : $(BOOST_ROOT)/libs/regex/index.htm ] +[ regex-test-run snippets/partial_regex_grep.cpp : $(HERE)/../index.htm ] +[ regex-test-run snippets/partial_regex_iterate.cpp : $(HERE)/../index.htm ] [ regex-test-run snippets/partial_regex_match.cpp : 1234-5678-8765-4 ] -[ regex-test-run snippets/regex_grep_example_1.cpp : $(BOOST_ROOT)/boost/rational.hpp ] -[ regex-test-run snippets/regex_grep_example_2.cpp : $(BOOST_ROOT)/boost/rational.hpp ] -[ regex-test-run snippets/regex_grep_example_3.cpp : $(BOOST_ROOT)/boost/rational.hpp ] -[ regex-test-run snippets/regex_grep_example_4.cpp : $(BOOST_ROOT)/boost/rational.hpp ] +[ regex-test-run snippets/regex_grep_example_1.cpp : $(HERE)/../include/boost/regex/v5/regex_iterator.hpp ] +[ regex-test-run snippets/regex_grep_example_2.cpp : $(HERE)/../include/boost/regex/v5/regex_iterator.hpp ] +[ regex-test-run snippets/regex_grep_example_3.cpp : $(HERE)/../include/boost/regex/v5/regex_iterator.hpp ] +[ regex-test-run snippets/regex_grep_example_4.cpp : $(HERE)/../include/boost/regex/v5/regex_iterator.hpp ] [ regex-test-run snippets/regex_match_example.cpp : -auto ] -[ regex-test-run snippets/regex_merge_example.cpp : $(BOOST_ROOT)/boost/rational.hpp ] -[ regex-test-run snippets/regex_replace_example.cpp : $(BOOST_ROOT)/boost/rational.hpp ] -[ regex-test-run snippets/regex_search_example.cpp : $(BOOST_ROOT)/boost/rational.hpp ] +[ regex-test-run snippets/regex_merge_example.cpp : $(HERE)/../include/boost/regex/v5/regex_iterator.hpp ] +[ regex-test-run snippets/regex_replace_example.cpp : $(HERE)/../include/boost/regex/v5/regex_iterator.hpp ] +[ regex-test-run snippets/regex_search_example.cpp : $(HERE)/../include/boost/regex/v5/regex_iterator.hpp ] [ regex-test-run snippets/regex_split_example_1.cpp : -auto ] -[ regex-test-run snippets/regex_split_example_2.cpp : $(BOOST_ROOT)/libs/regex/doc/html/index.html ] +[ regex-test-run snippets/regex_split_example_2.cpp : $(HERE)/../doc/html/index.html ] [ regex-test-run snippets/regex_token_iterator_eg_1.cpp : -auto ] -[ regex-test-run snippets/regex_token_iterator_eg_2.cpp : $(BOOST_ROOT)/libs/regex/doc/html/index.html ] -[ regex-test-run snippets/regex_iterator_example.cpp : $(BOOST_ROOT)/boost/rational.hpp ] +[ regex-test-run snippets/regex_token_iterator_eg_2.cpp : $(HERE)/../doc/html/index.html ] +[ regex-test-run snippets/regex_iterator_example.cpp : $(HERE)/../include/boost/regex/v5/regex_iterator.hpp ] [ run snippets/captures_example.cpp ../test/captures//boost_regex_extra : : : multi BOOST_REGEX_MATCH_EXTRA=1 ] ; - - - - - - - - - - - - - - diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index edbe190a..e00adc5f 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -5,6 +5,7 @@ project : requirements + /boost/detail//boost_detail multi shared:BOOST_REGEX_DYN_LINK=1 msvc-7.1:TEST_MFC=1 @@ -21,6 +22,7 @@ project #gcc-mingw:static #gcc-cygwin:static sun:static + ../src ; # @@ -28,7 +30,7 @@ project # rule regex-test ( name : sources + : requirements * : input-files * ) { - return [ run $(sources) ../build//boost_regex + return [ run $(sources) /boost/regex//boost_regex : : $(input-files) : $(requirements) @@ -80,22 +82,22 @@ local regress-sources = regress/$(R_SOURCE) ; test-suite regex : - [ run regress/$(R_SOURCE) ../build//boost_regex ../build//icu_options + [ run regress/$(R_SOURCE) /boost/regex//boost_regex ../build//icu_options : # command line : # input files : # requirements : regex_regress ] - [ run regress/$(R_SOURCE) ../build//boost_regex - ../../thread/build//boost_thread ../build//icu_options + [ run regress/$(R_SOURCE) /boost/regex//boost_regex + /boost/thread//boost_thread ../build//icu_options : # command line : # input files : # requirements TEST_THREADS : regex_regress_threaded ] - [ run regress/$(R_SOURCE) ../build//boost_regex - ../../thread/build//boost_thread ../build//icu_options + [ run regress/$(R_SOURCE) /boost/regex//boost_regex + /boost/thread//boost_thread ../build//icu_options : # command line : # input files : # requirements @@ -114,67 +116,72 @@ test-suite regex : c_compiler_checks/wide_posix_api_check.cpp ] [ run pathology/bad_expression_test.cpp : : : - [ check-target-builds ../build//is_legacy_03 : : ../build//boost_regex ] + [ check-target-builds ../build//is_legacy_03 : : /boost/regex//boost_regex ] ] [ run pathology/recursion_test.cpp : : : - [ check-target-builds ../build//is_legacy_03 : : ../build//boost_regex ] + [ check-target-builds ../build//is_legacy_03 : : /boost/regex//boost_regex ] ] [ run named_subexpressions/named_subexpressions_test.cpp : : : - [ check-target-builds ../build//is_legacy_03 : : ../build//boost_regex ] + [ check-target-builds ../build//is_legacy_03 : : /boost/regex//boost_regex ] ] [ run unicode/unicode_iterator_test.cpp : : : - [ check-target-builds ../build//is_legacy_03 : : ../build//boost_regex ] + [ check-target-builds ../build//is_legacy_03 : : /boost/regex//boost_regex ] release TEST_UTF8 : unicode_iterator_test_utf8 ] [ run unicode/unicode_iterator_test.cpp : : : - [ check-target-builds ../build//is_legacy_03 : : ../build//boost_regex ] + [ check-target-builds ../build//is_legacy_03 : : /boost/regex//boost_regex ] release TEST_UTF16 : unicode_iterator_test_utf16 ] [ run unicode/unicode_casefold_test.cpp - ../build//boost_regex ../build//icu_options + /boost/regex//boost_regex ../build//icu_options ] [ run static_mutex/static_mutex_test.cpp - ../../thread/build//boost_thread ../build//boost_regex + /boost/thread//boost_thread /boost/regex//boost_regex + /boost/timer//boost_timer + : : : BOOST_TIMER_ENABLE_DEPRECATED ] [ run object_cache/object_cache_test.cpp : : : - [ check-target-builds ../build//is_legacy_03 : : ../build//boost_regex ] + [ check-target-builds ../build//is_legacy_03 : : /boost/regex//boost_regex ] ] [ run config_info/regex_config_info.cpp - ../build//boost_regex/static + /boost/regex//boost_regex/static : # command line : # input files : always_show_run_output + /boost/config//testing ] - [ run config_info/regex_config_info.cpp ../build//boost_regex + [ run config_info/regex_config_info.cpp /boost/regex//boost_regex : # command line : # input files : always_show_run_output + /boost/config//testing : regex_dll_config_info - ] + ] - [ run collate_info/collate_info.cpp ../build//boost_regex + [ run collate_info/collate_info.cpp /boost/regex//boost_regex : : : always_show_run_output : test_collate_info ] [ link concepts/concept_check.cpp : - [ check-target-builds ../build//is_legacy_03 : : ../build//boost_regex ] + [ check-target-builds ../build//is_legacy_03 : : /boost/regex//boost_regex ] ] [ link concepts/concept_check.cpp : BOOST_REGEX_STANDALONE [ check-target-builds ../build//is_legacy_03 : : no ] : standalone_concept_check ] [ link concepts/icu_concept_check.cpp : - BOOST_REGEX_STANDALONE [ check-target-builds ../build//is_legacy_03 : : ../build//boost_regex ] + BOOST_REGEX_STANDALONE [ check-target-builds ../build//is_legacy_03 : : /boost/regex//boost_regex ] ] [ link concepts/icu_concept_check.cpp : [ check-target-builds ../build//is_legacy_03 : : no ] : standalone_icu_concept_check ] [ link concepts/range_concept_check.cpp : - [ check-target-builds ../build//is_legacy_03 : : ../build//boost_regex ] + [ check-target-builds ../build//is_legacy_03 : : /boost/regex//boost_regex ] + /boost/range//boost_range ] [ run concepts/test_bug_11988.cpp : : : - [ check-target-builds ../build//is_legacy_03 : : ../build//boost_regex ] + [ check-target-builds ../build//is_legacy_03 : : /boost/regex//boost_regex ] ] [ run @@ -184,10 +191,11 @@ test-suite regex : # additional args : # test-files : # requirements + /boost/array//boost_array multi BOOST_REGEX_MATCH_EXTRA=1 BOOST_REGEX_NO_LIB=1 - [ check-target-builds ../build//is_legacy_03 : : ../build//boost_regex ] + [ check-target-builds ../build//is_legacy_03 : : /boost/regex//boost_regex ] : # test name captures_test ] @@ -219,7 +227,7 @@ compile test_consolidated.cpp ; build-project ../example ; # `quick` target (for CI) -run quick.cpp ../build//boost_regex ; +run quick.cpp /boost/regex//boost_regex ; compile test_warnings.cpp : msvc:all msvc:on @@ -239,4 +247,4 @@ compile test_windows_defs_2.cpp ; compile test_windows_defs_3.cpp ; compile test_windows_defs_4.cpp ; -run issue153.cpp : : : msvc:-STACK:2097152 ; +run issue153.cpp : : : "msvc:-STACK:2097152" ; diff --git a/test/config_info/regex_config_info.cpp b/test/config_info/regex_config_info.cpp index 211e9ec0..fb37c29f 100644 --- a/test/config_info/regex_config_info.cpp +++ b/test/config_info/regex_config_info.cpp @@ -19,7 +19,7 @@ #endif #define main OLD_MAIN -#include +#include #undef main #ifndef NEW_MAIN # define NEW_MAIN main diff --git a/test/test_consolidated.cpp b/test/test_consolidated.cpp index d5415f2b..d51448da 100644 --- a/test/test_consolidated.cpp +++ b/test/test_consolidated.cpp @@ -10,8 +10,8 @@ */ -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include From 1dcd3318796c8bceaf688c21ddfa7ffa1a4d3435 Mon Sep 17 00:00:00 2001 From: Rene Rivera Date: Fri, 29 Mar 2024 21:15:59 -0500 Subject: [PATCH 02/26] Switch to library requirements instead of source. As source puts extra source in install targets. --- build.jam | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/build.jam b/build.jam index b73dd099..d09e7788 100644 --- a/build.jam +++ b/build.jam @@ -7,18 +7,18 @@ import project ; project /boost/regex : common-requirements - /boost/assert//boost_assert - /boost/concept_check//boost_concept_check - /boost/config//boost_config - /boost/container_hash//boost_container_hash - /boost/core//boost_core - /boost/integer//boost_integer - /boost/mpl//boost_mpl - /boost/predef//boost_predef - /boost/smart_ptr//boost_smart_ptr - /boost/static_assert//boost_static_assert - /boost/throw_exception//boost_throw_exception - /boost/type_traits//boost_type_traits + /boost/assert//boost_assert + /boost/concept_check//boost_concept_check + /boost/config//boost_config + /boost/container_hash//boost_container_hash + /boost/core//boost_core + /boost/integer//boost_integer + /boost/mpl//boost_mpl + /boost/predef//boost_predef + /boost/smart_ptr//boost_smart_ptr + /boost/static_assert//boost_static_assert + /boost/throw_exception//boost_throw_exception + /boost/type_traits//boost_type_traits include ; From 8dc1fd4a3bb6ce4c794ef928f61c05fc159c955c Mon Sep 17 00:00:00 2001 From: Rene Rivera Date: Wed, 10 Apr 2024 17:46:03 -0500 Subject: [PATCH 03/26] Update build dependencies and fix test compile error from depending on Boost.Config test files. --- build.jam | 4 ---- test/Jamfile.v2 | 1 + 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/build.jam b/build.jam index d09e7788..95327dfb 100644 --- a/build.jam +++ b/build.jam @@ -10,12 +10,8 @@ project /boost/regex /boost/assert//boost_assert /boost/concept_check//boost_concept_check /boost/config//boost_config - /boost/container_hash//boost_container_hash /boost/core//boost_core - /boost/integer//boost_integer - /boost/mpl//boost_mpl /boost/predef//boost_predef - /boost/smart_ptr//boost_smart_ptr /boost/static_assert//boost_static_assert /boost/throw_exception//boost_throw_exception /boost/type_traits//boost_type_traits diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 41b35054..a9975d26 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -22,6 +22,7 @@ project #gcc-cygwin:static sun:static ../src + . ; # From 72652f7cde6561a3103ca1aeb2b22ac7002e5045 Mon Sep 17 00:00:00 2001 From: Rene Rivera Date: Wed, 10 Apr 2024 17:47:08 -0500 Subject: [PATCH 04/26] Add missing file. --- test/config_info.cpp | 1569 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1569 insertions(+) create mode 100644 test/config_info.cpp diff --git a/test/config_info.cpp b/test/config_info.cpp new file mode 100644 index 00000000..6198da8f --- /dev/null +++ b/test/config_info.cpp @@ -0,0 +1,1569 @@ +// Boost config.hpp configuration test program file -----------------------// + +// (C) Copyright John Maddock 2001 - 2003. +// (C) Copyright Jens Maurer 2001. +// (C) Copyright Peter Dimov 2001. +// (C) Copyright Darin Adler 2001. +// (C) Copyright Beman Dawes 2002. +// Use, modification and distribution are subject to 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) + +// See http://www.boost.org/libs/config for most recent version. +// +// Revision $Id$ +// + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef BOOST_HAS_UNISTD_H +#include +#endif + +#if defined(__MINGW32__) +# include <_mingw.h> +#endif + +static unsigned int indent = 4; +static unsigned int width = 40; + +using std::cout; +using std::istream; + +void print_macro(const char* name, const char* value) +{ + // if name == value+1 then then macro is not defined, + // in which case we don't print anything: + if(0 != strcmp(name, value+1)) + { + for(unsigned i = 0; i < indent; ++i) std::cout.put(' '); + std::cout << std::setw(width); + cout.setf(istream::left, istream::adjustfield); + std::cout << name; + if(value[1]) + { + // macro has a value: + std::cout << value << "\n"; + } + else + { + // macro is defined but has no value: + std::cout << " [no value]\n"; + } + } +} + +#define PRINT_MACRO(X) print_macro(#X, BOOST_STRINGIZE(=X)) + +template +void print_expression(const char* expression, T val) +{ + for(unsigned i = 0; i < indent; ++i) std::cout.put(' '); + std::cout << std::setw(width); + std::cout.setf(istream::left, istream::adjustfield); + std::cout << expression << "=" << val << std::endl; +} + +#define PRINT_EXPRESSION(E) print_expression(#E, E); + +template +void print_byte_order(const char* what, T /* t */ ) +{ + T val = 0; + unsigned i; + for(i = 1; i < sizeof(T); ++i) + { + val |= (CHAR_BIT * static_cast(i)) << (CHAR_BIT * static_cast(i)); + } + const char* p = reinterpret_cast(&val); + + for(i = 0; i < indent; ++i) std::cout.put(' '); + std::cout << std::setw(width); + std::cout.setf(istream::left, istream::adjustfield); + std::cout << what << "="; + for(i = 0; i < sizeof(T); ++i) + { + std::cout << (int)p[i] << " "; + } + std::cout << std::endl; +} + +#define PRINT_ORDER(T) print_byte_order(BOOST_STRINGIZE(byte order for type T), T()) + +template +void print_sign(const char* what, T t) +{ + t = static_cast(-1); // cast suppresses warnings + for(unsigned i = 0; i < indent; ++i) std::cout.put(' '); + std::cout << "Type " << what << " is " << ((t > 0) ? "unsigned" : "signed") << std::endl; +} + +#define PRINT_SIGN(T) print_sign(#T, T()) + + +void print_compiler_macros() +{ + std::cout << BOOST_COMPILER << "\n"; + // Borland options: + PRINT_MACRO(__BORLANDC__); + PRINT_MACRO(__CDECL__); + PRINT_MACRO(_CHAR_UNSIGNED); + PRINT_MACRO(__CODEGUARD__); + PRINT_MACRO(__CONSOLE__); + PRINT_MACRO(_CPPUNWIND); + PRINT_MACRO(__cplusplus); + PRINT_MACRO(__FLAT__); + PRINT_MACRO(__FUNC__); + PRINT_MACRO(_M_IX86); + PRINT_MACRO(__MSDOS__); + PRINT_MACRO(__MT__ ); + PRINT_MACRO(__PASCAL__); + PRINT_MACRO(__STDC__); + PRINT_MACRO(__TLS__); + PRINT_MACRO(_WCHAR_T); + PRINT_MACRO(_Windows); + PRINT_MACRO(__WIN32__); + PRINT_MACRO(_WIN32); + PRINT_MACRO(_WIN64); + PRINT_MACRO(_WIN32_WCE); + PRINT_MACRO(WIN32); + PRINT_MACRO(_RTLDLL); + PRINT_MACRO(__DEBUG); + +// Internal MSVC 7 error workaround (Peter Dimov) + +#ifndef _NATIVE_WCHAR_T_DEFINED + PRINT_MACRO(_WCHAR_T_DEFINED); +#endif + // MSVC macros: + PRINT_MACRO(_ALIGNED_NEW_SUPPORTED); + PRINT_MACRO(__ATOM__); + PRINT_MACRO(__AVX__); + PRINT_MACRO(__AVX2__); + PRINT_MACRO(_CHAR_UNSIGNED); + PRINT_MACRO(_CLR_VER); + PRINT_MACRO(_CONTROL_FLOW_GUARD); + PRINT_MACRO(__cplusplus_cli); + PRINT_MACRO(__cplusplus_winrt); + PRINT_MACRO(_CPPRTTI); + PRINT_MACRO(_CPPUNWIND); + PRINT_MACRO(_DLL); + PRINT_MACRO(_INLINE_VARIABLES_SUPPORTED); + PRINT_MACRO(_ISO_VOLATILE); + PRINT_MACRO(_M_AMD64); + PRINT_MACRO(_M_ARM); + PRINT_MACRO(_M_ARM_ARMV7VE); + PRINT_MACRO(_M_ARM_FP); + PRINT_MACRO(_M_ARM64); + PRINT_MACRO(_M_CEE); + PRINT_MACRO(_M_CEE_PURE); + PRINT_MACRO(_M_CEE_SAFE); + PRINT_MACRO(_M_FP_EXCEPT); + PRINT_MACRO(_M_FP_FAST); + PRINT_MACRO(_M_FP_PRECISE); + PRINT_MACRO(_M_FP_STRICT); + PRINT_MACRO(_M_IX86); + PRINT_MACRO(_M_IX86_FP); + PRINT_MACRO(_M_X64); + PRINT_MACRO(_M_ALPHA); + PRINT_MACRO(_M_MPPC); + PRINT_MACRO(_M_MRX000); + PRINT_MACRO(_M_PPC); + PRINT_MACRO(_MANAGED); + PRINT_MACRO(_MSC_BUILD); + PRINT_MACRO(_MFC_VER); + PRINT_MACRO(_MSC_EXTENSIONS); + PRINT_MACRO(_MSC_VER); + PRINT_MACRO(_MSC_FULL_VER); + PRINT_MACRO(_MSVC_LANG); + PRINT_MACRO(_MSVC_WARNING_LEVEL); + PRINT_MACRO(__MSVC_RUNTIME_CHECKS); + PRINT_MACRO(_MT); + PRINT_MACRO(_NATIVE_WCHAR_T_DEFINED); + PRINT_MACRO(_NOEXCEPT_TYPES_SUPPORTED); + PRINT_MACRO(_OPENMP); + PRINT_MACRO(_PREFAST_); + // GNUC options: + PRINT_MACRO(__GNUC__); + PRINT_MACRO(__GNUC_MINOR__); + PRINT_MACRO(__GNUC_PATCHLEVEL__); + PRINT_MACRO(__STDC_VERSION__); + PRINT_MACRO(__GNUG__); + PRINT_MACRO(__STRICT_ANSI__); + PRINT_MACRO(__GXX_EXPERIMENTAL_CXX0X__); + PRINT_MACRO(__VERSION__); + PRINT_MACRO(__OPTIMIZE__); + PRINT_MACRO(__CHAR_UNSIGNED__); + PRINT_MACRO(__REGISTER_PREFIX__); + PRINT_MACRO(__USER_LABEL_PREFIX__); + PRINT_MACRO(__GNUPRO__); + PRINT_MACRO(__EXCEPTIONS); + PRINT_MACRO(__FreeBSD__); + PRINT_MACRO(__FreeBSD_cc_version); + PRINT_MACRO(__ELF__); + PRINT_MACRO(__GNUPRO__); + PRINT_MACRO(unix); + PRINT_MACRO(bsd); + PRINT_MACRO(vax); + PRINT_MACRO(mc68000); + PRINT_MACRO(m68k); + PRINT_MACRO(M68020); + PRINT_MACRO(_AM29K); + PRINT_MACRO(ns32000); + PRINT_MACRO(sun); + PRINT_MACRO(pyr); + PRINT_MACRO(sequent); + PRINT_MACRO(__i386__); + PRINT_MACRO(__sparc); + PRINT_MACRO(__sparc__); + PRINT_MACRO(__powerpc__); + PRINT_MACRO(__hppa); + PRINT_MACRO(__CYGWIN__); + PRINT_MACRO(__MINGW32__); + PRINT_MACRO(__GXX_RTTI); + PRINT_MACRO(__alpha__); + PRINT_MACRO(__amd64__); + PRINT_MACRO(__arm__); + PRINT_MACRO(__aarch64__); + PRINT_MACRO(__bfin); + PRINT_MACRO(__convex__); + PRINT_MACRO(__epiphany__); + PRINT_MACRO(__hppa__); + PRINT_MACRO(__ia64__); + PRINT_MACRO(__IA64); + PRINT_MACRO(__IA64__); + PRINT_MACRO(__m68k__); + PRINT_MACRO(__mips__); + PRINT_MACRO(__powerpc); + PRINT_MACRO(__powerpc__); + PRINT_MACRO(__powerpc64__); + PRINT_MACRO(__POWERPC__); + PRINT_MACRO(__ppc__); + PRINT_MACRO(__ppc64__); + PRINT_MACRO(__PPC__); + PRINT_MACRO(__PPC64__); + PRINT_MACRO(_ARCH_PPC); + PRINT_MACRO(_ARCH_PPC64); + PRINT_MACRO(__sh__); + PRINT_MACRO(__370__); + PRINT_MACRO(__THW_370__); + // HP aCC: + PRINT_MACRO(__HP_aCC); + PRINT_MACRO(_HPACC_); + PRINT_MACRO(__LP64__); + PRINT_MACRO(__RISC2_0__); + PRINT_MACRO(__STDCPP__); + PRINT_MACRO(__hppa); + PRINT_MACRO(__hpux); + PRINT_MACRO(__hp9000s800); + PRINT_MACRO(__hp9000s700); + PRINT_MACRO(_PA_RISC1_1); + PRINT_MACRO(__HPUX_SOURCE); + PRINT_MACRO(_INCLUDE__STDC_A1_SOURCE); + // SGI IRIX: + PRINT_MACRO(__sgi); + PRINT_MACRO(_COMPILER_VERSION); + // Sunpro: + PRINT_MACRO(__SUNPRO_CC); + PRINT_MACRO(__SUNPRO_CC_COMPAT); + PRINT_MACRO(__BUILTIN_VA_ARG_INCR); + PRINT_MACRO(__sun); + PRINT_MACRO(__SVR4); + PRINT_MACRO(__unix); + PRINT_MACRO(__sparcv9); + PRINT_MACRO(__i386); + PRINT_MACRO(i386); + // Metrowerks + PRINT_MACRO(__MWERKS__); + PRINT_MACRO(__MSL__); + PRINT_MACRO(__MSL_CPP__); + PRINT_MACRO(__A5__); + PRINT_MACRO(__embedded_cplusplus); + PRINT_MACRO(__fourbyteints__); + PRINT_MACRO(__IEEEdoubles__); + PRINT_MACRO(__MC68K__); + PRINT_MACRO(__MC68020__); + PRINT_MACRO(__MC68881__); + PRINT_MACRO(__MIPS__); + PRINT_MACRO(__MIPS_ISA2__); + PRINT_MACRO(__MIPS_ISA3__); + PRINT_MACRO(__MIPS_ISA4__); + PRINT_MACRO(__MWBROWSER__); + PRINT_MACRO(__profile__); + PRINT_MACRO(__powerc); + PRINT_MACRO(_powerc); + PRINT_MACRO(__POWERPC__); + PRINT_MACRO(macintosh); + PRINT_MACRO(__MACH__); + PRINT_MACRO(__APPLE__); + PRINT_MACRO(__APPLE_CC__); + // MPW (MrCpp and SCpp) + PRINT_MACRO(__MRC__); + PRINT_MACRO(__SC__); + PRINT_MACRO(__FPCE__); + PRINT_MACRO(__FPCE_IEEE__); + PRINT_MACRO(MPW_CPLUS); + PRINT_MACRO(MPW_C); + PRINT_MACRO(__MC601); + PRINT_MACRO(__POWERPC); + PRINT_MACRO(__useAppleExts__); + PRINT_MACRO(powerc); + PRINT_MACRO(MC68000); + PRINT_MACRO(THINK_PLUS); + PRINT_MACRO(mc68881); + PRINT_MACRO(__FAR_CODE__); + PRINT_MACRO(__FAR_DATA__); + PRINT_MACRO(__CFM68K__); + // EDG + PRINT_MACRO(__EDG__); + PRINT_MACRO(__EDG_VERSION__); + PRINT_MACRO(c_plusplus); // indication for strict mode + PRINT_MACRO(_BOOL); + PRINT_MACRO(_EXPLICIT); + PRINT_MACRO(__SIGNED_CHARS__); + PRINT_MACRO(_TYPENAME); + PRINT_MACRO(_WCHAR_T); + PRINT_MACRO(__ARRAY_OPERATORS); + PRINT_MACRO(__EDG_ABI_COMPATIBILITY_VERSION); + PRINT_MACRO(__EDG_IMPLICIT_USING_STD); + PRINT_MACRO(__EDG_RUNTIME_USES_NAMESPACES); + PRINT_MACRO(__BOOL_DEFINED); + PRINT_MACRO(__RTTI); + PRINT_MACRO(__PLACEMENT_DELETE); + PRINT_MACRO(__NO_LONG_LONG); + + // Intel options: + PRINT_MACRO(__INTEL__); + PRINT_MACRO(__ICC); + PRINT_MACRO(__ICL); + PRINT_MACRO(__ECC); + PRINT_MACRO(__INTEL_COMPILER); + PRINT_MACRO(__INITIAL_POINTER_SIZE); + PRINT_MACRO(_INTEGRAL_MAX_BITS); + PRINT_MACRO(__INTEL_COMPILER_BUILD_DATE); + PRINT_MACRO(__INTEL_MS_COMPAT_LEVEL); + PRINT_MACRO(__LONG_DOUBLE_SIZE__); + PRINT_MACRO(_M_X64); + PRINT_MACRO(_OPENMP); + PRINT_MACRO(_OPENMPT); + PRINT_MACRO(_PGO_INSTRUMENT); + PRINT_MACRO(__QMSPP_); + PRINT_MACRO(__INTEL_RTTI__); + PRINT_MACRO(__INTEL_CXX11_MODE__); + + // Cray options: + PRINT_MACRO(_CRAYC); + PRINT_MACRO(_RELEASE); + PRINT_MACRO(cray); + PRINT_MACRO(CRAY); + PRINT_MACRO(CRAY1); + PRINT_MACRO(_CRAY1); + PRINT_MACRO(_CRAYMPP); + PRINT_MACRO(_CRAYT3E); + PRINT_MACRO(_CRAYIEEE); + PRINT_MACRO(_ADDR32); + PRINT_MACRO(_ADDR64); + PRINT_MACRO(_LD64); + PRINT_MACRO(_FASTMD); + PRINT_MACRO(_MAXVL); + + // clang options: + PRINT_MACRO(__clang__); + PRINT_MACRO(__clang_major__); + PRINT_MACRO(__clang_minor__); + PRINT_MACRO(__clang_version__); + PRINT_MACRO(__clang_patchlevel__); + PRINT_MACRO(__apple_build_version__); + + // misc compilers not covered so far: + PRINT_MACRO(__USLC__); + PRINT_MACRO(__DECCXX); + PRINT_MACRO(__IBMCPP__); + PRINT_MACRO(_REENTRANT); + PRINT_MACRO(_PTHREADS); + PRINT_MACRO(__STDC_HOSTED__); + PRINT_MACRO(__COMO__); + PRINT_MACRO(__COMO_VERSION__); + PRINT_MACRO(__DM__); + PRINT_MACRO(__osf__); + PRINT_MACRO(__OSF__); + PRINT_MACRO(__QNXNTO__); + PRINT_MACRO(__QNX__); + PRINT_MACRO(_NTO_VERSION); + PRINT_MACRO(__OPEN64__); + PRINT_MACRO(__open64); + PRINT_MACRO(__NVCC__); + PRINT_MACRO(__CUDACC__); + PRINT_MACRO(__CUDACC_RDC__); + PRINT_MACRO(__CUDACC_VER_MAJOR__); + PRINT_MACRO(__CUDACC_VER_MINOR__); + PRINT_MACRO(__CUDACC_VER_BUILD__); + PRINT_MACRO(__CUDACC_VER__); + + // Android: + PRINT_MACRO(ANDROID); + PRINT_MACRO(__ANDROID__); +} + +void print_stdlib_macros() +{ + std::cout << BOOST_STDLIB << std::endl; + #ifdef _RWSTD_VER + // Rogue Wave 2.x config options: + PRINT_MACRO(__NO_EDG_EXCEPTION_CLASSES); + PRINT_MACRO(_RWSTD_ALLOCATOR); + PRINT_MACRO(_RWSTD_BAD_ALLOC_DEFINED); + PRINT_MACRO(_RWSTD_BAD_EXCEPTION_DEFINED); + PRINT_MACRO(_RWSTD_BOUNDS_CHECKING); + PRINT_MACRO(_RWSTD_COMPILE_INSTANTIATE); + PRINT_MACRO(_RWSTD_DEFAULT_PRECISION); + PRINT_MACRO(_RWSTD_EXCEPTION_DEFINED); + PRINT_MACRO(_RWSTD_EXCEPTION_HANDLER_IN_STD); + PRINT_MACRO(_RWSTD_EXCEPTION_PREDEFINED); + PRINT_MACRO(_RWSTD_FLT_ROUNDS_IS_CONSTANT); + PRINT_MACRO(_RWSTD_LOCALIZED_ERRORS); + PRINT_MACRO(_RWSTD_MESSAGE); + PRINT_MACRO(_RWSTD_MUTEXATTR_DEFAULT); + PRINT_MACRO(_RWSTD_NO_ANSI_SPRINTF); + PRINT_MACRO(_RWSTD_NO_ARG_MATCH); + PRINT_MACRO(_RWSTD_NO_BAD_CAST); + PRINT_MACRO(_RWSTD_NO_BASE_CLASS_MATCH); + PRINT_MACRO(_RWSTD_NO_BOOL); + PRINT_MACRO(_RWSTD_NO_BUILTIN_CTOR); + PRINT_MACRO(_RWSTD_NO_CATOPEN_CATGETS); + PRINT_MACRO(_RWSTD_NO_CLASS_PARTIAL_SPEC); + PRINT_MACRO(_RWSTD_NO_COMPLEX_DEFAULT_TEMPLATES); + PRINT_MACRO(_RWSTD_NO_COMPLICATED_EXCEPTIONS); + PRINT_MACRO(_RWSTD_NO_COMPLICATED_TYPEDEF); + PRINT_MACRO(_RWSTD_NO_CONST_INST); + PRINT_MACRO(_RWSTD_NO_CTOR_RETURN); + PRINT_MACRO(_RWSTD_NO_DEFAULT_FOR_TPARAM); + PRINT_MACRO(_RWSTD_NO_DEFAULT_TEMPLATE_ARGS); + PRINT_MACRO(_RWSTD_NO_DESTROY_BUILTIN); + PRINT_MACRO(_RWSTD_NO_DESTROY_NONBUILTIN); + PRINT_MACRO(_RWSTD_NO_EMBEDDED_TYPEDEF); + PRINT_MACRO(_RWSTD_NO_EX_SPEC); + PRINT_MACRO(_RWSTD_NO_EXCEPTIONS); + PRINT_MACRO(_RWSTD_NO_EXPLICIT); + PRINT_MACRO(_RWSTD_NO_EXPLICIT_ARG); + PRINT_MACRO(_RWSTD_NO_EXPLICIT_FUNC_INSTANTIATION); + PRINT_MACRO(_RWSTD_NO_EXPLICIT_INSTANTIATION); + PRINT_MACRO(_RWSTD_NO_EXTENSION); + PRINT_MACRO(_RWSTD_NO_FORWARD_SPECIALIZATIONS); + PRINT_MACRO(_RWSTD_NO_FPOS_T); + PRINT_MACRO(_RWSTD_NO_FRIEND_TEMPLATES); + PRINT_MACRO(_RWSTD_NO_FUNC_PARTIAL_SPEC); + PRINT_MACRO(_RWSTD_NO_GETTIMEOFDAY); + PRINT_MACRO(_RWSTD_NO_GLOBAL_TZ); + PRINT_MACRO(_RWSTD_NO_INHERITED_TYPEDEFS); + PRINT_MACRO(_RWSTD_NO_INIT_CONST_TEMPLATE_REF_ARG); + PRINT_MACRO(_RWSTD_NO_INT_TYPEDEF); + PRINT_MACRO(_RWSTD_NO_LDIV); + PRINT_MACRO(_RWSTD_NO_LEADING_UNDERSCORE); + PRINT_MACRO(_RWSTD_NO_LOCALE); + PRINT_MACRO(_RWSTD_NO_LONG_NAME); + PRINT_MACRO(_RWSTD_NO_LONGDOUBLE); + PRINT_MACRO(_RWSTD_NO_MBSTATE_T); + PRINT_MACRO(_RWSTD_NO_MEM_CLASS_TEMPLATES); + PRINT_MACRO(_RWSTD_NO_MEMBER_TEMPLATES); + PRINT_MACRO(_RWSTD_NO_MEMBER_TYPE_TPARAM); + PRINT_MACRO(_RWSTD_NO_MEMBER_WO_DEF_CTOR); + PRINT_MACRO(_RWSTD_NO_MEMMOVE); + PRINT_MACRO(_RWSTD_NO_MULTI_DIM_ARRAY); + PRINT_MACRO(_RWSTD_NO_MUTABLE); + PRINT_MACRO(_RWSTD_NO_NAME_INJECTION); + PRINT_MACRO(_RWSTD_NO_NAMESPACE); + PRINT_MACRO(_RWSTD_NO_NESTING_TEMPLATES); + PRINT_MACRO(_RWSTD_NO_NEW_BRACKETS); + PRINT_MACRO(_RWSTD_NO_NEW_DECL); + PRINT_MACRO(_RWSTD_NO_NEW_HEADER); + PRINT_MACRO(_RWSTD_NO_NEW_TEMPLATE_SYNTAX); + PRINT_MACRO(_RWSTD_NO_NONCLASS_ARROW_RETURN); + PRINT_MACRO(_RWSTD_NO_NONTYPE_ARGS); + PRINT_MACRO(_RWSTD_NO_ONLY_NEEDED_INSTANTIATION); + PRINT_MACRO(_RWSTD_NO_OVERLOAD_C_POW); + PRINT_MACRO(_RWSTD_NO_OVERLOAD_OF_TEMPLATE_FUNCTION); + PRINT_MACRO(_RWSTD_NO_OVERLOAD_WCHAR); + PRINT_MACRO(_RWSTD_NO_PART_SPEC_OVERLOAD); + PRINT_MACRO(_RWSTD_NO_RET_TEMPLATE); + PRINT_MACRO(_RWSTD_NO_SIMPLE_DEFAULT_TEMPLATES); + PRINT_MACRO(_RWSTD_NO_STATIC_CAST); + PRINT_MACRO(_RWSTD_NO_STATIC_DEF); + PRINT_MACRO(_RWSTD_NO_STATIC_DEF2); + PRINT_MACRO(_RWSTD_NO_STATIC_DEF3); + PRINT_MACRO(_RWSTD_NO_STATIC_MEM_DEF); + PRINT_MACRO(_RWSTD_NO_STI_SIMPLE); + PRINT_MACRO(_RWSTD_NO_STI_TEMPLATE); + PRINT_MACRO(_RWSTD_NO_STREAM_LONG_DOUBLE); + PRINT_MACRO(_RWSTD_NO_STRFTIME_CAPC); + PRINT_MACRO(_RWSTD_NO_STRICT_TEMPLATE_INSTANTIATE); + PRINT_MACRO(_RWSTD_NO_SWPRINTF); + PRINT_MACRO(_RWSTD_NO_TEMPLATE_ON_RETURN_TYPE); + PRINT_MACRO(_RWSTD_NO_TEMPLATE_TEMPLATE); + PRINT_MACRO(_RWSTD_NO_THREADS); + PRINT_MACRO(_RWSTD_NO_THROW_SPEC_ON_NEW); + PRINT_MACRO(_RWSTD_NO_THROW_WITH_SHARED); + PRINT_MACRO(_RWSTD_NO_TYPEDEF_INST); + PRINT_MACRO(_RWSTD_NO_TYPEDEF_OVERLOAD); + PRINT_MACRO(_RWSTD_NO_TYPENAME); + PRINT_MACRO(_RWSTD_NO_UNDEFINED_FRIEND); + PRINT_MACRO(_RWSTD_NO_UNINITIALIZED_STATIC_DEF); + PRINT_MACRO(_RWSTD_NO_WCHAR_H); + PRINT_MACRO(_RWSTD_NO_WCTYPE_H); + PRINT_MACRO(_RWSTD_NO_WIDE_CHAR); + PRINT_MACRO(_RWSTD_NO_WINT_TYPE); + PRINT_MACRO(_RWSTD_NO_WSTR); + PRINT_MACRO(_RWSTD_NOT_ALL_WSTR_CFUNCTIONS); + PRINT_MACRO(_RWSTD_POSIX_D10_THREADS); + PRINT_MACRO(_RWSTD_POSIX_THREADS); + PRINT_MACRO(_RWSTD_REQUIRES_IEEEFP); + PRINT_MACRO(_RWSTD_SOLARIS_THREADS); + PRINT_MACRO(_RWSTD_STRUCT_TM_TZ); + PRINT_MACRO(_RWSTD_WIDE_STRING_NULL_PROBLEM); + #elif defined(__STD_RWCOMPILER_H__) + // Rogue Wave 1.x std lib: + PRINT_MACRO(__NO_EDG_EXCEPTION_CLASSES); + PRINT_MACRO(RWSTD_ALLOCATOR); + PRINT_MACRO(RWSTD_BAD_ALLOC_DEFINED); + PRINT_MACRO(RWSTD_BAD_EXCEPTION_DEFINED); + PRINT_MACRO(RWSTD_BOUNDS_CHECKING); + PRINT_MACRO(RWSTD_COMPILE_INSTANTIATE); + PRINT_MACRO(RWSTD_DEFAULT_PRECISION); + PRINT_MACRO(RWSTD_EXCEPTION_DEFINED); + PRINT_MACRO(RWSTD_EXCEPTION_HANDLER_IN_STD); + PRINT_MACRO(RWSTD_EXCEPTION_PREDEFINED); + PRINT_MACRO(RWSTD_FLT_ROUNDS_IS_CONSTANT); + PRINT_MACRO(RWSTD_LOCALIZED_ERRORS); + PRINT_MACRO(RWSTD_MESSAGE); + PRINT_MACRO(RWSTD_MUTEXATTR_DEFAULT); + PRINT_MACRO(RWSTD_NO_ANSI_SPRINTF); + PRINT_MACRO(RWSTD_NO_ARG_MATCH); + PRINT_MACRO(RWSTD_NO_BAD_CAST); + PRINT_MACRO(RWSTD_NO_BASE_CLASS_MATCH); + PRINT_MACRO(RWSTD_NO_BOOL); + PRINT_MACRO(RWSTD_NO_BUILTIN_CTOR); + PRINT_MACRO(RWSTD_NO_CATOPEN_CATGETS); + PRINT_MACRO(RWSTD_NO_CLASS_PARTIAL_SPEC); + PRINT_MACRO(RWSTD_NO_COMPLEX_DEFAULT_TEMPLATES); + PRINT_MACRO(RWSTD_NO_COMPLICATED_EXCEPTIONS); + PRINT_MACRO(RWSTD_NO_COMPLICATED_TYPEDEF); + PRINT_MACRO(RWSTD_NO_CONST_INST); + PRINT_MACRO(RWSTD_NO_CTOR_RETURN); + PRINT_MACRO(RWSTD_NO_DEFAULT_FOR_TPARAM); + PRINT_MACRO(RWSTD_NO_DEFAULT_TEMPLATE_ARGS); + PRINT_MACRO(RWSTD_NO_DESTROY_BUILTIN); + PRINT_MACRO(RWSTD_NO_DESTROY_NONBUILTIN); + PRINT_MACRO(RWSTD_NO_EMBEDDED_TYPEDEF); + PRINT_MACRO(RWSTD_NO_EX_SPEC); + PRINT_MACRO(RWSTD_NO_EXCEPTIONS); + PRINT_MACRO(RWSTD_NO_EXPLICIT); + PRINT_MACRO(RWSTD_NO_EXPLICIT_ARG); + PRINT_MACRO(RWSTD_NO_EXPLICIT_FUNC_INSTANTIATION); + PRINT_MACRO(RWSTD_NO_EXPLICIT_INSTANTIATION); + PRINT_MACRO(RWSTD_NO_EXTENSION); + PRINT_MACRO(RWSTD_NO_FORWARD_SPECIALIZATIONS); + PRINT_MACRO(RWSTD_NO_FPOS_T); + PRINT_MACRO(RWSTD_NO_FRIEND_TEMPLATES); + PRINT_MACRO(RWSTD_NO_FUNC_PARTIAL_SPEC); + PRINT_MACRO(RWSTD_NO_GETTIMEOFDAY); + PRINT_MACRO(RWSTD_NO_GLOBAL_TZ); + PRINT_MACRO(RWSTD_NO_INHERITED_TYPEDEFS); + PRINT_MACRO(RWSTD_NO_INIT_CONST_TEMPLATE_REF_ARG); + PRINT_MACRO(RWSTD_NO_INT_TYPEDEF); + PRINT_MACRO(RWSTD_NO_LDIV); + PRINT_MACRO(RWSTD_NO_LEADING_UNDERSCORE); + PRINT_MACRO(RWSTD_NO_LOCALE); + PRINT_MACRO(RWSTD_NO_LONG_NAME); + PRINT_MACRO(RWSTD_NO_LONGDOUBLE); + PRINT_MACRO(RWSTD_NO_MBSTATE_T); + PRINT_MACRO(RWSTD_NO_MEM_CLASS_TEMPLATES); + PRINT_MACRO(RWSTD_NO_MEMBER_TEMPLATES); + PRINT_MACRO(RWSTD_NO_MEMBER_TYPE_TPARAM); + PRINT_MACRO(RWSTD_NO_MEMBER_WO_DEF_CTOR); + PRINT_MACRO(RWSTD_NO_MEMMOVE); + PRINT_MACRO(RWSTD_NO_MULTI_DIM_ARRAY); + PRINT_MACRO(RWSTD_NO_MUTABLE); + PRINT_MACRO(RWSTD_NO_NAME_INJECTION); + PRINT_MACRO(RWSTD_NO_NAMESPACE); + PRINT_MACRO(RWSTD_NO_NESTING_TEMPLATES); + PRINT_MACRO(RWSTD_NO_NEW_BRACKETS); + PRINT_MACRO(RWSTD_NO_NEW_DECL); + PRINT_MACRO(RWSTD_NO_NEW_HEADER); + PRINT_MACRO(RWSTD_NO_NEW_TEMPLATE_SYNTAX); + PRINT_MACRO(RWSTD_NO_NONCLASS_ARROW_RETURN); + PRINT_MACRO(RWSTD_NO_NONTYPE_ARGS); + PRINT_MACRO(RWSTD_NO_ONLY_NEEDED_INSTANTIATION); + PRINT_MACRO(RWSTD_NO_OVERLOAD_C_POW); + PRINT_MACRO(RWSTD_NO_OVERLOAD_OF_TEMPLATE_FUNCTION); + PRINT_MACRO(RWSTD_NO_OVERLOAD_WCHAR); + PRINT_MACRO(RWSTD_NO_PART_SPEC_OVERLOAD); + PRINT_MACRO(RWSTD_NO_RET_TEMPLATE); + PRINT_MACRO(RWSTD_NO_SIMPLE_DEFAULT_TEMPLATES); + PRINT_MACRO(RWSTD_NO_STATIC_CAST); + PRINT_MACRO(RWSTD_NO_STATIC_DEF); + PRINT_MACRO(RWSTD_NO_STATIC_DEF2); + PRINT_MACRO(RWSTD_NO_STATIC_DEF3); + PRINT_MACRO(RWSTD_NO_STATIC_MEM_DEF); + PRINT_MACRO(RWSTD_NO_STI_SIMPLE); + PRINT_MACRO(RWSTD_NO_STI_TEMPLATE); + PRINT_MACRO(RWSTD_NO_STREAM_LONG_DOUBLE); + PRINT_MACRO(RWSTD_NO_STRFTIME_CAPC); + PRINT_MACRO(RWSTD_NO_STRICT_TEMPLATE_INSTANTIATE); + PRINT_MACRO(RWSTD_NO_SWPRINTF); + PRINT_MACRO(RWSTD_NO_TEMPLATE_ON_RETURN_TYPE); + PRINT_MACRO(RWSTD_NO_TEMPLATE_TEMPLATE); + PRINT_MACRO(RWSTD_NO_THREADS); + PRINT_MACRO(RWSTD_NO_THROW_SPEC_ON_NEW); + PRINT_MACRO(RWSTD_NO_THROW_WITH_SHARED); + PRINT_MACRO(RWSTD_NO_TYPEDEF_INST); + PRINT_MACRO(RWSTD_NO_TYPEDEF_OVERLOAD); + PRINT_MACRO(RWSTD_NO_TYPENAME); + PRINT_MACRO(RWSTD_NO_UNDEFINED_FRIEND); + PRINT_MACRO(RWSTD_NO_UNINITIALIZED_STATIC_DEF); + PRINT_MACRO(RWSTD_NO_WCHAR_H); + PRINT_MACRO(RWSTD_NO_WCTYPE_H); + PRINT_MACRO(RWSTD_NO_WIDE_CHAR); + PRINT_MACRO(RWSTD_NO_WINT_TYPE); + PRINT_MACRO(RWSTD_NO_WSTR); + PRINT_MACRO(RWSTD_NOT_ALL_WSTR_CFUNCTIONS); + PRINT_MACRO(RWSTD_POSIX_D10_THREADS); + PRINT_MACRO(RWSTD_POSIX_THREADS); + PRINT_MACRO(RWSTD_REQUIRES_IEEEFP); + PRINT_MACRO(RWSTD_SOLARIS_THREADS); + PRINT_MACRO(RWSTD_STRUCT_TM_TZ); + PRINT_MACRO(RWSTD_WIDE_STRING_NULL_PROBLEM); + #endif + // Dinkumware options: + PRINT_MACRO(_CPPLIB_VER); + PRINT_MACRO(_MSVC_STL_VERSION); // VS2017 15.5+ + PRINT_MACRO(_MSVC_STL_UPDATE); // VS2017 15.5+ + PRINT_MACRO(_GLOBAL_USING); + PRINT_MACRO(_HAS_EXCEPTIONS); + PRINT_MACRO(_HAS_MEMBER_TEMPLATES_REBIND); + PRINT_MACRO(_HAS_TEMPLATE_PARTIAL_ORDERING); + // https://blogs.msdn.microsoft.com/vcblog/2016/08/12/stl-fixes-in-vs-2015-update-3/ + PRINT_MACRO(_HAS_CXX17); + PRINT_MACRO(_HAS_AUTO_PTR_ETC); + PRINT_MACRO(_HAS_OLD_IOSTREAMS_MEMBERS); + PRINT_MACRO(_HAS_FUNCTION_ASSIGN); + PRINT_MACRO(_HAS_TR1_NAMESPACE); + PRINT_MACRO(_HAS_IDENTITY_STRUCT); + // VS2017 15.5+ + PRINT_MACRO(_HAS_STATIC_RTTI); + PRINT_MACRO(_HAS_UNEXPECTED); + PRINT_MACRO(_HAS_STD_BYTE); + PRINT_MACRO(_HAS_FUNCTION_ALLOCATOR_SUPPORT); + PRINT_MACRO(_HAS_TR2_SYS_NAMESPACE); + PRINT_MACRO(_ENFORCE_MATCHING_ALLOCATORS); + PRINT_MACRO(_HAS_HAS_UNIQUE_OBJECT_REPRESENTATIONS); + PRINT_MACRO(_HAS_INLINE_VARIABLES); + PRINT_MACRO(_HAS_ALIGNED_NEW); + PRINT_MACRO(_HAS_NOEXCEPT_FUNCTION_TYPES); + PRINT_MACRO(_ITERATOR_DEBUG_LEVEL); + PRINT_MACRO(_HAS_ITERATOR_DEBUGGING); + PRINT_MACRO(_ITERATOR_DEBUG_ARRAY_OVERLOADS); + // Libc++: + PRINT_MACRO(_LIBCPP_VERSION); + // STLPort and generic SGI STL options: + PRINT_MACRO(__SGI_STL_NO_ARROW_OPERATOR); + PRINT_MACRO(__SGI_STL_OWN_IOSTREAMS); + PRINT_MACRO(__SGI_STL_PORT); + PRINT_MACRO(__STL_AUTOMATIC_TYPE_TRAITS); + PRINT_MACRO(__STL_BASE_MATCH_BUG); + PRINT_MACRO(__STL_BASE_TYPEDEF_BUG); + PRINT_MACRO(__STL_BASE_TYPEDEF_OUTSIDE_BUG); + PRINT_MACRO(__STL_BROKEN_USING_DIRECTIVE); + PRINT_MACRO(__STL_CONST_CONSTRUCTOR_BUG); + PRINT_MACRO(__STL_DEBUG); + PRINT_MACRO(__STL_DEBUG_ALLOC); + PRINT_MACRO(__STL_DEFAULT_CONSTRUCTOR_BUG); + PRINT_MACRO(__STL_DEFAULT_TYPE_PARAM); + PRINT_MACRO(__STL_DONT_REDEFINE_STD); + PRINT_MACRO(__STL_DONT_USE_BOOL_TYPEDEF); + PRINT_MACRO(__STL_HAS_NO_EXCEPTIONS); + PRINT_MACRO(__STL_HAS_NO_NAMESPACES); + PRINT_MACRO(__STL_HAS_NO_NEW_C_HEADERS); + PRINT_MACRO(__STL_HAS_NO_NEW_IOSTREAMS); + PRINT_MACRO(__STL_IMPORT_VENDOR_CSTD); + PRINT_MACRO(__STL_LIMITED_DEFAULT_TEMPLATES); + PRINT_MACRO(__STL_LINK_TIME_INSTANTIATION); + PRINT_MACRO(__STL_LONG_LONG); + PRINT_MACRO(__STL_LOOP_INLINE_PROBLEMS); + PRINT_MACRO(__STL_MEMBER_POINTER_PARAM_BUG); + PRINT_MACRO(__STL_NEED_EXPLICIT); + PRINT_MACRO(__STL_NEED_MUTABLE); + PRINT_MACRO(__STL_NEED_TYPENAME); + PRINT_MACRO(__STL_NESTED_TYPE_PARAM_BUG); + PRINT_MACRO(__STL_NO_BAD_ALLOC); + PRINT_MACRO(__STL_NO_BOOL); + PRINT_MACRO(__STL_NO_CLASS_PARTIAL_SPECIALIZATION); + PRINT_MACRO(__STL_NO_CSTD_FUNCTION_IMPORTS); + PRINT_MACRO(__STL_NO_DEFAULT_NON_TYPE_PARAM); + PRINT_MACRO(__STL_NO_EXCEPTION_HEADER); + PRINT_MACRO(__STL_NO_EXCEPTION_SPEC); + PRINT_MACRO(__STL_NO_EXCEPTIONS); + PRINT_MACRO(__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS); + PRINT_MACRO(__STL_NO_FRIEND_TEMPLATES); + PRINT_MACRO(__STL_NO_FUNCTION_TMPL_PARTIAL_ORDER); + PRINT_MACRO(__STL_NO_IOSTREAMS); + PRINT_MACRO(__STL_NO_LONG_DOUBLE); + PRINT_MACRO(__STL_NO_MEMBER_TEMPLATE_CLASSES); + PRINT_MACRO(__STL_NO_MEMBER_TEMPLATE_KEYWORD); + PRINT_MACRO(__STL_NO_MEMBER_TEMPLATES); + PRINT_MACRO(__STL_NO_METHOD_SPECIALIZATION); + PRINT_MACRO(__STL_NO_NAMESPACES); + PRINT_MACRO(__STL_NO_NEW_IOSTREAMS); + PRINT_MACRO(__STL_NO_NEW_NEW_HEADER); + PRINT_MACRO(__STL_NO_NEW_STYLE_CASTS); + PRINT_MACRO(__STL_NO_PARTIAL_SPECIALIZATION_SYNTAX); + PRINT_MACRO(__STL_NO_QUALIFIED_FRIENDS); + PRINT_MACRO(__STL_NO_RELOPS_NAMESPACE); + PRINT_MACRO(__STL_NO_SGI_IOSTREAMS); + PRINT_MACRO(__STL_NO_STATIC_TEMPLATE_DATA); + PRINT_MACRO(__STL_NO_TEMPLATE_CONVERSIONS); + PRINT_MACRO(__STL_NO_WCHAR_T); + PRINT_MACRO(__STL_NON_TYPE_TMPL_PARAM_BUG); + PRINT_MACRO(__STL_NONTEMPL_BASE_MATCH_BUG); + PRINT_MACRO(__STL_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS); + PRINT_MACRO(__STL_RAND48); + PRINT_MACRO(__STL_STATIC_ARRAY_BUG); + PRINT_MACRO(__STL_STATIC_CONST_INIT_BUG); + PRINT_MACRO(__STL_STATIC_CONST_INIT_BUG); + PRINT_MACRO(__STL_THROW_RETURN_BUG); + PRINT_MACRO(__STL_TRIVIAL_CONSTRUCTOR_BUG); + PRINT_MACRO(__STL_TRIVIAL_DESTRUCTOR_BUG); + PRINT_MACRO(__STL_UNINITIALIZABLE_PRIVATE); + PRINT_MACRO(__STL_USE_ABBREVS); + PRINT_MACRO(__STL_USE_DEFALLOC); + PRINT_MACRO(__STL_USE_MALLOC); + PRINT_MACRO(__STL_USE_NEW_C_HEADERS); + PRINT_MACRO(__STL_USE_NEW_IOSTREAMS); + PRINT_MACRO(__STL_USE_NEWALLOC); + PRINT_MACRO(__STL_USE_OWN_NAMESPACE); + PRINT_MACRO(__STL_USE_SGI_ALLOCATORS); + PRINT_MACRO(__STL_WCHAR_T_IS_USHORT); + PRINT_MACRO(__STL_WEAK_ATTRIBUTE); + PRINT_MACRO(__STL_YVALS_H); + PRINT_MACRO(_NOTHREADS); + PRINT_MACRO(_PTHREADS); +#if defined(__SGI_STL_PORT) && (__SGI_STL_PORT > 0x0400) + PRINT_MACRO(_STLP_AUTOMATIC_TYPE_TRAITS); + PRINT_MACRO(_STLP_BASE_MATCH_BUG); + PRINT_MACRO(_STLP_BASE_TYPEDEF_BUG); + PRINT_MACRO(_STLP_BASE_TYPEDEF_OUTSIDE_BUG); + PRINT_MACRO(_STLP_BROKEN_USING_DIRECTIVE); + PRINT_MACRO(_STLP_CONST_CONSTRUCTOR_BUG); + PRINT_MACRO(_STLP_DEBUG); + PRINT_MACRO(_STLP_DEBUG_ALLOC); + PRINT_MACRO(_STLP_DEFAULT_CONSTRUCTOR_BUG); + PRINT_MACRO(_STLP_DEFAULT_TYPE_PARAM); + PRINT_MACRO(_STLP_DONT_REDEFINE_STD); + PRINT_MACRO(_STLP_DONT_USE_BOOL_TYPEDEF); + PRINT_MACRO(_STLP_HAS_NO_EXCEPTIONS); + PRINT_MACRO(_STLP_HAS_NO_NAMESPACES); + PRINT_MACRO(_STLP_HAS_NO_NEW_C_HEADERS); + PRINT_MACRO(_STLP_HAS_NO_NEW_IOSTREAMS); + PRINT_MACRO(_STLP_IMPORT_VENDOR_CSTD); + PRINT_MACRO(_STLP_LIMITED_DEFAULT_TEMPLATES); + PRINT_MACRO(_STLP_LINK_TIME_INSTANTIATION); + PRINT_MACRO(_STLP_LONG_LONG); + PRINT_MACRO(_STLP_LOOP_INLINE_PROBLEMS); + PRINT_MACRO(_STLP_MEMBER_POINTER_PARAM_BUG); + PRINT_MACRO(_STLP_NEED_EXPLICIT); + PRINT_MACRO(_STLP_NEED_MUTABLE); + PRINT_MACRO(_STLP_NEED_TYPENAME); + PRINT_MACRO(_STLP_NESTED_TYPE_PARAM_BUG); + PRINT_MACRO(_STLP_NO_ARROW_OPERATOR); + PRINT_MACRO(_STLP_NO_BAD_ALLOC); + PRINT_MACRO(_STLP_NO_BOOL); + PRINT_MACRO(_STLP_NO_CLASS_PARTIAL_SPECIALIZATION); + PRINT_MACRO(_STLP_NO_CSTD_FUNCTION_IMPORTS); + PRINT_MACRO(_STLP_NO_DEFAULT_NON_TYPE_PARAM); + PRINT_MACRO(_STLP_NO_EXCEPTION_HEADER); + PRINT_MACRO(_STLP_NO_EXCEPTION_SPEC); + PRINT_MACRO(_STLP_NO_EXCEPTIONS); + PRINT_MACRO(_STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS); + PRINT_MACRO(_STLP_NO_FRIEND_TEMPLATES); + PRINT_MACRO(_STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER); + PRINT_MACRO(_STLP_NO_IOSTREAMS); + PRINT_MACRO(_STLP_NO_LONG_DOUBLE); + PRINT_MACRO(_STLP_NO_MEMBER_TEMPLATE_CLASSES); + PRINT_MACRO(_STLP_NO_MEMBER_TEMPLATE_KEYWORD); + PRINT_MACRO(_STLP_NO_MEMBER_TEMPLATES); + PRINT_MACRO(_STLP_NO_METHOD_SPECIALIZATION); + PRINT_MACRO(_STLP_NO_NAMESPACES); + PRINT_MACRO(_STLP_NO_NEW_IOSTREAMS); + PRINT_MACRO(_STLP_NO_NEW_NEW_HEADER); + PRINT_MACRO(_STLP_NO_NEW_STYLE_CASTS); + PRINT_MACRO(_STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX); + PRINT_MACRO(_STLP_NO_QUALIFIED_FRIENDS); + PRINT_MACRO(_STLP_NO_RELOPS_NAMESPACE); + PRINT_MACRO(_STLP_NO_SGI_IOSTREAMS); + PRINT_MACRO(_STLP_NO_STATIC_TEMPLATE_DATA); + PRINT_MACRO(_STLP_NO_TEMPLATE_CONVERSIONS); + PRINT_MACRO(_STLP_NO_WCHAR_T); + PRINT_MACRO(_STLP_NON_TYPE_TMPL_PARAM_BUG); + PRINT_MACRO(_STLP_NONTEMPL_BASE_MATCH_BUG); + PRINT_MACRO(_STLP_OWN_IOSTREAMS); + PRINT_MACRO(_STLP_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS); + PRINT_MACRO(_STLP_RAND48); + PRINT_MACRO(_STLP_STATIC_ARRAY_BUG); + PRINT_MACRO(_STLP_STATIC_CONST_INIT_BUG); + PRINT_MACRO(_STLP_STATIC_CONST_INIT_BUG); + PRINT_MACRO(_STLP_THROW_RETURN_BUG); + PRINT_MACRO(_STLP_TRIVIAL_CONSTRUCTOR_BUG); + PRINT_MACRO(_STLP_TRIVIAL_DESTRUCTOR_BUG); + PRINT_MACRO(_STLP_UNINITIALIZABLE_PRIVATE); + PRINT_MACRO(_STLP_USE_ABBREVS); + PRINT_MACRO(_STLP_USE_DEFALLOC); + PRINT_MACRO(_STLP_USE_MALLOC); + PRINT_MACRO(_STLP_USE_NEW_C_HEADERS); + PRINT_MACRO(_STLP_USE_NEWALLOC); + PRINT_MACRO(_STLP_USE_OWN_NAMESPACE); + PRINT_MACRO(_STLP_USE_SGI_ALLOCATORS); + PRINT_MACRO(_STLP_WCHAR_T_IS_USHORT); + PRINT_MACRO(_STLP_WEAK_ATTRIBUTE); + PRINT_MACRO(_STLP_YVALS_H); +#endif + PRINT_MACRO(__GLIBCPP__); + PRINT_MACRO(_GLIBCPP_USE_WCHAR_T); + PRINT_MACRO(_GLIBCPP_VERSION); + PRINT_MACRO(__GLIBCXX__); + PRINT_MACRO(_GLIBCXX_USE_WCHAR_T); + PRINT_MACRO(_GLIBCXX_VERSION); + PRINT_MACRO(_GLIBCXX_USE_LONG_LONG); + PRINT_MACRO(_GLIBCXX_USE_NLS); + PRINT_MACRO(_GLIBCXX_USE_C99_MATH); + PRINT_MACRO(_GLIBCXX_USE_C99); + PRINT_MACRO(_GLIBCXX_CONCEPT_CHECKS); + PRINT_MACRO(_GLIBCXX_USE_LFS); + PRINT_MACRO(_GLIBCXX_SYMVER); + PRINT_MACRO(_GLIBCXX_MEM_LIMITS); + PRINT_MACRO(_GLIBCXX_HOSTED); + PRINT_MACRO(_GLIBCXX_SJLJ_EXCEPTIONS); + PRINT_MACRO(_GLIBCXX_RELEASE); + PRINT_MACRO(_GLIBCXX_USE_FLOAT128); + + // Modena C++ standard library + PRINT_MACRO(MSIPL_ANSI_HEADER); + PRINT_MACRO(MSIPL_BOOL_BUILTIN); + PRINT_MACRO(MSIPL_DEF_EXPLICIT); + PRINT_MACRO(MSIPL_DEF_TEMPARG); + PRINT_MACRO(MSIPL_EXPINST_ALLOWED); + PRINT_MACRO(MSIPL_EXPLICIT_FUNC_TEMPLATE_ARG); + PRINT_MACRO(MISPL_EXPLICIT_TEMPLATE_ARGUMENT); + PRINT_MACRO(MSIPL_FUNC_TEMPLATE_DEFARG); + PRINT_MACRO(MSIPL_MEMBER_TEMPLATE); + PRINT_MACRO(MSIPL_MULTITHREAD); + PRINT_MACRO(MSIPL_NON_TYPE_TEMPARG); + PRINT_MACRO(MSIPL_PARTIAL_TEMPL); + PRINT_MACRO(MSIPL_STATIC_CONST_INIT); + PRINT_MACRO(MSIPL_TEMPL_NEWSPEC); + PRINT_MACRO(MSIPL_TYPENAME); + PRINT_MACRO(MSIPL_USING_NAMESPACE); + PRINT_MACRO(MSIPL_WCHART); +} + +void print_platform_macros() +{ + std::cout << "Detected Platform: " << BOOST_PLATFORM << std::endl; + // signedness: + PRINT_SIGN(char); + PRINT_SIGN(wchar_t); + // byte ordering: + PRINT_ORDER(short); + PRINT_ORDER(int); + PRINT_ORDER(long); + // sizes: + PRINT_EXPRESSION(sizeof(wchar_t)); + PRINT_EXPRESSION(sizeof(short)); + PRINT_EXPRESSION(sizeof(int)); + PRINT_EXPRESSION(sizeof(long)); + PRINT_EXPRESSION(sizeof(size_t)); + PRINT_EXPRESSION(sizeof(ptrdiff_t)); + PRINT_EXPRESSION(sizeof(void*)); + PRINT_EXPRESSION(sizeof(void(*)(void))); + PRINT_EXPRESSION(sizeof(float)); + PRINT_EXPRESSION(sizeof(double)); + PRINT_EXPRESSION(sizeof(long double)); + // limits: + PRINT_MACRO(CHAR_BIT); + PRINT_MACRO(CHAR_MAX); + PRINT_MACRO(WCHAR_MAX); + PRINT_MACRO(SHRT_MAX); + PRINT_MACRO(INT_MAX); + PRINT_MACRO(LONG_MAX); + PRINT_MACRO(LLONG_MAX); + PRINT_MACRO(LONG_LONG_MAX); + PRINT_MACRO(LONGLONG_MAX); + PRINT_MACRO(ULLONG_MAX); // uses these, so we need to know them + PRINT_MACRO(ULONG_LONG_MAX); + PRINT_MACRO(ULONGLONG_MAX); + // general C99: + PRINT_MACRO(__STDC_IEC_559__); + PRINT_MACRO(__STDC_IEC_559_COMPLEX__); + PRINT_MACRO(__STDC_ISO_10646__); + // GNU: + PRINT_MACRO(__GLIBC__); + PRINT_MACRO(__GLIBC_MINOR__); + PRINT_MACRO(__GNU_LIBRARY__); + PRINT_MACRO(_BSD_SOURCE); + PRINT_MACRO(_GNU_SOURCE); + PRINT_MACRO(_ISOC99_SOURCE); + PRINT_MACRO(_ISOC9X_SOURCE); + PRINT_MACRO(_LARGEFILE_SOURCE); + PRINT_MACRO(_LARGEFILE64_SOURCE); + PRINT_MACRO(_SVID_SOURCE); + PRINT_MACRO(_THREAD_SAFE); + PRINT_MACRO(_XOPEN_SOURCE_EXTENDED); + PRINT_MACRO(XPG); + PRINT_MACRO(__MINGW32_MAJOR_VERSION); + PRINT_MACRO(__MINGW32_MINOR_VERSION); + // POSIX: + PRINT_MACRO(_POSIX_ADVISORY_INFO); + PRINT_MACRO(_POSIX_ASYNCHRONOUS_IO); + PRINT_MACRO(_POSIX_BARRIERS); + PRINT_MACRO(_POSIX_C_SOURCE); + PRINT_MACRO(_POSIX_CHOWN_RESTRICTED); + PRINT_MACRO(_POSIX_CLOCK_SELECTION); + PRINT_MACRO(_POSIX_CPUTIME); + PRINT_MACRO(_POSIX_FSYNC); + PRINT_MACRO(_POSIX_JOB_CONTROL); + PRINT_MACRO(_POSIX_MAPPED_FILES); + PRINT_MACRO(_POSIX_MEMLOCK); + PRINT_MACRO(_POSIX_MEMLOCK_RANGE); + PRINT_MACRO(_POSIX_MEMORY_PROTECTION); + PRINT_MACRO(_POSIX_MESSAGE_PASSING); + PRINT_MACRO(_POSIX_MONOTONIC_CLOCK); + PRINT_MACRO(_POSIX_NO_TRUNC); + PRINT_MACRO(_POSIX_PRIORITIZED_IO); + PRINT_MACRO(_POSIX_PRIORITY_SCHEDULING); + PRINT_MACRO(_POSIX_RAW_SOCKETS); + PRINT_MACRO(_POSIX_READER_WRITER_LOCKS); + PRINT_MACRO(_POSIX_REALTIME_SIGNALS); + PRINT_MACRO(_POSIX_REGEXP); + PRINT_MACRO(_POSIX_SAVED_IDS); + PRINT_MACRO(_POSIX_SEMAPHORES); + PRINT_MACRO(_POSIX_SHARED_MEMORY_OBJECTS); + PRINT_MACRO(_POSIX_SHELL); + PRINT_MACRO(_POSIX_SOURCE); + PRINT_MACRO(_POSIX_SPAWN); + PRINT_MACRO(_POSIX_SPIN_LOCKS); + PRINT_MACRO(_POSIX_SPORADIC_SERVER); + PRINT_MACRO(_POSIX_SYNCHRONIZED_IO); + PRINT_MACRO(_POSIX_THREAD_ATTR_STACKADDR); + PRINT_MACRO(_POSIX_THREAD_ATTR_STACKSIZE); + PRINT_MACRO(_POSIX_THREAD_CPUTIME); + PRINT_MACRO(_POSIX_THREAD_PRIO_INHERIT); + PRINT_MACRO(_POSIX_THREAD_PRIO_PROTECT); + PRINT_MACRO(_POSIX_THREAD_PRIORITY_SCHEDULING); + PRINT_MACRO(_POSIX_THREAD_PROCESS_SHARED); + PRINT_MACRO(_POSIX_THREAD_SAFE_FUNCTIONS); + PRINT_MACRO(_POSIX_THREAD_SPORADIC_SERVER); + PRINT_MACRO(_POSIX_THREADS); + PRINT_MACRO(_POSIX_TIMEOUTS); + PRINT_MACRO(_POSIX_TIMERS); + PRINT_MACRO(_POSIX_TRACE); + PRINT_MACRO(_POSIX_TRACE_EVENT_FILTER); + PRINT_MACRO(_POSIX_TRACE_INHERIT); + PRINT_MACRO(_POSIX_TRACE_LOG); + PRINT_MACRO(_POSIX_TYPED_MEMORY_OBJECTS); + PRINT_MACRO(_POSIX_VDISABLE); + PRINT_MACRO(_POSIX_VERSION); + PRINT_MACRO(_POSIX2_C_BIND); + PRINT_MACRO(_POSIX2_C_DEV); + PRINT_MACRO(_POSIX2_CHAR_TERM); + PRINT_MACRO(_POSIX2_FORT_DEV); + PRINT_MACRO(_POSIX2_FORT_RUN); + PRINT_MACRO(_POSIX2_LOCALEDEF); + PRINT_MACRO(_POSIX2_PBS); + PRINT_MACRO(_POSIX2_PBS_ACCOUNTING); + PRINT_MACRO(_POSIX2_PBS_CHECKPOINT); + PRINT_MACRO(_POSIX2_PBS_LOCATE); + PRINT_MACRO(_POSIX2_PBS_MESSAGE); + PRINT_MACRO(_POSIX2_PBS_TRACK); + PRINT_MACRO(_POSIX2_SW_DEV); + PRINT_MACRO(_POSIX2_UPE); + PRINT_MACRO(_POSIX2_VERSION); + PRINT_MACRO(_V6_ILP32_OFF32); + PRINT_MACRO(_V6_ILP32_OFFBIG); + PRINT_MACRO(_V6_LP64_OFF64); + PRINT_MACRO(_V6_LPBIG_OFFBIG); + PRINT_MACRO(_XBS5_ILP32_OFF32); + PRINT_MACRO(_XBS5_ILP32_OFFBIG); + PRINT_MACRO(_XBS5_LP64_OFF64); + PRINT_MACRO(_XBS5_LPBIG_OFFBIG); + PRINT_MACRO(_XOPEN_CRYPT); + PRINT_MACRO(_XOPEN_ENH_I18N); + PRINT_MACRO(_XOPEN_LEGACY); + PRINT_MACRO(_XOPEN_REALTIME); + PRINT_MACRO(_XOPEN_REALTIME_THREADS); + PRINT_MACRO(_XOPEN_SHM); + PRINT_MACRO(_XOPEN_SOURCE); + PRINT_MACRO(_XOPEN_STREAMS); + PRINT_MACRO(_XOPEN_UNIX); + PRINT_MACRO(_XOPEN_VERSION); + // Misc: + PRINT_MACRO(__USE_BSD); + PRINT_MACRO(_FILE_OFFSET_BITS); +} + +void print_boost_macros() +{ + std::cout << "Boost version " << BOOST_STRINGIZE(BOOST_VERSION) << std::endl; + // config setup macros first: + PRINT_MACRO(BOOST_USER_CONFIG); + PRINT_MACRO(BOOST_COMPILER_CONFIG); + PRINT_MACRO(BOOST_STDLIB_CONFIG); + PRINT_MACRO(BOOST_PLATFORM_CONFIG); + PRINT_MACRO(BOOST_NO_CONFIG); + PRINT_MACRO(BOOST_NO_USER_CONFIG); + PRINT_MACRO(BOOST_NO_COMPILER_CONFIG); + PRINT_MACRO(BOOST_NO_STDLIB_CONFIG); + PRINT_MACRO(BOOST_NO_PLATFORM_CONFIG); + // then defect and feature macros: + PRINT_MACRO(BOOST_DISABLE_THREADS); + PRINT_MACRO(BOOST_DISABLE_WIN32); + PRINT_MACRO(BOOST_HAS_THREADS); + PRINT_MACRO(BOOST_WINDOWS); + + // BEGIN GENERATED BLOCK DO NOT EDIT THIS!!!!!! + PRINT_MACRO(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG); + PRINT_MACRO(BOOST_DEDUCED_TYPENAME); + PRINT_MACRO(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL); + PRINT_MACRO(BOOST_HAS_BETHREADS); + PRINT_MACRO(BOOST_HAS_CLOCK_GETTIME); + PRINT_MACRO(BOOST_HAS_DIRENT_H); + PRINT_MACRO(BOOST_HAS_EXPM1); + PRINT_MACRO(BOOST_HAS_FLOAT128); + PRINT_MACRO(BOOST_HAS_FTIME); + PRINT_MACRO(BOOST_HAS_GETSYSTEMTIMEASFILETIME); + PRINT_MACRO(BOOST_HAS_GETTIMEOFDAY); + PRINT_MACRO(BOOST_HAS_HASH); + PRINT_MACRO(BOOST_HAS_INT128); + PRINT_MACRO(BOOST_HAS_LOG1P); + PRINT_MACRO(BOOST_HAS_LONG_LONG); + PRINT_MACRO(BOOST_HAS_MACRO_USE_FACET); + PRINT_MACRO(BOOST_HAS_MS_INT64); + PRINT_MACRO(BOOST_HAS_NANOSLEEP); + PRINT_MACRO(BOOST_HAS_NL_TYPES_H); + PRINT_MACRO(BOOST_HAS_NRVO); + PRINT_MACRO(BOOST_HAS_PARTIAL_STD_ALLOCATOR); + PRINT_MACRO(BOOST_HAS_PRAGMA_DETECT_MISMATCH); + PRINT_MACRO(BOOST_HAS_PTHREADS); + PRINT_MACRO(BOOST_HAS_PTHREAD_DELAY_NP); + PRINT_MACRO(BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE); + PRINT_MACRO(BOOST_HAS_PTHREAD_YIELD); + PRINT_MACRO(BOOST_HAS_RVALUE_REFS); + PRINT_MACRO(BOOST_HAS_SCHED_YIELD); + PRINT_MACRO(BOOST_HAS_SGI_TYPE_TRAITS); + PRINT_MACRO(BOOST_HAS_SIGACTION); + PRINT_MACRO(BOOST_HAS_SLIST); + PRINT_MACRO(BOOST_HAS_STATIC_ASSERT); + PRINT_MACRO(BOOST_HAS_STDINT_H); + PRINT_MACRO(BOOST_HAS_STLP_USE_FACET); + PRINT_MACRO(BOOST_HAS_TWO_ARG_USE_FACET); + PRINT_MACRO(BOOST_HAS_UNISTD_H); + PRINT_MACRO(BOOST_HAS_VARIADIC_TMPL); + PRINT_MACRO(BOOST_HAS_WINTHREADS); + PRINT_MACRO(BOOST_MSVC6_MEMBER_TEMPLATES); + PRINT_MACRO(BOOST_MSVC_STD_ITERATOR); + PRINT_MACRO(BOOST_NO_ADL_BARRIER); + PRINT_MACRO(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP); + PRINT_MACRO(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS); + PRINT_MACRO(BOOST_NO_AUTO_PTR); + PRINT_MACRO(BOOST_NO_COMPLETE_VALUE_INITIALIZATION); + PRINT_MACRO(BOOST_NO_CTYPE_FUNCTIONS); + PRINT_MACRO(BOOST_NO_CV_SPECIALIZATIONS); + PRINT_MACRO(BOOST_NO_CV_VOID_SPECIALIZATIONS); + PRINT_MACRO(BOOST_NO_CWCHAR); + PRINT_MACRO(BOOST_NO_CWCTYPE); + PRINT_MACRO(BOOST_NO_CXX03); + PRINT_MACRO(BOOST_NO_CXX11); + PRINT_MACRO(BOOST_NO_CXX11_ADDRESSOF); + PRINT_MACRO(BOOST_NO_CXX11_ALIGNAS); + PRINT_MACRO(BOOST_NO_CXX11_ALIGNOF); + PRINT_MACRO(BOOST_NO_CXX11_ALLOCATOR); + PRINT_MACRO(BOOST_NO_CXX11_ATOMIC_SMART_PTR); + PRINT_MACRO(BOOST_NO_CXX11_AUTO_DECLARATIONS); + PRINT_MACRO(BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS); + PRINT_MACRO(BOOST_NO_CXX11_CHAR16_T); + PRINT_MACRO(BOOST_NO_CXX11_CHAR32_T); + PRINT_MACRO(BOOST_NO_CXX11_CONSTEXPR); + PRINT_MACRO(BOOST_NO_CXX11_DECLTYPE); + PRINT_MACRO(BOOST_NO_CXX11_DECLTYPE_N3276); + PRINT_MACRO(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS); + PRINT_MACRO(BOOST_NO_CXX11_DEFAULTED_MOVES); + PRINT_MACRO(BOOST_NO_CXX11_DELETED_FUNCTIONS); + PRINT_MACRO(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS); + PRINT_MACRO(BOOST_NO_CXX11_EXTERN_TEMPLATE); + PRINT_MACRO(BOOST_NO_CXX11_FINAL); + PRINT_MACRO(BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS); + PRINT_MACRO(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS); + PRINT_MACRO(BOOST_NO_CXX11_HDR_ARRAY); + PRINT_MACRO(BOOST_NO_CXX11_HDR_ATOMIC); + PRINT_MACRO(BOOST_NO_CXX11_HDR_CHRONO); + PRINT_MACRO(BOOST_NO_CXX11_HDR_CODECVT); + PRINT_MACRO(BOOST_NO_CXX11_HDR_CONDITION_VARIABLE); + PRINT_MACRO(BOOST_NO_CXX11_HDR_EXCEPTION); + PRINT_MACRO(BOOST_NO_CXX11_HDR_FORWARD_LIST); + PRINT_MACRO(BOOST_NO_CXX11_HDR_FUNCTIONAL); + PRINT_MACRO(BOOST_NO_CXX11_HDR_FUTURE); + PRINT_MACRO(BOOST_NO_CXX11_HDR_INITIALIZER_LIST); + PRINT_MACRO(BOOST_NO_CXX11_HDR_MUTEX); + PRINT_MACRO(BOOST_NO_CXX11_HDR_RANDOM); + PRINT_MACRO(BOOST_NO_CXX11_HDR_RATIO); + PRINT_MACRO(BOOST_NO_CXX11_HDR_REGEX); + PRINT_MACRO(BOOST_NO_CXX11_HDR_SYSTEM_ERROR); + PRINT_MACRO(BOOST_NO_CXX11_HDR_THREAD); + PRINT_MACRO(BOOST_NO_CXX11_HDR_TUPLE); + PRINT_MACRO(BOOST_NO_CXX11_HDR_TYPEINDEX); + PRINT_MACRO(BOOST_NO_CXX11_HDR_TYPE_TRAITS); + PRINT_MACRO(BOOST_NO_CXX11_HDR_UNORDERED_MAP); + PRINT_MACRO(BOOST_NO_CXX11_HDR_UNORDERED_SET); + PRINT_MACRO(BOOST_NO_CXX11_INLINE_NAMESPACES); + PRINT_MACRO(BOOST_NO_CXX11_LAMBDAS); + PRINT_MACRO(BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS); + PRINT_MACRO(BOOST_NO_CXX11_NOEXCEPT); + PRINT_MACRO(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS); + PRINT_MACRO(BOOST_NO_CXX11_NULLPTR); + PRINT_MACRO(BOOST_NO_CXX11_NUMERIC_LIMITS); + PRINT_MACRO(BOOST_NO_CXX11_OVERRIDE); + PRINT_MACRO(BOOST_NO_CXX11_POINTER_TRAITS); + PRINT_MACRO(BOOST_NO_CXX11_RANGE_BASED_FOR); + PRINT_MACRO(BOOST_NO_CXX11_RAW_LITERALS); + PRINT_MACRO(BOOST_NO_CXX11_REF_QUALIFIERS); + PRINT_MACRO(BOOST_NO_CXX11_RVALUE_REFERENCES); + PRINT_MACRO(BOOST_NO_CXX11_SCOPED_ENUMS); + PRINT_MACRO(BOOST_NO_CXX11_SFINAE_EXPR); + PRINT_MACRO(BOOST_NO_CXX11_SMART_PTR); + PRINT_MACRO(BOOST_NO_CXX11_STATIC_ASSERT); + PRINT_MACRO(BOOST_NO_CXX11_STD_ALIGN); + PRINT_MACRO(BOOST_NO_CXX11_TEMPLATE_ALIASES); + PRINT_MACRO(BOOST_NO_CXX11_THREAD_LOCAL); + PRINT_MACRO(BOOST_NO_CXX11_TRAILING_RESULT_TYPES); + PRINT_MACRO(BOOST_NO_CXX11_UNICODE_LITERALS); + PRINT_MACRO(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX); + PRINT_MACRO(BOOST_NO_CXX11_UNRESTRICTED_UNION); + PRINT_MACRO(BOOST_NO_CXX11_USER_DEFINED_LITERALS); + PRINT_MACRO(BOOST_NO_CXX11_VARIADIC_MACROS); + PRINT_MACRO(BOOST_NO_CXX11_VARIADIC_TEMPLATES); + PRINT_MACRO(BOOST_NO_CXX14); + PRINT_MACRO(BOOST_NO_CXX14_AGGREGATE_NSDMI); + PRINT_MACRO(BOOST_NO_CXX14_BINARY_LITERALS); + PRINT_MACRO(BOOST_NO_CXX14_CONSTEXPR); + PRINT_MACRO(BOOST_NO_CXX14_DECLTYPE_AUTO); + PRINT_MACRO(BOOST_NO_CXX14_DIGIT_SEPARATORS); + PRINT_MACRO(BOOST_NO_CXX14_GENERIC_LAMBDAS); + PRINT_MACRO(BOOST_NO_CXX14_HDR_SHARED_MUTEX); + PRINT_MACRO(BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES); + PRINT_MACRO(BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION); + PRINT_MACRO(BOOST_NO_CXX14_STD_EXCHANGE); + PRINT_MACRO(BOOST_NO_CXX14_VARIABLE_TEMPLATES); + PRINT_MACRO(BOOST_NO_CXX17); + PRINT_MACRO(BOOST_NO_CXX17_AUTO_NONTYPE_TEMPLATE_PARAMS); + PRINT_MACRO(BOOST_NO_CXX17_DEDUCTION_GUIDES); + PRINT_MACRO(BOOST_NO_CXX17_FOLD_EXPRESSIONS); + PRINT_MACRO(BOOST_NO_CXX17_HDR_ANY); + PRINT_MACRO(BOOST_NO_CXX17_HDR_CHARCONV); + PRINT_MACRO(BOOST_NO_CXX17_HDR_EXECUTION); + PRINT_MACRO(BOOST_NO_CXX17_HDR_FILESYSTEM); + PRINT_MACRO(BOOST_NO_CXX17_HDR_MEMORY_RESOURCE); + PRINT_MACRO(BOOST_NO_CXX17_HDR_OPTIONAL); + PRINT_MACRO(BOOST_NO_CXX17_HDR_STRING_VIEW); + PRINT_MACRO(BOOST_NO_CXX17_HDR_VARIANT); + PRINT_MACRO(BOOST_NO_CXX17_IF_CONSTEXPR); + PRINT_MACRO(BOOST_NO_CXX17_INLINE_VARIABLES); + PRINT_MACRO(BOOST_NO_CXX17_ITERATOR_TRAITS); + PRINT_MACRO(BOOST_NO_CXX17_STD_APPLY); + PRINT_MACRO(BOOST_NO_CXX17_STD_INVOKE); + PRINT_MACRO(BOOST_NO_CXX17_STRUCTURED_BINDINGS); + PRINT_MACRO(BOOST_NO_CXX20_HDR_BARRIER); + PRINT_MACRO(BOOST_NO_CXX20_HDR_BIT); + PRINT_MACRO(BOOST_NO_CXX20_HDR_COMPARE); + PRINT_MACRO(BOOST_NO_CXX20_HDR_CONCEPTS); + PRINT_MACRO(BOOST_NO_CXX20_HDR_COROUTINE); + PRINT_MACRO(BOOST_NO_CXX20_HDR_FORMAT); + PRINT_MACRO(BOOST_NO_CXX20_HDR_LATCH); + PRINT_MACRO(BOOST_NO_CXX20_HDR_NUMBERS); + PRINT_MACRO(BOOST_NO_CXX20_HDR_RANGES); + PRINT_MACRO(BOOST_NO_CXX20_HDR_SEMAPHORE); + PRINT_MACRO(BOOST_NO_CXX20_HDR_SOURCE_LOCATION); + PRINT_MACRO(BOOST_NO_CXX20_HDR_SPAN); + PRINT_MACRO(BOOST_NO_CXX20_HDR_STOP_TOKEN); + PRINT_MACRO(BOOST_NO_CXX20_HDR_SYNCSTREAM); + PRINT_MACRO(BOOST_NO_CXX20_HDR_VERSION); + PRINT_MACRO(BOOST_NO_CXX23_HDR_EXPECTED); + PRINT_MACRO(BOOST_NO_CXX23_HDR_FLAT_MAP); + PRINT_MACRO(BOOST_NO_CXX23_HDR_FLAT_SET); + PRINT_MACRO(BOOST_NO_CXX23_HDR_GENERATOR); + PRINT_MACRO(BOOST_NO_CXX23_HDR_MDSPAN); + PRINT_MACRO(BOOST_NO_CXX23_HDR_PRINT); + PRINT_MACRO(BOOST_NO_CXX23_HDR_SPANSTREAM); + PRINT_MACRO(BOOST_NO_CXX23_HDR_STACKTRACE); + PRINT_MACRO(BOOST_NO_CXX23_HDR_STDFLOAT); + PRINT_MACRO(BOOST_NO_CXX98_BINDERS); + PRINT_MACRO(BOOST_NO_CXX98_FUNCTION_BASE); + PRINT_MACRO(BOOST_NO_CXX98_RANDOM_SHUFFLE); + PRINT_MACRO(BOOST_NO_DEPENDENT_NESTED_DERIVATIONS); + PRINT_MACRO(BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS); + PRINT_MACRO(BOOST_NO_EXCEPTIONS); + PRINT_MACRO(BOOST_NO_EXCEPTION_STD_NAMESPACE); + PRINT_MACRO(BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS); + PRINT_MACRO(BOOST_NO_FENV_H); + PRINT_MACRO(BOOST_NO_FUNCTION_TEMPLATE_ORDERING); + PRINT_MACRO(BOOST_NO_FUNCTION_TYPE_SPECIALIZATIONS); + PRINT_MACRO(BOOST_NO_INCLASS_MEMBER_INITIALIZATION); + PRINT_MACRO(BOOST_NO_INTEGRAL_INT64_T); + PRINT_MACRO(BOOST_NO_INTRINSIC_WCHAR_T); + PRINT_MACRO(BOOST_NO_IOSFWD); + PRINT_MACRO(BOOST_NO_IOSTREAM); + PRINT_MACRO(BOOST_NO_IS_ABSTRACT); + PRINT_MACRO(BOOST_NO_LIMITS); + PRINT_MACRO(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS); + PRINT_MACRO(BOOST_NO_LONG_LONG); + PRINT_MACRO(BOOST_NO_LONG_LONG_NUMERIC_LIMITS); + PRINT_MACRO(BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS); + PRINT_MACRO(BOOST_NO_MEMBER_TEMPLATES); + PRINT_MACRO(BOOST_NO_MEMBER_TEMPLATE_FRIENDS); + PRINT_MACRO(BOOST_NO_MEMBER_TEMPLATE_KEYWORD); + PRINT_MACRO(BOOST_NO_MS_INT64_NUMERIC_LIMITS); + PRINT_MACRO(BOOST_NO_NESTED_FRIENDSHIP); + PRINT_MACRO(BOOST_NO_OPERATORS_IN_NAMESPACE); + PRINT_MACRO(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS); + PRINT_MACRO(BOOST_NO_POINTER_TO_MEMBER_CONST); + PRINT_MACRO(BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS); + PRINT_MACRO(BOOST_NO_PRIVATE_IN_AGGREGATE); + PRINT_MACRO(BOOST_NO_RESTRICT_REFERENCES); + PRINT_MACRO(BOOST_NO_RTTI); + PRINT_MACRO(BOOST_NO_SFINAE); + PRINT_MACRO(BOOST_NO_SFINAE_EXPR); + PRINT_MACRO(BOOST_NO_STDC_NAMESPACE); + PRINT_MACRO(BOOST_NO_STD_ALLOCATOR); + PRINT_MACRO(BOOST_NO_STD_DISTANCE); + PRINT_MACRO(BOOST_NO_STD_ITERATOR); + PRINT_MACRO(BOOST_NO_STD_ITERATOR_TRAITS); + PRINT_MACRO(BOOST_NO_STD_LOCALE); + PRINT_MACRO(BOOST_NO_STD_MESSAGES); + PRINT_MACRO(BOOST_NO_STD_MIN_MAX); + PRINT_MACRO(BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN); + PRINT_MACRO(BOOST_NO_STD_TYPEINFO); + PRINT_MACRO(BOOST_NO_STD_USE_FACET); + PRINT_MACRO(BOOST_NO_STD_WSTREAMBUF); + PRINT_MACRO(BOOST_NO_STD_WSTRING); + PRINT_MACRO(BOOST_NO_STRINGSTREAM); + PRINT_MACRO(BOOST_NO_SWPRINTF); + PRINT_MACRO(BOOST_NO_TEMPLATED_IOSTREAMS); + PRINT_MACRO(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS); + PRINT_MACRO(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION); + PRINT_MACRO(BOOST_NO_TEMPLATE_TEMPLATES); + PRINT_MACRO(BOOST_NO_TWO_PHASE_NAME_LOOKUP); + PRINT_MACRO(BOOST_NO_TYPEID); + PRINT_MACRO(BOOST_NO_TYPENAME_WITH_CTOR); + PRINT_MACRO(BOOST_NO_UNREACHABLE_RETURN_DETECTION); + PRINT_MACRO(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE); + PRINT_MACRO(BOOST_NO_USING_TEMPLATE); + PRINT_MACRO(BOOST_NO_VOID_RETURNS); + + + + + + + + + + + + + + + + + + + // END GENERATED BLOCK + + PRINT_MACRO(BOOST_CXX_VERSION); + PRINT_MACRO(BOOST_INTEL); + PRINT_MACRO(BOOST_MSVC); + PRINT_MACRO(BOOST_GCC); + PRINT_MACRO(BOOST_CLANG); + PRINT_MACRO(BOOST_CLANG_VERSION); + PRINT_MACRO(BOOST_LIBSTDCXX_VERSION); + PRINT_MACRO(BOOST_MSSTL_VERSION); + PRINT_MACRO(BOOST_STD_EXTENSION_NAMESPACE); + PRINT_MACRO(BOOST_UNREACHABLE_RETURN(0)); + PRINT_MACRO(BOOST_CONSTEXPR); + PRINT_MACRO(BOOST_CONSTEXPR_OR_CONST); + PRINT_MACRO(BOOST_STATIC_CONSTEXPR); + PRINT_MACRO(BOOST_NOEXCEPT); + PRINT_MACRO(BOOST_FORCEINLINE); + PRINT_MACRO(BOOST_NOINLINE); + PRINT_MACRO(BOOST_FALLTHROUGH); + PRINT_MACRO(BOOST_MAY_ALIAS); + PRINT_MACRO(BOOST_NO_MAY_ALIAS); + PRINT_MACRO(BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS); + PRINT_MACRO(BOOST_ATTRIBUTE_UNUSED); + PRINT_MACRO(BOOST_UNLIKELY); + PRINT_MACRO(BOOST_NORETURN); +} + +#ifdef __has_include +#if __has_include() +# include +#endif +#if __has_include() && (BOOST_CXX_VERSION > 201100) +# include +#endif +#endif + +void print_sd6_macros() +{ + // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0096r5.html + + // Library macros are only really available if we have : + + PRINT_MACRO(__cpp_lib_addressof_constexpr); + PRINT_MACRO(__cpp_lib_allocator_traits_is_always_equal); + PRINT_MACRO(__cpp_lib_any); + PRINT_MACRO(__cpp_lib_apply); + PRINT_MACRO(__cpp_lib_array_constexpr); + PRINT_MACRO(__cpp_lib_as_const); + PRINT_MACRO(__cpp_lib_assume_aligned); + PRINT_MACRO(__cpp_lib_atomic_flag_test); + PRINT_MACRO(__cpp_lib_atomic_float); + PRINT_MACRO(__cpp_lib_atomic_is_always_lock_free); + PRINT_MACRO(__cpp_lib_atomic_lock_free_type_aliases); + PRINT_MACRO(__cpp_lib_atomic_ref); + PRINT_MACRO(__cpp_lib_atomic_shared_ptr); + PRINT_MACRO(__cpp_lib_atomic_value_initialization); + PRINT_MACRO(__cpp_lib_atomic_wait); + PRINT_MACRO(__cpp_lib_barrier); + PRINT_MACRO(__cpp_lib_bind_front); + PRINT_MACRO(__cpp_lib_bit_cast); + PRINT_MACRO(__cpp_lib_bitops); + PRINT_MACRO(__cpp_lib_bool_constant); + PRINT_MACRO(__cpp_lib_bounded_array_traits); + PRINT_MACRO(__cpp_lib_boyer_moore_searcher); + PRINT_MACRO(__cpp_lib_byte); + PRINT_MACRO(__cpp_lib_char8_t); + PRINT_MACRO(__cpp_lib_chrono); + PRINT_MACRO(__cpp_lib_chrono_udls); + PRINT_MACRO(__cpp_lib_clamp); + PRINT_MACRO(__cpp_lib_complex_udls); + PRINT_MACRO(__cpp_lib_concepts); + PRINT_MACRO(__cpp_lib_constexpr_algorithms); + PRINT_MACRO(__cpp_lib_constexpr_complex); + PRINT_MACRO(__cpp_lib_constexpr_dynamic_alloc); + PRINT_MACRO(__cpp_lib_constexpr_functional); + PRINT_MACRO(__cpp_lib_constexpr_iterator); + PRINT_MACRO(__cpp_lib_constexpr_memory); + PRINT_MACRO(__cpp_lib_constexpr_numeric); + PRINT_MACRO(__cpp_lib_constexpr_string); + PRINT_MACRO(__cpp_lib_constexpr_string_view); + PRINT_MACRO(__cpp_lib_constexpr_tuple); + PRINT_MACRO(__cpp_lib_constexpr_utility); + PRINT_MACRO(__cpp_lib_constexpr_vector); + PRINT_MACRO(__cpp_lib_coroutine); + PRINT_MACRO(__cpp_lib_destroying_delete); + PRINT_MACRO(__cpp_lib_enable_shared_from_this); + PRINT_MACRO(__cpp_lib_endian); + PRINT_MACRO(__cpp_lib_erase_if); + PRINT_MACRO(__cpp_lib_exchange_function); + PRINT_MACRO(__cpp_lib_execution); + PRINT_MACRO(__cpp_lib_expected); + PRINT_MACRO(__cpp_lib_filesystem); + PRINT_MACRO(__cpp_lib_flat_map); + PRINT_MACRO(__cpp_lib_flat_set); + PRINT_MACRO(__cpp_lib_format); + PRINT_MACRO(__cpp_lib_gcd_lcm); + PRINT_MACRO(__cpp_lib_generator); + PRINT_MACRO(__cpp_lib_generic_associative_lookup); + PRINT_MACRO(__cpp_lib_generic_unordered_lookup); + PRINT_MACRO(__cpp_lib_hardware_interference_size); + PRINT_MACRO(__cpp_lib_has_unique_object_representations); + PRINT_MACRO(__cpp_lib_hypot); + PRINT_MACRO(__cpp_lib_incomplete_container_elements); + PRINT_MACRO(__cpp_lib_int_pow2); + PRINT_MACRO(__cpp_lib_integer_comparison_functions); + PRINT_MACRO(__cpp_lib_integer_sequence); + PRINT_MACRO(__cpp_lib_integral_constant_callable); + PRINT_MACRO(__cpp_lib_interpolate); + PRINT_MACRO(__cpp_lib_invoke); + PRINT_MACRO(__cpp_lib_is_aggregate); + PRINT_MACRO(__cpp_lib_is_constant_evaluated); + PRINT_MACRO(__cpp_lib_is_final); + PRINT_MACRO(__cpp_lib_is_invocable); + PRINT_MACRO(__cpp_lib_is_layout_compatible); + PRINT_MACRO(__cpp_lib_is_nothrow_convertible); + PRINT_MACRO(__cpp_lib_is_null_pointer); + PRINT_MACRO(__cpp_lib_is_pointer_interconvertible); + PRINT_MACRO(__cpp_lib_is_swappable); + PRINT_MACRO(__cpp_lib_jthread); + PRINT_MACRO(__cpp_lib_latch); + PRINT_MACRO(__cpp_lib_launder); + PRINT_MACRO(__cpp_lib_list_remove_return_type); + PRINT_MACRO(__cpp_lib_logical_traits); + PRINT_MACRO(__cpp_lib_make_from_tuple); + PRINT_MACRO(__cpp_lib_make_reverse_iterator); + PRINT_MACRO(__cpp_lib_make_unique); + PRINT_MACRO(__cpp_lib_map_try_emplace); + PRINT_MACRO(__cpp_lib_math_constants); + PRINT_MACRO(__cpp_lib_math_special_functions); + PRINT_MACRO(__cpp_lib_mdspan); + PRINT_MACRO(__cpp_lib_memory_resource); + PRINT_MACRO(__cpp_lib_node_extract); + PRINT_MACRO(__cpp_lib_nonmember_container_access); + PRINT_MACRO(__cpp_lib_not_fn); + PRINT_MACRO(__cpp_lib_null_iterators); + PRINT_MACRO(__cpp_lib_optional); + PRINT_MACRO(__cpp_lib_parallel_algorithm); + PRINT_MACRO(__cpp_lib_polymorphic_allocator); + PRINT_MACRO(__cpp_lib_print); + PRINT_MACRO(__cpp_lib_quoted_string_io); + PRINT_MACRO(__cpp_lib_ranges); + PRINT_MACRO(__cpp_lib_raw_memory_algorithms); + PRINT_MACRO(__cpp_lib_remove_cvref); + PRINT_MACRO(__cpp_lib_result_of_sfinae); + PRINT_MACRO(__cpp_lib_robust_nonmodifying_seq_ops); + PRINT_MACRO(__cpp_lib_sample); + PRINT_MACRO(__cpp_lib_scoped_lock); + PRINT_MACRO(__cpp_lib_semaphore); + PRINT_MACRO(__cpp_lib_shared_mutex); + PRINT_MACRO(__cpp_lib_shared_ptr_arrays); + PRINT_MACRO(__cpp_lib_shared_ptr_weak_type); + PRINT_MACRO(__cpp_lib_shared_timed_mutex); + PRINT_MACRO(__cpp_lib_shift); + PRINT_MACRO(__cpp_lib_smart_ptr_for_overwrite); + PRINT_MACRO(__cpp_lib_source_location); + PRINT_MACRO(__cpp_lib_span); + PRINT_MACRO(__cpp_lib_spanstream); + PRINT_MACRO(__cpp_lib_ssize); + PRINT_MACRO(__cpp_lib_stacktrace); + PRINT_MACRO(__cpp_lib_starts_ends_with); + PRINT_MACRO(__cpp_lib_string_udls); + PRINT_MACRO(__cpp_lib_string_view); + PRINT_MACRO(__cpp_lib_syncbuf); + PRINT_MACRO(__cpp_lib_three_way_comparison); + PRINT_MACRO(__cpp_lib_to_address); + PRINT_MACRO(__cpp_lib_to_array); + PRINT_MACRO(__cpp_lib_to_chars); + PRINT_MACRO(__cpp_lib_transformation_trait_aliases); + PRINT_MACRO(__cpp_lib_transparent_operators); + PRINT_MACRO(__cpp_lib_tuple_element_t); + PRINT_MACRO(__cpp_lib_tuples_by_type); + PRINT_MACRO(__cpp_lib_type_identity); + PRINT_MACRO(__cpp_lib_type_trait_variable_templates); + PRINT_MACRO(__cpp_lib_uncaught_exceptions); + PRINT_MACRO(__cpp_lib_unordered_map_try_emplace); + PRINT_MACRO(__cpp_lib_unwrap_ref); + PRINT_MACRO(__cpp_lib_variant); + PRINT_MACRO(__cpp_lib_void_t); + + // C++20: + PRINT_MACRO(__cpp_aggregate_paren_init); + PRINT_MACRO(__cpp_char8_t); + PRINT_MACRO(__cpp_char8_type); + PRINT_MACRO(__cpp_conditional_explicit); + PRINT_MACRO(__cpp_coroutines); + PRINT_MACRO(__cpp_impl_destroying_delete); + PRINT_MACRO(__cpp_impl_three_way_comparison); + PRINT_MACRO(__cpp_nontype_template_parameter_class); + + // C++17: + PRINT_MACRO(__cpp_hex_float); + PRINT_MACRO(__cpp_inline_variables); + PRINT_MACRO(__cpp_aligned_new); + PRINT_MACRO(__cpp_guaranteed_copy_elision); + PRINT_MACRO(__cpp_noexcept_function_type); + PRINT_MACRO(__cpp_fold_expressions); + PRINT_MACRO(__cpp_capture_star_this); + PRINT_MACRO(__cpp_constexpr); + PRINT_MACRO(__cpp_if_constexpr); + PRINT_MACRO(__cpp_range_based_for); + PRINT_MACRO(__cpp_static_assert); + PRINT_MACRO(__cpp_deduction_guides); + PRINT_MACRO(__cpp_nontype_template_parameter_auto); + PRINT_MACRO(__cpp_namespace_attributes); + PRINT_MACRO(__cpp_enumerator_attributes); + PRINT_MACRO(__cpp_inheriting_constructors); + PRINT_MACRO(__cpp_variadic_using); + PRINT_MACRO(__cpp_structured_bindings); + PRINT_MACRO(__cpp_aggregate_bases); + PRINT_MACRO(__cpp_nontype_template_args); + PRINT_MACRO(__cpp_template_template_args); + + // C++14: + PRINT_MACRO(__cpp_binary_literals); + PRINT_MACRO(__cpp_init_captures); + PRINT_MACRO(__cpp_generic_lambdas); + PRINT_MACRO(__cpp_sized_deallocation); + PRINT_MACRO(__cpp_decltype_auto); + PRINT_MACRO(__cpp_return_type_deduction); + PRINT_MACRO(__cpp_aggregate_nsdmi); + PRINT_MACRO(__cpp_variable_templates); + + // C++11: + PRINT_MACRO(__cpp_unicode_characters); + PRINT_MACRO(__cpp_raw_strings); + PRINT_MACRO(__cpp_unicode_literals); + PRINT_MACRO(__cpp_user_defined_literals); + PRINT_MACRO(__cpp_threadsafe_static_init); + PRINT_MACRO(__cpp_lambdas); + PRINT_MACRO(__cpp_decltype); + PRINT_MACRO(__cpp_attributes); + PRINT_MACRO(__cpp_rvalue_references); + PRINT_MACRO(__cpp_variadic_templates); + PRINT_MACRO(__cpp_initializer_lists); + PRINT_MACRO(__cpp_delegating_constructors); + PRINT_MACRO(__cpp_nsdmi); + PRINT_MACRO(__cpp_ref_qualifiers); + PRINT_MACRO(__cpp_alias_templates); + + // C++98: + PRINT_MACRO(__cpp_rtti); + PRINT_MACRO(__cpp_exceptions); + + // : + PRINT_MACRO(ATOMIC_INT_LOCK_FREE); + PRINT_MACRO(ATOMIC_SHORT_LOCK_FREE); + PRINT_MACRO(ATOMIC_LONG_LOCK_FREE); + PRINT_MACRO(ATOMIC_LLONG_LOCK_FREE); + PRINT_MACRO(ATOMIC_POINTER_LOCK_FREE); + PRINT_MACRO(ATOMIC_CHAR_LOCK_FREE); + PRINT_MACRO(ATOMIC_WCHAR_T_LOCK_FREE); + PRINT_MACRO(ATOMIC_CHAR8_T_LOCK_FREE); + PRINT_MACRO(ATOMIC_CHAR16_T_LOCK_FREE); + PRINT_MACRO(ATOMIC_CHAR32_T_LOCK_FREE); +} + +void print_separator() +{ + std::cout << +"\n\n*********************************************************************\n\n"; +} + +int main() +{ + + // boost compiler workaround defines + print_compiler_macros(); + print_separator(); + print_stdlib_macros(); + print_separator(); + print_platform_macros(); + print_separator(); + print_boost_macros(); + print_separator(); + print_sd6_macros(); + + return 0; +} From 8e2a51e90582d78a9078f66c5d8631595e411fe1 Mon Sep 17 00:00:00 2001 From: Rene Rivera Date: Thu, 25 Apr 2024 22:56:00 -0500 Subject: [PATCH 05/26] Add missing lib reference. --- example/Jamfile.v2 | 2 +- test/Jamfile.v2 | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/example/Jamfile.v2 b/example/Jamfile.v2 index baaadad4..6ccef7b6 100644 --- a/example/Jamfile.v2 +++ b/example/Jamfile.v2 @@ -42,7 +42,7 @@ path-constant HERE : . ; test-suite regex-examples : -[ regex-test-run timer/regex_timer.cpp : $(HERE)/timer/input_script.txt ] +[ regex-test-run timer/regex_timer.cpp /boost/smart_ptr//boost_smart_ptr : $(HERE)/timer/input_script.txt ] [ regex-test-run grep/grep.cpp /boost/program_options//boost_program_options/static : -n -b $(HERE)/../include/boost/regex.hpp : test_grep ] [ regex-test-run snippets/credit_card_example.cpp ] [ regex-test-run snippets/mfc_example.cpp ] diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index a9975d26..7baf5f69 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -102,13 +102,13 @@ run object_cache/object_cache_test.cpp ; run config_info/regex_config_info.cpp ../build//boost_regex/static : : : always_show_run_output ; run config_info/regex_config_info.cpp ../build//boost_regex : : : always_show_run_output : regex_dll_config_info ; run collate_info/collate_info.cpp ../build//boost_regex : : : always_show_run_output : test_collate_info ; -link concepts/concept_check.cpp : gcc:-Wno-deprecated-copy ; +link concepts/concept_check.cpp /boost/range//boost_range : gcc:-Wno-deprecated-copy ; link concepts/concept_check.cpp : BOOST_REGEX_STANDALONE gcc:-Wno-deprecated-copy : standalone_concept_check ; link concepts/icu_concept_check.cpp : BOOST_REGEX_STANDALONE gcc:-Wno-deprecated-copy ; link concepts/icu_concept_check.cpp : gcc:-Wno-deprecated-copy : standalone_icu_concept_check ; link concepts/range_concept_check.cpp : gcc:-Wno-deprecated-copy ; run concepts/test_bug_11988.cpp ; -run captures/captures_test.cpp ../build//icu_options : : : multi BOOST_REGEX_MATCH_EXTRA=1 BOOST_REGEX_NO_LIB=1 : captures_test ; +run captures/captures_test.cpp ../build//icu_options /boost/array//boost_array : : : multi BOOST_REGEX_MATCH_EXTRA=1 BOOST_REGEX_NO_LIB=1 : captures_test ; run regress/$(R_SOURCE) ./noeh_test//boost_regex_noeh ../build//icu_options : : : BOOST_NO_EXCEPTIONS=1 off static shared : regex_regress_noeh ; compile test_consolidated.cpp ; From 801d83fb4fa2b15a8833d939f18a169c552dc8cc Mon Sep 17 00:00:00 2001 From: Rene Rivera Date: Sun, 28 Apr 2024 20:16:39 -0500 Subject: [PATCH 06/26] Add missing NO_LIB usage requirements. --- build/Jamfile.v2 | 36 +++++++++++++++++++----------------- 1 file changed, 19 insertions(+), 17 deletions(-) diff --git a/build/Jamfile.v2 b/build/Jamfile.v2 index 4026d7ec..d428a2d2 100644 --- a/build/Jamfile.v2 +++ b/build/Jamfile.v2 @@ -1,6 +1,6 @@ # copyright John Maddock 2003 -# Distributed under the Boost Software License, Version 1.0. -# (See accompanying file LICENSE_1_0.txt or copy at +# 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. import modules ; @@ -17,13 +17,13 @@ local disable-icu = [ MATCH (--disable-icu) : [ modules.peek : ARGV ] ] ; rule path_options ( properties * ) { local result ; - if 64 in $(properties) && msvc in $(properties) + if 64 in $(properties) && msvc in $(properties) { - result = $(ICU_PATH)/bin64 $(ICU_PATH)/lib64 ; + result = $(ICU_PATH)/bin64 $(ICU_PATH)/lib64 ; } else { - result = $(ICU_PATH)/bin $(ICU_PATH)/lib ; + result = $(ICU_PATH)/bin $(ICU_PATH)/lib ; } return $(result) ; } @@ -34,24 +34,24 @@ rule path_options ( properties * ) if ! $(disable-icu) { if [ modules.peek : ICU_LINK ] - { + { errors.user-error : "The ICU_LINK option is no longer supported by the Boost.Regex build - please refer to the documentation for equivalent options" ; } if [ modules.peek : ICU_PATH ] - { + { ICU_PATH = [ modules.peek : ICU_PATH ] ; } if [ modules.peek : ICU_ICUUC_NAME ] - { + { ICU_ICUUC_NAME = [ modules.peek : ICU_ICUUC_NAME ] ; } if [ modules.peek : ICU_ICUDT_NAME ] - { + { ICU_ICUDT_NAME = [ modules.peek : ICU_ICUDT_NAME ] ; } if [ modules.peek : ICU_ICUIN_NAME ] - { + { ICU_ICUIN_NAME = [ modules.peek : ICU_ICUIN_NAME ] ; } @@ -102,8 +102,8 @@ if ! $(disable-icu) lib icuin : : this_is_an_invalid_library_name ; } - ICU_OPTS = - $(ICU_PATH)/include + ICU_OPTS = + $(ICU_PATH)/include shared:icuuc/shared shared:icudt/shared shared:icuin/shared @@ -111,7 +111,7 @@ if ! $(disable-icu) static:icudt static:icuin windows,clang:"advapi32.lib" - BOOST_HAS_ICU=1 + BOOST_HAS_ICU=1 static:U_STATIC_IMPLEMENTATION=1 ; @@ -144,13 +144,15 @@ explicit has_icu ; alias icu_options : : : : [ check-target-builds has_icu : $(ICU_OPTS) : ] ; -SOURCES = +SOURCES = posix_api.cpp wide_posix_api.cpp ; lib boost_regex : ../src/$(SOURCES) icu_options - : - shared:BOOST_REGEX_DYN_LINK=1 - gcc-cygwin:static + : + shared:BOOST_REGEX_DYN_LINK=1 + gcc-cygwin:static + : : : + BOOST_REGEX_NO_LIB=1 ; From e469b8aae5498f5aa7c30d82323a99cfa6e83076 Mon Sep 17 00:00:00 2001 From: Rene Rivera Date: Sun, 28 Apr 2024 21:00:15 -0500 Subject: [PATCH 07/26] Fix extra arg for lib declaration. --- build/Jamfile.v2 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build/Jamfile.v2 b/build/Jamfile.v2 index d428a2d2..c8ccd3a5 100644 --- a/build/Jamfile.v2 +++ b/build/Jamfile.v2 @@ -153,6 +153,6 @@ lib boost_regex : ../src/$(SOURCES) icu_options : shared:BOOST_REGEX_DYN_LINK=1 gcc-cygwin:static - : : : + : : BOOST_REGEX_NO_LIB=1 ; From 126875cac97d59533ac2acde62875aea365ba6c8 Mon Sep 17 00:00:00 2001 From: Rene Rivera Date: Mon, 29 Apr 2024 22:08:35 -0500 Subject: [PATCH 08/26] Update library dependencies. --- test/Jamfile.v2 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 7baf5f69..766dc484 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -106,7 +106,7 @@ link concepts/concept_check.cpp /boost/range//boost_range : gcc:BOOST_REGEX_STANDALONE gcc:-Wno-deprecated-copy : standalone_concept_check ; link concepts/icu_concept_check.cpp : BOOST_REGEX_STANDALONE gcc:-Wno-deprecated-copy ; link concepts/icu_concept_check.cpp : gcc:-Wno-deprecated-copy : standalone_icu_concept_check ; -link concepts/range_concept_check.cpp : gcc:-Wno-deprecated-copy ; +link concepts/range_concept_check.cpp : gcc:-Wno-deprecated-copy /boost/range//boost_range ; run concepts/test_bug_11988.cpp ; run captures/captures_test.cpp ../build//icu_options /boost/array//boost_array : : : multi BOOST_REGEX_MATCH_EXTRA=1 BOOST_REGEX_NO_LIB=1 : captures_test ; run regress/$(R_SOURCE) ./noeh_test//boost_regex_noeh ../build//icu_options : : : BOOST_NO_EXCEPTIONS=1 off static shared : regex_regress_noeh ; From f9c3c8c461735b91bf62ff504a362ee01f504a57 Mon Sep 17 00:00:00 2001 From: Rene Rivera Date: Sun, 5 May 2024 09:00:01 -0500 Subject: [PATCH 09/26] Add requires-b2 check to top-level build file. --- build.jam | 2 ++ 1 file changed, 2 insertions(+) diff --git a/build.jam b/build.jam index 95327dfb..a7b13064 100644 --- a/build.jam +++ b/build.jam @@ -3,6 +3,8 @@ # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) +require-b2 5.1 ; + import project ; project /boost/regex From 028935b104fdbd3dd484fa925eab2c2992b0667a Mon Sep 17 00:00:00 2001 From: Rene Rivera Date: Fri, 14 Jun 2024 11:33:56 -0500 Subject: [PATCH 10/26] Bump B2 require to 5.2 --- build.jam | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/build.jam b/build.jam index a7b13064..abac0d82 100644 --- a/build.jam +++ b/build.jam @@ -3,9 +3,7 @@ # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) -require-b2 5.1 ; - -import project ; +require-b2 5.2 ; project /boost/regex : common-requirements From e5a7bbd399603e592a1802f8f8066eddbae30756 Mon Sep 17 00:00:00 2001 From: Rene Rivera Date: Sat, 20 Jul 2024 19:42:20 -0500 Subject: [PATCH 11/26] Change all references to . --- example/Jamfile.v2 | 2 +- test/Jamfile.v2 | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/example/Jamfile.v2 b/example/Jamfile.v2 index 6ccef7b6..7a7a7ed9 100644 --- a/example/Jamfile.v2 +++ b/example/Jamfile.v2 @@ -5,7 +5,7 @@ project : requirements - /boost/timer//boost_timer + /boost/timer//boost_timer multi shared:BOOST_REGEX_DYN_LINK=1 # There are unidentified linker problems on these platforms: diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 766dc484..3523022a 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -5,7 +5,7 @@ project : requirements - /boost/detail//boost_detail + /boost/detail//boost_detail multi shared:BOOST_REGEX_DYN_LINK=1 msvc-7.1:TEST_MFC=1 From fa2d2e1008f104ec2d167556a9a3e08f8ca6d785 Mon Sep 17 00:00:00 2001 From: Rene Rivera Date: Sat, 20 Jul 2024 22:52:03 -0500 Subject: [PATCH 12/26] Update copyright dates. --- build.jam | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.jam b/build.jam index abac0d82..8c83ccaf 100644 --- a/build.jam +++ b/build.jam @@ -1,4 +1,4 @@ -# Copyright René Ferdinand Rivera Morell 2023 +# Copyright René Ferdinand Rivera Morell 2023-2024 # 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) From fdacaf7d6de5d1425c581adcf83260d4ca00d669 Mon Sep 17 00:00:00 2001 From: Rene Rivera Date: Tue, 23 Jul 2024 22:34:22 -0500 Subject: [PATCH 13/26] Move inter-lib dependencies to a project variable and into the build targets. --- build.jam | 19 +++++++++++-------- build/Jamfile.v2 | 1 + 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/build.jam b/build.jam index 8c83ccaf..8e89f650 100644 --- a/build.jam +++ b/build.jam @@ -5,16 +5,18 @@ require-b2 5.2 ; +constant boost_dependencies : + /boost/assert//boost_assert + /boost/concept_check//boost_concept_check + /boost/config//boost_config + /boost/core//boost_core + /boost/predef//boost_predef + /boost/static_assert//boost_static_assert + /boost/throw_exception//boost_throw_exception + /boost/type_traits//boost_type_traits ; + project /boost/regex : common-requirements - /boost/assert//boost_assert - /boost/concept_check//boost_concept_check - /boost/config//boost_config - /boost/core//boost_core - /boost/predef//boost_predef - /boost/static_assert//boost_static_assert - /boost/throw_exception//boost_throw_exception - /boost/type_traits//boost_type_traits include ; @@ -26,3 +28,4 @@ explicit call-if : boost-library regex : install boost_regex ; + diff --git a/build/Jamfile.v2 b/build/Jamfile.v2 index c8ccd3a5..8062d55b 100644 --- a/build/Jamfile.v2 +++ b/build/Jamfile.v2 @@ -10,6 +10,7 @@ import errors ; project : requirements # default to all warnings on: all + : common-requirements $(boost_dependencies) ; local disable-icu = [ MATCH (--disable-icu) : [ modules.peek : ARGV ] ] ; From e3840cf3a6f3219b180f6b3a539d08f5347c629f Mon Sep 17 00:00:00 2001 From: Rene Rivera Date: Fri, 26 Jul 2024 17:43:46 -0500 Subject: [PATCH 14/26] Split b2 dependencies into public and private. --- build.jam | 1 - build/Jamfile.v2 | 5 +++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/build.jam b/build.jam index 8e89f650..b4223a58 100644 --- a/build.jam +++ b/build.jam @@ -9,7 +9,6 @@ constant boost_dependencies : /boost/assert//boost_assert /boost/concept_check//boost_concept_check /boost/config//boost_config - /boost/core//boost_core /boost/predef//boost_predef /boost/static_assert//boost_static_assert /boost/throw_exception//boost_throw_exception diff --git a/build/Jamfile.v2 b/build/Jamfile.v2 index 8062d55b..5304f3e8 100644 --- a/build/Jamfile.v2 +++ b/build/Jamfile.v2 @@ -7,10 +7,15 @@ import modules ; import testing ; import errors ; +constant boost_dependencies_private : + /boost/core//boost_core + ; + project : requirements # default to all warnings on: all : common-requirements $(boost_dependencies) + : requirements $(boost_dependencies_private) ; local disable-icu = [ MATCH (--disable-icu) : [ modules.peek : ARGV ] ] ; From cd92ca1ed0d3fceb2b2ca806b7b33d1c5f41231f Mon Sep 17 00:00:00 2001 From: Rene Rivera Date: Wed, 7 Aug 2024 23:46:57 -0500 Subject: [PATCH 15/26] Update build deps. --- example/Jamfile.v2 | 1 + test/Jamfile.v2 | 1 + 2 files changed, 2 insertions(+) diff --git a/example/Jamfile.v2 b/example/Jamfile.v2 index 7a7a7ed9..50f1ab99 100644 --- a/example/Jamfile.v2 +++ b/example/Jamfile.v2 @@ -5,6 +5,7 @@ project : requirements + /boost/regex//boost_regex /boost/timer//boost_timer multi shared:BOOST_REGEX_DYN_LINK=1 diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 3523022a..a2f6bba9 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -5,6 +5,7 @@ project : requirements + /boost/regex//boost_regex /boost/detail//boost_detail multi shared:BOOST_REGEX_DYN_LINK=1 From 1144c1dad8d036b65b6589fbd653b3d55b08687d Mon Sep 17 00:00:00 2001 From: Rene Rivera Date: Thu, 8 Aug 2024 21:54:58 -0500 Subject: [PATCH 16/26] Add VERBATIM to add_custom_target --- test/cmake_install_test/CMakeLists.txt | 2 +- test/cmake_subdir_test/CMakeLists.txt | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/test/cmake_install_test/CMakeLists.txt b/test/cmake_install_test/CMakeLists.txt index f0fde175..e5cce82b 100644 --- a/test/cmake_install_test/CMakeLists.txt +++ b/test/cmake_install_test/CMakeLists.txt @@ -15,4 +15,4 @@ target_link_libraries(quick Boost::regex Boost::core) enable_testing() add_test(quick quick) -add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $) +add_custom_target(check VERBATIM COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $) diff --git a/test/cmake_subdir_test/CMakeLists.txt b/test/cmake_subdir_test/CMakeLists.txt index 52f8d97d..a610309e 100644 --- a/test/cmake_subdir_test/CMakeLists.txt +++ b/test/cmake_subdir_test/CMakeLists.txt @@ -20,4 +20,4 @@ target_link_libraries(quick Boost::regex Boost::core) enable_testing() add_test(quick quick) -add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $) +add_custom_target(check VERBATIM COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $) From d4e7ac721c90cd77f6f6d653030145717caf7a5f Mon Sep 17 00:00:00 2001 From: Brian Weed Date: Wed, 14 Aug 2024 14:12:23 -0400 Subject: [PATCH 17/26] Performance improvement By-value sink params can be moved into their final destination --- include/boost/regex/v5/match_results.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/boost/regex/v5/match_results.hpp b/include/boost/regex/v5/match_results.hpp index 6b77ea57..eb54e0c3 100644 --- a/include/boost/regex/v5/match_results.hpp +++ b/include/boost/regex/v5/match_results.hpp @@ -553,7 +553,7 @@ public: void set_named_subs(std::shared_ptr subs) { - m_named_subs = subs; + m_named_subs = std::move(subs); } private: From d3697ab02385ccb97efde20ed8987cf06989df73 Mon Sep 17 00:00:00 2001 From: Braden Ganetsky Date: Thu, 22 Aug 2024 23:28:28 -0500 Subject: [PATCH 18/26] Fix deprecated-declarations error on clang-win --- src/wide_posix_api.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/wide_posix_api.cpp b/src/wide_posix_api.cpp index 993464f8..a6deacb6 100644 --- a/src/wide_posix_api.cpp +++ b/src/wide_posix_api.cpp @@ -169,7 +169,7 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int code, const regex_tW* { result = std::wcslen(wnames[code]) + 1; if(buf_size >= result) -#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE) +#if (BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE)) || (defined(BOOST_CLANG) && defined(_MSC_VER)) ::wcscpy_s(buf, buf_size, wnames[code]); #else std::wcscpy(buf, wnames[code]); From 65726f3d2ff4673b8a82c0193c93a2a7a6434b24 Mon Sep 17 00:00:00 2001 From: Peter Dimov Date: Mon, 2 Sep 2024 10:07:29 +0300 Subject: [PATCH 19/26] Define _CRT_SECURE_NO_WARNINGS instead of using wcscpy_s. Fixes #219. --- src/wide_posix_api.cpp | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-) diff --git a/src/wide_posix_api.cpp b/src/wide_posix_api.cpp index a6deacb6..6c01184b 100644 --- a/src/wide_posix_api.cpp +++ b/src/wide_posix_api.cpp @@ -16,6 +16,7 @@ * DESCRIPTION: Implements the wide character POSIX API wrappers. */ +#define _CRT_SECURE_NO_WARNINGS // for std::wcscpy #define BOOST_REGEX_SOURCE #include @@ -169,11 +170,7 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int code, const regex_tW* { result = std::wcslen(wnames[code]) + 1; if(buf_size >= result) -#if (BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE)) || (defined(BOOST_CLANG) && defined(_MSC_VER)) - ::wcscpy_s(buf, buf_size, wnames[code]); -#else std::wcscpy(buf, wnames[code]); -#endif return result; } return result; @@ -193,11 +190,7 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int code, const regex_tW* (boost::core::swprintf)(localbuf, 5, L"%d", i); #endif if(std::wcslen(localbuf) < buf_size) -#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE) - ::wcscpy_s(buf, buf_size, localbuf); -#else std::wcscpy(buf, localbuf); -#endif return std::wcslen(localbuf) + 1; } } @@ -207,11 +200,7 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int code, const regex_tW* (boost::core::swprintf)(localbuf, 5, L"%d", 0); #endif if(std::wcslen(localbuf) < buf_size) -#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE) - ::wcscpy_s(buf, buf_size, localbuf); -#else std::wcscpy(buf, localbuf); -#endif return std::wcslen(localbuf) + 1; } if(code <= (int)REG_E_UNKNOWN) From cff442b3e76f35f76d0bd96fb18e8a58ec7b33c1 Mon Sep 17 00:00:00 2001 From: Peter Dimov Date: Mon, 2 Sep 2024 10:23:02 +0300 Subject: [PATCH 20/26] Add VERBATIM to the remaining add_custom_target as well --- test/cmake_subdir_test_icu/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/cmake_subdir_test_icu/CMakeLists.txt b/test/cmake_subdir_test_icu/CMakeLists.txt index 62e4f0a6..db4dab25 100644 --- a/test/cmake_subdir_test_icu/CMakeLists.txt +++ b/test/cmake_subdir_test_icu/CMakeLists.txt @@ -19,4 +19,4 @@ target_link_libraries(quick_icu Boost::regex_icu) enable_testing() add_test(quick_icu quick_icu) -add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $) +add_custom_target(check VERBATIM COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $) From ccfc76570fde0b7704ade0f6d09d2cfd76cea5e6 Mon Sep 17 00:00:00 2001 From: Peter Dimov Date: Mon, 2 Sep 2024 11:05:00 +0300 Subject: [PATCH 21/26] Move all from requirements to default-build. Fixes #223. --- build/Jamfile.v2 | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/build/Jamfile.v2 b/build/Jamfile.v2 index 5304f3e8..c67a1b27 100644 --- a/build/Jamfile.v2 +++ b/build/Jamfile.v2 @@ -11,9 +11,8 @@ constant boost_dependencies_private : /boost/core//boost_core ; -project : requirements - # default to all warnings on: - all +project + : default-build all : common-requirements $(boost_dependencies) : requirements $(boost_dependencies_private) ; From bd0e76f42f7ae0db3ff671e7f1f7314b9f2a5027 Mon Sep 17 00:00:00 2001 From: jzmaddock Date: Sat, 2 Nov 2024 18:29:39 +0000 Subject: [PATCH 22/26] =?UTF-8?q?Correct=20example/Jamfile.v2=20so=20that?= =?UTF-8?q?=20grep=20gets=20valid=20command=20line=20argum=E2=80=A6=20(#22?= =?UTF-8?q?9)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Correct example/Jamfile.v2 so that grep gets valid command line arguments. --- example/Jamfile.v2 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/example/Jamfile.v2 b/example/Jamfile.v2 index 50f1ab99..6126b7d0 100644 --- a/example/Jamfile.v2 +++ b/example/Jamfile.v2 @@ -44,7 +44,7 @@ path-constant HERE : . ; test-suite regex-examples : [ regex-test-run timer/regex_timer.cpp /boost/smart_ptr//boost_smart_ptr : $(HERE)/timer/input_script.txt ] -[ regex-test-run grep/grep.cpp /boost/program_options//boost_program_options/static : -n -b $(HERE)/../include/boost/regex.hpp : test_grep ] +[ regex-test-run grep/grep.cpp /boost/program_options//boost_program_options/static : -n -b -E include $(HERE)/../include/boost/regex.hpp : test_grep ] [ regex-test-run snippets/credit_card_example.cpp ] [ regex-test-run snippets/mfc_example.cpp ] [ regex-test-run snippets/icu_example.cpp ] From 9a8d2b13a302bd57bc03319e2726ee81ccae1222 Mon Sep 17 00:00:00 2001 From: jzmaddock Date: Wed, 6 Nov 2024 09:20:07 +0000 Subject: [PATCH 23/26] Tentative fix for #227. (#230) Fixes #227. --- .../regex/v5/perl_matcher_non_recursive.hpp | 5 ++++- test/Jamfile.v2 | 1 + test/issue227.cpp | 19 +++++++++++++++++++ 3 files changed, 24 insertions(+), 1 deletion(-) create mode 100644 test/issue227.cpp diff --git a/include/boost/regex/v5/perl_matcher_non_recursive.hpp b/include/boost/regex/v5/perl_matcher_non_recursive.hpp index 28d6c462..92f6eb62 100644 --- a/include/boost/regex/v5/perl_matcher_non_recursive.hpp +++ b/include/boost/regex/v5/perl_matcher_non_recursive.hpp @@ -1204,7 +1204,10 @@ bool perl_matcher::skip_until_paren(int index, else if(pstate->type == syntax_element_startmark) { int idx = static_cast(pstate)->index; - pstate = pstate->next.p; + if(idx > 0) + match_startmark(); + else + pstate = pstate->next.p; skip_until_paren(idx, false); continue; } diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index a2f6bba9..1fd6cc3d 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -135,3 +135,4 @@ compile test_windows_defs_3.cpp ; compile test_windows_defs_4.cpp ; run issue153.cpp : : : "msvc:-STACK:2097152" ; +run issue227.cpp ; diff --git a/test/issue227.cpp b/test/issue227.cpp new file mode 100644 index 00000000..fce7fb52 --- /dev/null +++ b/test/issue227.cpp @@ -0,0 +1,19 @@ +/* +* Copyright (c) 2024 +* Christian Mazakas +* +* Use, modification and distribution are subject to 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) +* +*/ + +#include +#include + +int main() { + boost::regex rx("(*ACCEPT)*+\\1((*ACCEPT)*+\\K)"); + std::string str = "Z"; + boost::smatch what; + boost::regex_search(str, what, rx, boost::match_default | boost::match_partial); +} From f0afa5d9b870f2211a937c437357a5e75cb534d2 Mon Sep 17 00:00:00 2001 From: Christian Mazakas <5543573+cmazakas@users.noreply.github.com> Date: Sat, 23 Nov 2024 03:10:27 -0800 Subject: [PATCH 24/26] #include cleanup (#231) * update library headers to have self-contained #includes * update gha ci to run for feature/** branches --- .github/workflows/ci.yml | 1 + include/boost/regex/v5/basic_regex.hpp | 9 +++++++++ include/boost/regex/v5/basic_regex_creator.hpp | 3 +++ include/boost/regex/v5/basic_regex_parser.hpp | 7 +++++++ include/boost/regex/v5/c_regex_traits.hpp | 5 +++++ include/boost/regex/v5/char_regex_traits.hpp | 2 ++ include/boost/regex/v5/iterator_traits.hpp | 2 ++ include/boost/regex/v5/match_results.hpp | 8 ++++++++ include/boost/regex/v5/mem_block_cache.hpp | 3 +++ include/boost/regex/v5/perl_matcher.hpp | 11 +++++++++++ include/boost/regex/v5/perl_matcher_common.hpp | 16 ++++++++++++++++ .../regex/v5/perl_matcher_non_recursive.hpp | 12 ++++++++++++ include/boost/regex/v5/regex_format.hpp | 4 ++++ include/boost/regex/v5/regex_grep.hpp | 4 ++++ include/boost/regex/v5/regex_iterator.hpp | 3 +++ include/boost/regex/v5/regex_match.hpp | 3 +++ include/boost/regex/v5/regex_raw_buffer.hpp | 1 + include/boost/regex/v5/regex_replace.hpp | 4 ++++ include/boost/regex/v5/regex_search.hpp | 3 +++ include/boost/regex/v5/regex_split.hpp | 3 +++ include/boost/regex/v5/regex_token_iterator.hpp | 4 ++++ include/boost/regex/v5/states.hpp | 5 +++++ include/boost/regex/v5/sub_match.hpp | 3 +++ include/boost/regex/v5/u32regex_iterator.hpp | 15 +++++++++++++++ .../boost/regex/v5/u32regex_token_iterator.hpp | 12 ++++++++++++ 25 files changed, 143 insertions(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 5222c87d..61dbb63e 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -9,6 +9,7 @@ on: branches: - master - develop + - feature/** pull_request: release: types: [published, created, edited] diff --git a/include/boost/regex/v5/basic_regex.hpp b/include/boost/regex/v5/basic_regex.hpp index c09151ff..b611a528 100644 --- a/include/boost/regex/v5/basic_regex.hpp +++ b/include/boost/regex/v5/basic_regex.hpp @@ -19,6 +19,15 @@ #ifndef BOOST_REGEX_V5_BASIC_REGEX_HPP #define BOOST_REGEX_V5_BASIC_REGEX_HPP +#include +#include +#include +#include +#include + +#include +#include +#include #include namespace boost{ diff --git a/include/boost/regex/v5/basic_regex_creator.hpp b/include/boost/regex/v5/basic_regex_creator.hpp index 6e49ffe9..7e4ffcac 100644 --- a/include/boost/regex/v5/basic_regex_creator.hpp +++ b/include/boost/regex/v5/basic_regex_creator.hpp @@ -28,6 +28,9 @@ #endif #endif +#include + +#include #include namespace boost{ diff --git a/include/boost/regex/v5/basic_regex_parser.hpp b/include/boost/regex/v5/basic_regex_parser.hpp index 34d775ef..16e78849 100644 --- a/include/boost/regex/v5/basic_regex_parser.hpp +++ b/include/boost/regex/v5/basic_regex_parser.hpp @@ -19,6 +19,13 @@ #ifndef BOOST_REGEX_V5_BASIC_REGEX_PARSER_HPP #define BOOST_REGEX_V5_BASIC_REGEX_PARSER_HPP +#include + +#include +#include +#include +#include + namespace boost{ namespace BOOST_REGEX_DETAIL_NS{ diff --git a/include/boost/regex/v5/c_regex_traits.hpp b/include/boost/regex/v5/c_regex_traits.hpp index 9de34632..c22ce35c 100644 --- a/include/boost/regex/v5/c_regex_traits.hpp +++ b/include/boost/regex/v5/c_regex_traits.hpp @@ -21,7 +21,12 @@ #include #include +#include +#include + #include +#include +#include namespace boost{ diff --git a/include/boost/regex/v5/char_regex_traits.hpp b/include/boost/regex/v5/char_regex_traits.hpp index aeed86f8..41fe420b 100644 --- a/include/boost/regex/v5/char_regex_traits.hpp +++ b/include/boost/regex/v5/char_regex_traits.hpp @@ -20,6 +20,8 @@ #ifndef BOOST_REGEX_V5_CHAR_REGEX_TRAITS_HPP #define BOOST_REGEX_V5_CHAR_REGEX_TRAITS_HPP +#include + namespace boost{ namespace deprecated{ diff --git a/include/boost/regex/v5/iterator_traits.hpp b/include/boost/regex/v5/iterator_traits.hpp index 293db6bf..b2537565 100644 --- a/include/boost/regex/v5/iterator_traits.hpp +++ b/include/boost/regex/v5/iterator_traits.hpp @@ -19,6 +19,8 @@ #ifndef BOOST_REGEX_V5_ITERATOR_TRAITS_HPP #define BOOST_REGEX_V5_ITERATOR_TRAITS_HPP +#include + namespace boost{ namespace BOOST_REGEX_DETAIL_NS{ diff --git a/include/boost/regex/v5/match_results.hpp b/include/boost/regex/v5/match_results.hpp index eb54e0c3..78fbeb33 100644 --- a/include/boost/regex/v5/match_results.hpp +++ b/include/boost/regex/v5/match_results.hpp @@ -19,6 +19,14 @@ #ifndef BOOST_REGEX_V5_MATCH_RESULTS_HPP #define BOOST_REGEX_V5_MATCH_RESULTS_HPP +#include +#include +#include +#include + +#include +#include + namespace boost{ #ifdef BOOST_REGEX_MSVC #pragma warning(push) diff --git a/include/boost/regex/v5/mem_block_cache.hpp b/include/boost/regex/v5/mem_block_cache.hpp index 3e1216d0..d42e4a32 100644 --- a/include/boost/regex/v5/mem_block_cache.hpp +++ b/include/boost/regex/v5/mem_block_cache.hpp @@ -18,6 +18,8 @@ #ifndef BOOST_REGEX_V5_MEM_BLOCK_CACHE_HPP #define BOOST_REGEX_V5_MEM_BLOCK_CACHE_HPP +#include + #include #ifdef BOOST_HAS_THREADS #include @@ -31,6 +33,7 @@ #endif #endif + namespace boost{ namespace BOOST_REGEX_DETAIL_NS{ diff --git a/include/boost/regex/v5/perl_matcher.hpp b/include/boost/regex/v5/perl_matcher.hpp index deeffa58..e4817108 100644 --- a/include/boost/regex/v5/perl_matcher.hpp +++ b/include/boost/regex/v5/perl_matcher.hpp @@ -12,7 +12,18 @@ #ifndef BOOST_REGEX_MATCHER_HPP #define BOOST_REGEX_MATCHER_HPP +#include +#include +#include #include +#include +#include + +#ifndef BOOST_REGEX_STANDALONE +#include +#endif + +#include #ifdef BOOST_REGEX_MSVC # pragma warning(push) diff --git a/include/boost/regex/v5/perl_matcher_common.hpp b/include/boost/regex/v5/perl_matcher_common.hpp index dcce9e6a..4e9119e3 100644 --- a/include/boost/regex/v5/perl_matcher_common.hpp +++ b/include/boost/regex/v5/perl_matcher_common.hpp @@ -20,6 +20,22 @@ #ifndef BOOST_REGEX_V5_PERL_MATCHER_COMMON_HPP #define BOOST_REGEX_V5_PERL_MATCHER_COMMON_HPP +#include + +#ifndef BOOST_REGEX_STANDALONE + +#include +#if defined(BOOST_HAS_PRAGMA_ONCE) +#pragma once +#include +#endif + +#endif + +#include +#include +#include + #ifdef BOOST_REGEX_MSVC # pragma warning(push) #pragma warning(disable:4459) diff --git a/include/boost/regex/v5/perl_matcher_non_recursive.hpp b/include/boost/regex/v5/perl_matcher_non_recursive.hpp index 92f6eb62..87400452 100644 --- a/include/boost/regex/v5/perl_matcher_non_recursive.hpp +++ b/include/boost/regex/v5/perl_matcher_non_recursive.hpp @@ -20,6 +20,18 @@ #ifndef BOOST_REGEX_V5_PERL_MATCHER_NON_RECURSIVE_HPP #define BOOST_REGEX_V5_PERL_MATCHER_NON_RECURSIVE_HPP +#include + +#ifndef BOOST_REGEX_STANDALONE + +#include +#if defined(BOOST_HAS_PRAGMA_ONCE) +#pragma once +#include +#endif + +#endif + #include #ifdef BOOST_REGEX_MSVC diff --git a/include/boost/regex/v5/regex_format.hpp b/include/boost/regex/v5/regex_format.hpp index 9741296d..31bbfee4 100644 --- a/include/boost/regex/v5/regex_format.hpp +++ b/include/boost/regex/v5/regex_format.hpp @@ -21,6 +21,10 @@ #ifndef BOOST_REGEX_FORMAT_HPP #define BOOST_REGEX_FORMAT_HPP +#include +#include +#include + #include #include diff --git a/include/boost/regex/v5/regex_grep.hpp b/include/boost/regex/v5/regex_grep.hpp index 6cd625d6..63f750d5 100644 --- a/include/boost/regex/v5/regex_grep.hpp +++ b/include/boost/regex/v5/regex_grep.hpp @@ -19,6 +19,10 @@ #ifndef BOOST_REGEX_V5_REGEX_GREP_HPP #define BOOST_REGEX_V5_REGEX_GREP_HPP +#include +#include +#include +#include namespace boost{ diff --git a/include/boost/regex/v5/regex_iterator.hpp b/include/boost/regex/v5/regex_iterator.hpp index b2e9d2ce..17a20ac3 100644 --- a/include/boost/regex/v5/regex_iterator.hpp +++ b/include/boost/regex/v5/regex_iterator.hpp @@ -19,6 +19,9 @@ #ifndef BOOST_REGEX_V5_REGEX_ITERATOR_HPP #define BOOST_REGEX_V5_REGEX_ITERATOR_HPP +#include +#include + #include namespace boost{ diff --git a/include/boost/regex/v5/regex_match.hpp b/include/boost/regex/v5/regex_match.hpp index 21753576..c2f81814 100644 --- a/include/boost/regex/v5/regex_match.hpp +++ b/include/boost/regex/v5/regex_match.hpp @@ -22,6 +22,9 @@ #ifndef BOOST_REGEX_MATCH_HPP #define BOOST_REGEX_MATCH_HPP +#include +#include + namespace boost{ // diff --git a/include/boost/regex/v5/regex_raw_buffer.hpp b/include/boost/regex/v5/regex_raw_buffer.hpp index 443c57a2..732955a2 100644 --- a/include/boost/regex/v5/regex_raw_buffer.hpp +++ b/include/boost/regex/v5/regex_raw_buffer.hpp @@ -27,6 +27,7 @@ #include #include +#include namespace boost{ namespace BOOST_REGEX_DETAIL_NS{ diff --git a/include/boost/regex/v5/regex_replace.hpp b/include/boost/regex/v5/regex_replace.hpp index 75f8894f..6cdaee82 100644 --- a/include/boost/regex/v5/regex_replace.hpp +++ b/include/boost/regex/v5/regex_replace.hpp @@ -22,6 +22,10 @@ #define BOOST_REGEX_V5_REGEX_REPLACE_HPP +#include +#include +#include + namespace boost{ template diff --git a/include/boost/regex/v5/regex_search.hpp b/include/boost/regex/v5/regex_search.hpp index d0addb19..8eac23cf 100644 --- a/include/boost/regex/v5/regex_search.hpp +++ b/include/boost/regex/v5/regex_search.hpp @@ -20,6 +20,9 @@ #define BOOST_REGEX_V5_REGEX_SEARCH_HPP +#include +#include + namespace boost{ template diff --git a/include/boost/regex/v5/regex_split.hpp b/include/boost/regex/v5/regex_split.hpp index 8d932896..80e30210 100644 --- a/include/boost/regex/v5/regex_split.hpp +++ b/include/boost/regex/v5/regex_split.hpp @@ -21,6 +21,9 @@ #ifndef BOOST_REGEX_SPLIT_HPP #define BOOST_REGEX_SPLIT_HPP +#include +#include + namespace boost{ #ifdef BOOST_REGEX_MSVC diff --git a/include/boost/regex/v5/regex_token_iterator.hpp b/include/boost/regex/v5/regex_token_iterator.hpp index 16832746..4fbf5246 100644 --- a/include/boost/regex/v5/regex_token_iterator.hpp +++ b/include/boost/regex/v5/regex_token_iterator.hpp @@ -19,6 +19,10 @@ #ifndef BOOST_REGEX_V5_REGEX_TOKEN_ITERATOR_HPP #define BOOST_REGEX_V5_REGEX_TOKEN_ITERATOR_HPP +#include +#include +#include + #include namespace boost{ diff --git a/include/boost/regex/v5/states.hpp b/include/boost/regex/v5/states.hpp index 60fc99d0..942f0c3a 100644 --- a/include/boost/regex/v5/states.hpp +++ b/include/boost/regex/v5/states.hpp @@ -19,6 +19,11 @@ #ifndef BOOST_REGEX_V5_STATES_HPP #define BOOST_REGEX_V5_STATES_HPP +#include + +#include +#include + namespace boost{ namespace BOOST_REGEX_DETAIL_NS{ diff --git a/include/boost/regex/v5/sub_match.hpp b/include/boost/regex/v5/sub_match.hpp index aa61b560..630070dc 100644 --- a/include/boost/regex/v5/sub_match.hpp +++ b/include/boost/regex/v5/sub_match.hpp @@ -19,6 +19,9 @@ #ifndef BOOST_REGEX_V5_SUB_MATCH_HPP #define BOOST_REGEX_V5_SUB_MATCH_HPP +#include +#include + namespace boost{ template diff --git a/include/boost/regex/v5/u32regex_iterator.hpp b/include/boost/regex/v5/u32regex_iterator.hpp index 608cd176..b7ac61a1 100644 --- a/include/boost/regex/v5/u32regex_iterator.hpp +++ b/include/boost/regex/v5/u32regex_iterator.hpp @@ -19,6 +19,21 @@ #ifndef BOOST_REGEX_V5_U32REGEX_ITERATOR_HPP #define BOOST_REGEX_V5_U32REGEX_ITERATOR_HPP +#include + +#ifndef BOOST_REGEX_STANDALONE + +#include +#if defined(BOOST_HAS_PRAGMA_ONCE) +#pragma once +#include +#endif + +#endif + +#include +#include + namespace boost{ template diff --git a/include/boost/regex/v5/u32regex_token_iterator.hpp b/include/boost/regex/v5/u32regex_token_iterator.hpp index 3d303265..ea30de7c 100644 --- a/include/boost/regex/v5/u32regex_token_iterator.hpp +++ b/include/boost/regex/v5/u32regex_token_iterator.hpp @@ -19,6 +19,18 @@ #ifndef BOOST_REGEX_V5_U32REGEX_TOKEN_ITERATOR_HPP #define BOOST_REGEX_V5_U32REGEX_TOKEN_ITERATOR_HPP +#include + +#ifndef BOOST_REGEX_STANDALONE + +#include +#if defined(BOOST_HAS_PRAGMA_ONCE) +#pragma once +#include +#endif + +#endif + namespace boost{ #ifdef BOOST_REGEX_MSVC From 0cbaa4ef1740c88106337cf0ba5bf5c73b62863c Mon Sep 17 00:00:00 2001 From: Christian Mazakas <5543573+cmazakas@users.noreply.github.com> Date: Thu, 5 Dec 2024 05:08:52 -0800 Subject: [PATCH 25/26] fix #232 (#234) * add failing test case * fix issue #232 Credit to OSS-Fuzz for finding the problematic test regexes and configurations. --- include/boost/regex/v5/perl_matcher.hpp | 25 ++++--- .../boost/regex/v5/perl_matcher_common.hpp | 11 ++- test/Jamfile.v2 | 1 + test/issue232.cpp | 71 +++++++++++++++++++ 4 files changed, 94 insertions(+), 14 deletions(-) create mode 100644 test/issue232.cpp diff --git a/include/boost/regex/v5/perl_matcher.hpp b/include/boost/regex/v5/perl_matcher.hpp index e4817108..207daedd 100644 --- a/include/boost/regex/v5/perl_matcher.hpp +++ b/include/boost/regex/v5/perl_matcher.hpp @@ -39,25 +39,34 @@ #endif #endif +#ifndef BOOST_REGEX_STANDALONE +# define BOOST_REGEX_DETAIL_THROW(ex) boost::throw_exception(ex) +#else +# define BOOST_REGEX_DETAIL_THROW(ex) throw ex +#endif + namespace boost{ namespace BOOST_REGEX_DETAIL_NS{ // // error checking API: // -inline void verify_options(boost::regex_constants::syntax_option_type, match_flag_type mf) +inline void verify_options(boost::regex_constants::syntax_option_type, match_flag_type mf) { + auto is_perl = (mf & match_perl); + auto is_posix = (mf & match_posix); + + if (is_perl && is_posix) + { + BOOST_REGEX_DETAIL_THROW(std::logic_error("Usage Error: Can't mix Perl and POSIX matching rules")); + } + // // can't mix match_extra with POSIX matching rules: // - if ((mf & match_extra) && (mf & match_posix)) + if ((mf & match_extra) && is_posix) { - std::logic_error msg("Usage Error: Can't mix regular expression captures with POSIX matching rules"); -#ifndef BOOST_REGEX_STANDALONE - throw_exception(msg); -#else - throw msg; -#endif + BOOST_REGEX_DETAIL_THROW(std::logic_error("Usage Error: Can't mix regular expression captures with POSIX matching rules")); } } // diff --git a/include/boost/regex/v5/perl_matcher_common.hpp b/include/boost/regex/v5/perl_matcher_common.hpp index 4e9119e3..ff3a69e8 100644 --- a/include/boost/regex/v5/perl_matcher_common.hpp +++ b/include/boost/regex/v5/perl_matcher_common.hpp @@ -60,12 +60,7 @@ void perl_matcher::construct_init(const basic_r if(e.empty()) { // precondition failure: e is not a valid regex. - std::invalid_argument ex("Invalid regular expression object"); -#ifndef BOOST_REGEX_STANDALONE - boost::throw_exception(ex); -#else - throw e; -#endif + BOOST_REGEX_DETAIL_THROW(std::invalid_argument("Invalid regular expression object")); } pstate = 0; m_match_flags = f; @@ -98,7 +93,11 @@ void perl_matcher::construct_init(const basic_r match_any_mask = static_cast((f & match_not_dot_newline) ? BOOST_REGEX_DETAIL_NS::test_not_newline : BOOST_REGEX_DETAIL_NS::test_newline); // Disable match_any if requested in the state machine: if(e.get_data().m_disable_match_any) + { + if (m_match_flags & match_posix) + BOOST_REGEX_DETAIL_THROW(std::logic_error("Invalid regex for POSIX-style matching")); m_match_flags &= regex_constants::match_not_any; + } } #ifdef BOOST_REGEX_MSVC # pragma warning(pop) diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 1fd6cc3d..9140e2db 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -136,3 +136,4 @@ compile test_windows_defs_4.cpp ; run issue153.cpp : : : "msvc:-STACK:2097152" ; run issue227.cpp ; +run issue232.cpp ; diff --git a/test/issue232.cpp b/test/issue232.cpp new file mode 100644 index 00000000..a8c2b2cc --- /dev/null +++ b/test/issue232.cpp @@ -0,0 +1,71 @@ +#include + +#include +#include +#include + +template +void tester( char const (&str)[ N0 ] ) +{ + std::vector s(N, '\0'); + std::memcpy(s.data(), str, N); + boost::regex rx(s.begin(), s.end()); + + std::vector wheres; + wheres.push_back(std::string(15, 'H')); + wheres.push_back(""); + wheres.push_back(" "); + + // Perl-style matching + for (auto const& where : wheres) { + boost::match_results what; + bool match = boost::regex_match(where, what, rx, boost::match_default | boost::match_partial | boost::match_any | boost::match_perl); + (void) match; + } + + // POSIX-style matching + for (auto const& where : wheres) { + try { + boost::match_results what; + bool match = boost::regex_match(where, what, rx, boost::match_default | boost::match_partial | boost::match_any | boost::match_posix); + (void) match; + } catch(...) {} + } + +} + +int main() +{ + // test strings derived from fuzzing + // we keep a simple human-readable version + char const str1[] = "(Y(*COMMIT)|\\K\\D|.)+"; + char const str2[] = "(Y(*COMMIT){||\\K\\D|||||||||\\K|||ss|||||.|\232*(?(50)\027\0204657|H)\020}\031\000.* 6.'?-i)+[L??.\000\000\000\004\000\000\000\000?..<[\000\024R]*+"; + char const str3[] = "(Y(*COMMIT)\xFF\x80|\\L\\K||||||||||.|||||\x84|||||\x00\x00\x10||||||.* .'?-i)[L??...-i)[L??...[\x00\x14R]*+"; + char const str4[] = "(Y(*COMMIT)\x96||.* .* .\\K|||\x9F||||\x9C|.|||||\x84\x99|||\x01\x00\x00\x00|||'?-i#PL\x00\x01.\x86??OMMIT)?...[\x00\x14R]*+"; + + tester(str1); + tester(str2); + tester(str3); + tester(str4); + + // prove that we catch certain impossible scenarios + + { + char const* str = "abcd"; + boost::regex rx(str); + boost::match_results what; + std::string where(15, 'H'); + BOOST_TEST_THROWS(boost::regex_match(where, rx, boost::match_posix | boost::match_perl), std::logic_error); + } + + { + char const* str = "ab(*COMMIT)cd"; + boost::regex rx(str); + boost::match_results what; + std::string where(15, 'H'); + BOOST_TEST_THROWS(boost::regex_match(where, rx, boost::match_posix), std::logic_error); + } + + return boost::report_errors(); +} + From 57ca08240ee11e0b9416a1f22793cf3b72154b2c Mon Sep 17 00:00:00 2001 From: jzmaddock Date: Mon, 16 Dec 2024 16:58:25 +0000 Subject: [PATCH 26/26] Make backstep calculation non-recursive. Refs https://github.com/boostorg/regex/pull/236. --- .../boost/regex/v5/basic_regex_creator.hpp | 38 ++++++++++++++++--- test/Jamfile.v2 | 2 + test/lookbehind_recursion_stress_test.cpp | 28 ++++++++++++++ 3 files changed, 62 insertions(+), 6 deletions(-) create mode 100644 test/lookbehind_recursion_stress_test.cpp diff --git a/include/boost/regex/v5/basic_regex_creator.hpp b/include/boost/regex/v5/basic_regex_creator.hpp index 7e4ffcac..d9ae7807 100644 --- a/include/boost/regex/v5/basic_regex_creator.hpp +++ b/include/boost/regex/v5/basic_regex_creator.hpp @@ -974,7 +974,12 @@ template int basic_regex_creator::calculate_backstep(re_syntax_base* state) { typedef typename traits::char_class_type m_type; + int result = 0; + int last_alternative_result = -1; + + std::vector> stack; + while(state) { switch(state->type) @@ -993,9 +998,28 @@ int basic_regex_creator::calculate_backstep(re_syntax_base* state } break; case syntax_element_endmark: - if((static_cast(state)->index == -1) + if ((static_cast(state)->index == -1) || (static_cast(state)->index == -2)) - return result; + { + // We've finished the calculation, check against any previous alternatives: + if (last_alternative_result >= 0) + { + if (last_alternative_result != result) + return -1; + } + else + last_alternative_result = result; + + if (stack.size()) + { + // Skip to next alternative and calculate that as well: + std::tie(result, state) = stack.back(); + stack.pop_back(); + continue; + } + else + return result; + } break; case syntax_element_literal: result += static_cast(state)->length; @@ -1051,11 +1075,13 @@ int basic_regex_creator::calculate_backstep(re_syntax_base* state continue; case syntax_element_alt: { - int r1 = calculate_backstep(state->next.p); - int r2 = calculate_backstep(static_cast(state)->alt.p); - if((r1 < 0) || (r1 != r2)) + // Push the alternative if we haven't pushed too many already: + if(stack.size() > BOOST_REGEX_MAX_BLOCKS) return -1; - return result + r1; + stack.push_back(std::make_tuple(result, static_cast(state)->alt.p)); + // and take the first one: + state = state->next.p; + continue; } default: break; diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 9140e2db..19f675fe 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -137,3 +137,5 @@ compile test_windows_defs_4.cpp ; run issue153.cpp : : : "msvc:-STACK:2097152" ; run issue227.cpp ; run issue232.cpp ; +run lookbehind_recursion_stress_test.cpp ; + diff --git a/test/lookbehind_recursion_stress_test.cpp b/test/lookbehind_recursion_stress_test.cpp new file mode 100644 index 00000000..feb5a449 --- /dev/null +++ b/test/lookbehind_recursion_stress_test.cpp @@ -0,0 +1,28 @@ +/* + * + * Copyright (c) 2024 + * John Maddock + * + * Use, modification and distribution are subject to 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) + * + */ + +#include + +int main() +{ + std::string s("(?<=("); + s.append(1000, '|'); + s += "))"; + boost::regex rx(s); + + s = "(?<=(a"; + for (unsigned i = 0; i < 1000; ++i) + { + s += "|a"; + } + s += "))"; + boost::regex rx2(s); +}