1 // Boost config.hpp configuration header file ------------------------------// 2 // boostinspect:ndprecated_macros -- tell the inspect tool to ignore this file 3 4 // Copyright (c) 2001-2003 John Maddock 5 // Copyright (c) 2001 Darin Adler 6 // Copyright (c) 2001 Peter Dimov 7 // Copyright (c) 2002 Bill Kempf 8 // Copyright (c) 2002 Jens Maurer 9 // Copyright (c) 2002-2003 David Abrahams 10 // Copyright (c) 2003 Gennaro Prota 11 // Copyright (c) 2003 Eric Friedman 12 // Copyright (c) 2010 Eric Jourdanneau, Joel Falcou 13 // Distributed under the Boost Software License, Version 1.0. (See 14 // accompanying file LICENSE_1_0.txt or copy at 15 // http://www.boost.org/LICENSE_1_0.txt) 16 17 // See http://www.boost.org/ for most recent version. 18 19 // Boost config.hpp policy and rationale documentation has been moved to 20 // http://www.boost.org/libs/config/ 21 // 22 // This file is intended to be stable, and relatively unchanging. 23 // It should contain boilerplate code only - no compiler specific 24 // code unless it is unavoidable - no changes unless unavoidable. 25 26 #ifndef BOOST_CONFIG_SUFFIX_HPP 27 #define BOOST_CONFIG_SUFFIX_HPP 28 29 #if defined(__GNUC__) && (__GNUC__ >= 4) 30 // 31 // Some GCC-4.x versions issue warnings even when __extension__ is used, 32 // so use this as a workaround: 33 // 34 #pragma GCC system_header 35 #endif 36 37 // 38 // ensure that visibility macros are always defined, thus simplifying use 39 // 40 #ifndef BOOST_SYMBOL_EXPORT 41 # define BOOST_SYMBOL_EXPORT 42 #endif 43 #ifndef BOOST_SYMBOL_IMPORT 44 # define BOOST_SYMBOL_IMPORT 45 #endif 46 #ifndef BOOST_SYMBOL_VISIBLE 47 # define BOOST_SYMBOL_VISIBLE 48 #endif 49 50 // 51 // look for long long by looking for the appropriate macros in <limits.h>. 52 // Note that we use limits.h rather than climits for maximal portability, 53 // remember that since these just declare a bunch of macros, there should be 54 // no namespace issues from this. 55 // 56 #if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG) \ 57 && !defined(BOOST_MSVC) && !defined(BOOST_BORLANDC) 58 # include <limits.h> 59 # if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX)) 60 # define BOOST_HAS_LONG_LONG 61 # else 62 # define BOOST_NO_LONG_LONG 63 # endif 64 #endif 65 66 // GCC 3.x will clean up all of those nasty macro definitions that 67 // BOOST_NO_CTYPE_FUNCTIONS is intended to help work around, so undefine 68 // it under GCC 3.x. 69 #if defined(__GNUC__) && (__GNUC__ >= 3) && defined(BOOST_NO_CTYPE_FUNCTIONS) 70 # undef BOOST_NO_CTYPE_FUNCTIONS 71 #endif 72 73 // 74 // Assume any extensions are in namespace std:: unless stated otherwise: 75 // 76 # ifndef BOOST_STD_EXTENSION_NAMESPACE 77 # define BOOST_STD_EXTENSION_NAMESPACE std 78 # endif 79 80 // 81 // If cv-qualified specializations are not allowed, then neither are cv-void ones: 82 // 83 # if defined(BOOST_NO_CV_SPECIALIZATIONS) \ 84 && !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS) 85 # define BOOST_NO_CV_VOID_SPECIALIZATIONS 86 # endif 87 88 // 89 // If there is no numeric_limits template, then it can't have any compile time 90 // constants either! 91 // 92 # if defined(BOOST_NO_LIMITS) \ 93 && !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) 94 # define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS 95 # define BOOST_NO_MS_INT64_NUMERIC_LIMITS 96 # define BOOST_NO_LONG_LONG_NUMERIC_LIMITS 97 # endif 98 99 // 100 // if there is no long long then there is no specialisation 101 // for numeric_limits<long long> either: 102 // 103 #if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS) 104 # define BOOST_NO_LONG_LONG_NUMERIC_LIMITS 105 #endif 106 107 // 108 // if there is no __int64 then there is no specialisation 109 // for numeric_limits<__int64> either: 110 // 111 #if !defined(BOOST_HAS_MS_INT64) && !defined(BOOST_NO_MS_INT64_NUMERIC_LIMITS) 112 # define BOOST_NO_MS_INT64_NUMERIC_LIMITS 113 #endif 114 115 // 116 // if member templates are supported then so is the 117 // VC6 subset of member templates: 118 // 119 # if !defined(BOOST_NO_MEMBER_TEMPLATES) \ 120 && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) 121 # define BOOST_MSVC6_MEMBER_TEMPLATES 122 # endif 123 124 // 125 // Without partial specialization, can't test for partial specialisation bugs: 126 // 127 # if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ 128 && !defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) 129 # define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG 130 # endif 131 132 // 133 // Without partial specialization, we can't have array-type partial specialisations: 134 // 135 # if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ 136 && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) 137 # define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS 138 # endif 139 140 // 141 // Without partial specialization, std::iterator_traits can't work: 142 // 143 # if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ 144 && !defined(BOOST_NO_STD_ITERATOR_TRAITS) 145 # define BOOST_NO_STD_ITERATOR_TRAITS 146 # endif 147 148 // 149 // Without partial specialization, partial 150 // specialization with default args won't work either: 151 // 152 # if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ 153 && !defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS) 154 # define BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS 155 # endif 156 157 // 158 // Without member template support, we can't have template constructors 159 // in the standard library either: 160 // 161 # if defined(BOOST_NO_MEMBER_TEMPLATES) \ 162 && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \ 163 && !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) 164 # define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS 165 # endif 166 167 // 168 // Without member template support, we can't have a conforming 169 // std::allocator template either: 170 // 171 # if defined(BOOST_NO_MEMBER_TEMPLATES) \ 172 && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \ 173 && !defined(BOOST_NO_STD_ALLOCATOR) 174 # define BOOST_NO_STD_ALLOCATOR 175 # endif 176 177 // 178 // without ADL support then using declarations will break ADL as well: 179 // 180 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL) 181 # define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL 182 #endif 183 184 // 185 // Without typeid support we have no dynamic RTTI either: 186 // 187 #if defined(BOOST_NO_TYPEID) && !defined(BOOST_NO_RTTI) 188 # define BOOST_NO_RTTI 189 #endif 190 191 // 192 // If we have a standard allocator, then we have a partial one as well: 193 // 194 #if !defined(BOOST_NO_STD_ALLOCATOR) 195 # define BOOST_HAS_PARTIAL_STD_ALLOCATOR 196 #endif 197 198 // 199 // We can't have a working std::use_facet if there is no std::locale: 200 // 201 # if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_USE_FACET) 202 # define BOOST_NO_STD_USE_FACET 203 # endif 204 205 // 206 // We can't have a std::messages facet if there is no std::locale: 207 // 208 # if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_MESSAGES) 209 # define BOOST_NO_STD_MESSAGES 210 # endif 211 212 // 213 // We can't have a working std::wstreambuf if there is no std::locale: 214 // 215 # if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_WSTREAMBUF) 216 # define BOOST_NO_STD_WSTREAMBUF 217 # endif 218 219 // 220 // We can't have a <cwctype> if there is no <cwchar>: 221 // 222 # if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_CWCTYPE) 223 # define BOOST_NO_CWCTYPE 224 # endif 225 226 // 227 // We can't have a swprintf if there is no <cwchar>: 228 // 229 # if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_SWPRINTF) 230 # define BOOST_NO_SWPRINTF 231 # endif 232 233 // 234 // If Win32 support is turned off, then we must turn off 235 // threading support also, unless there is some other 236 // thread API enabled: 237 // 238 #if defined(BOOST_DISABLE_WIN32) && defined(_WIN32) \ 239 && !defined(BOOST_DISABLE_THREADS) && !defined(BOOST_HAS_PTHREADS) 240 # define BOOST_DISABLE_THREADS 241 #endif 242 243 // 244 // Turn on threading support if the compiler thinks that it's in 245 // multithreaded mode. We put this here because there are only a 246 // limited number of macros that identify this (if there's any missing 247 // from here then add to the appropriate compiler section): 248 // 249 #if (defined(__MT__) || defined(_MT) || defined(_REENTRANT) \ 250 || defined(_PTHREADS) || defined(__APPLE__) || defined(__DragonFly__)) \ 251 && !defined(BOOST_HAS_THREADS) 252 # define BOOST_HAS_THREADS 253 #endif 254 255 // 256 // Turn threading support off if BOOST_DISABLE_THREADS is defined: 257 // 258 #if defined(BOOST_DISABLE_THREADS) && defined(BOOST_HAS_THREADS) 259 # undef BOOST_HAS_THREADS 260 #endif 261 262 // 263 // Turn threading support off if we don't recognise the threading API: 264 // 265 #if defined(BOOST_HAS_THREADS) && !defined(BOOST_HAS_PTHREADS)\ 266 && !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_BETHREADS)\ 267 && !defined(BOOST_HAS_MPTASKS) 268 # undef BOOST_HAS_THREADS 269 #endif 270 271 // 272 // Turn threading detail macros off if we don't (want to) use threading 273 // 274 #ifndef BOOST_HAS_THREADS 275 # undef BOOST_HAS_PTHREADS 276 # undef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 277 # undef BOOST_HAS_PTHREAD_YIELD 278 # undef BOOST_HAS_PTHREAD_DELAY_NP 279 # undef BOOST_HAS_WINTHREADS 280 # undef BOOST_HAS_BETHREADS 281 # undef BOOST_HAS_MPTASKS 282 #endif 283 284 // 285 // If the compiler claims to be C99 conformant, then it had better 286 // have a <stdint.h>: 287 // 288 # if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901) 289 # define BOOST_HAS_STDINT_H 290 # ifndef BOOST_HAS_LOG1P 291 # define BOOST_HAS_LOG1P 292 # endif 293 # ifndef BOOST_HAS_EXPM1 294 # define BOOST_HAS_EXPM1 295 # endif 296 # endif 297 298 // 299 // Define BOOST_NO_SLIST and BOOST_NO_HASH if required. 300 // Note that this is for backwards compatibility only. 301 // 302 # if !defined(BOOST_HAS_SLIST) && !defined(BOOST_NO_SLIST) 303 # define BOOST_NO_SLIST 304 # endif 305 306 # if !defined(BOOST_HAS_HASH) && !defined(BOOST_NO_HASH) 307 # define BOOST_NO_HASH 308 # endif 309 310 // 311 // Set BOOST_SLIST_HEADER if not set already: 312 // 313 #if defined(BOOST_HAS_SLIST) && !defined(BOOST_SLIST_HEADER) 314 # define BOOST_SLIST_HEADER <slist> 315 #endif 316 317 // 318 // Set BOOST_HASH_SET_HEADER if not set already: 319 // 320 #if defined(BOOST_HAS_HASH) && !defined(BOOST_HASH_SET_HEADER) 321 # define BOOST_HASH_SET_HEADER <hash_set> 322 #endif 323 324 // 325 // Set BOOST_HASH_MAP_HEADER if not set already: 326 // 327 #if defined(BOOST_HAS_HASH) && !defined(BOOST_HASH_MAP_HEADER) 328 # define BOOST_HASH_MAP_HEADER <hash_map> 329 #endif 330 331 // BOOST_HAS_ABI_HEADERS 332 // This macro gets set if we have headers that fix the ABI, 333 // and prevent ODR violations when linking to external libraries: 334 #if defined(BOOST_ABI_PREFIX) && defined(BOOST_ABI_SUFFIX) && !defined(BOOST_HAS_ABI_HEADERS) 335 # define BOOST_HAS_ABI_HEADERS 336 #endif 337 338 #if defined(BOOST_HAS_ABI_HEADERS) && defined(BOOST_DISABLE_ABI_HEADERS) 339 # undef BOOST_HAS_ABI_HEADERS 340 #endif 341 342 // BOOST_NO_STDC_NAMESPACE workaround --------------------------------------// 343 // Because std::size_t usage is so common, even in boost headers which do not 344 // otherwise use the C library, the <cstddef> workaround is included here so 345 // that ugly workaround code need not appear in many other boost headers. 346 // NOTE WELL: This is a workaround for non-conforming compilers; <cstddef> 347 // must still be #included in the usual places so that <cstddef> inclusion 348 // works as expected with standard conforming compilers. The resulting 349 // double inclusion of <cstddef> is harmless. 350 351 # if defined(BOOST_NO_STDC_NAMESPACE) && defined(__cplusplus) 352 # include <cstddef> 353 namespace std { using ::ptrdiff_t; using ::size_t; } 354 # endif 355 356 // Workaround for the unfortunate min/max macros defined by some platform headers 357 358 #define BOOST_PREVENT_MACRO_SUBSTITUTION 359 360 #ifndef BOOST_USING_STD_MIN 361 # define BOOST_USING_STD_MIN() using std::min 362 #endif 363 364 #ifndef BOOST_USING_STD_MAX 365 # define BOOST_USING_STD_MAX() using std::max 366 #endif 367 368 // BOOST_NO_STD_MIN_MAX workaround -----------------------------------------// 369 370 # if defined(BOOST_NO_STD_MIN_MAX) && defined(__cplusplus) 371 372 namespace std { 373 template <class _Tp> BOOST_PREVENT_MACRO_SUBSTITUTION(const _Tp & __a,const _Tp & __b)374 inline const _Tp& min BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) { 375 return __b < __a ? __b : __a; 376 } 377 template <class _Tp> BOOST_PREVENT_MACRO_SUBSTITUTION(const _Tp & __a,const _Tp & __b)378 inline const _Tp& max BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) { 379 return __a < __b ? __b : __a; 380 } 381 } 382 383 # endif 384 385 // BOOST_STATIC_CONSTANT workaround --------------------------------------- // 386 // On compilers which don't allow in-class initialization of static integral 387 // constant members, we must use enums as a workaround if we want the constants 388 // to be available at compile-time. This macro gives us a convenient way to 389 // declare such constants. 390 391 # ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION 392 # define BOOST_STATIC_CONSTANT(type, assignment) enum { assignment } 393 # else 394 # define BOOST_STATIC_CONSTANT(type, assignment) static const type assignment 395 # endif 396 397 // BOOST_USE_FACET / HAS_FACET workaround ----------------------------------// 398 // When the standard library does not have a conforming std::use_facet there 399 // are various workarounds available, but they differ from library to library. 400 // The same problem occurs with has_facet. 401 // These macros provide a consistent way to access a locale's facets. 402 // Usage: 403 // replace 404 // std::use_facet<Type>(loc); 405 // with 406 // BOOST_USE_FACET(Type, loc); 407 // Note do not add a std:: prefix to the front of BOOST_USE_FACET! 408 // Use for BOOST_HAS_FACET is analogous. 409 410 #if defined(BOOST_NO_STD_USE_FACET) 411 # ifdef BOOST_HAS_TWO_ARG_USE_FACET 412 # define BOOST_USE_FACET(Type, loc) std::use_facet(loc, static_cast<Type*>(0)) 413 # define BOOST_HAS_FACET(Type, loc) std::has_facet(loc, static_cast<Type*>(0)) 414 # elif defined(BOOST_HAS_MACRO_USE_FACET) 415 # define BOOST_USE_FACET(Type, loc) std::_USE(loc, Type) 416 # define BOOST_HAS_FACET(Type, loc) std::_HAS(loc, Type) 417 # elif defined(BOOST_HAS_STLP_USE_FACET) 418 # define BOOST_USE_FACET(Type, loc) (*std::_Use_facet<Type >(loc)) 419 # define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc) 420 # endif 421 #else 422 # define BOOST_USE_FACET(Type, loc) std::use_facet< Type >(loc) 423 # define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc) 424 #endif 425 426 // BOOST_NESTED_TEMPLATE workaround ------------------------------------------// 427 // Member templates are supported by some compilers even though they can't use 428 // the A::template member<U> syntax, as a workaround replace: 429 // 430 // typedef typename A::template rebind<U> binder; 431 // 432 // with: 433 // 434 // typedef typename A::BOOST_NESTED_TEMPLATE rebind<U> binder; 435 436 #ifndef BOOST_NO_MEMBER_TEMPLATE_KEYWORD 437 # define BOOST_NESTED_TEMPLATE template 438 #else 439 # define BOOST_NESTED_TEMPLATE 440 #endif 441 442 // BOOST_UNREACHABLE_RETURN(x) workaround -------------------------------------// 443 // Normally evaluates to nothing, unless BOOST_NO_UNREACHABLE_RETURN_DETECTION 444 // is defined, in which case it evaluates to return x; Use when you have a return 445 // statement that can never be reached. 446 447 #ifndef BOOST_UNREACHABLE_RETURN 448 # ifdef BOOST_NO_UNREACHABLE_RETURN_DETECTION 449 # define BOOST_UNREACHABLE_RETURN(x) return x; 450 # else 451 # define BOOST_UNREACHABLE_RETURN(x) 452 # endif 453 #endif 454 455 // BOOST_DEDUCED_TYPENAME workaround ------------------------------------------// 456 // 457 // Some compilers don't support the use of `typename' for dependent 458 // types in deduced contexts, e.g. 459 // 460 // template <class T> void f(T, typename T::type); 461 // ^^^^^^^^ 462 // Replace these declarations with: 463 // 464 // template <class T> void f(T, BOOST_DEDUCED_TYPENAME T::type); 465 466 #ifndef BOOST_NO_DEDUCED_TYPENAME 467 # define BOOST_DEDUCED_TYPENAME typename 468 #else 469 # define BOOST_DEDUCED_TYPENAME 470 #endif 471 472 #ifndef BOOST_NO_TYPENAME_WITH_CTOR 473 # define BOOST_CTOR_TYPENAME typename 474 #else 475 # define BOOST_CTOR_TYPENAME 476 #endif 477 478 // long long workaround ------------------------------------------// 479 // On gcc (and maybe other compilers?) long long is alway supported 480 // but it's use may generate either warnings (with -ansi), or errors 481 // (with -pedantic -ansi) unless it's use is prefixed by __extension__ 482 // 483 #if defined(BOOST_HAS_LONG_LONG) && defined(__cplusplus) 484 namespace boost{ 485 # ifdef __GNUC__ 486 __extension__ typedef long long long_long_type; 487 __extension__ typedef unsigned long long ulong_long_type; 488 # else 489 typedef long long long_long_type; 490 typedef unsigned long long ulong_long_type; 491 # endif 492 } 493 #endif 494 // same again for __int128: 495 #if defined(BOOST_HAS_INT128) && defined(__cplusplus) 496 namespace boost{ 497 # ifdef __GNUC__ 498 __extension__ typedef __int128 int128_type; 499 __extension__ typedef unsigned __int128 uint128_type; 500 # else 501 typedef __int128 int128_type; 502 typedef unsigned __int128 uint128_type; 503 # endif 504 } 505 #endif 506 // same again for __float128: 507 #if defined(BOOST_HAS_FLOAT128) && defined(__cplusplus) 508 namespace boost { 509 # ifdef __GNUC__ 510 __extension__ typedef __float128 float128_type; 511 # else 512 typedef __float128 float128_type; 513 # endif 514 } 515 #endif 516 517 // BOOST_[APPEND_]EXPLICIT_TEMPLATE_[NON_]TYPE macros --------------------------// 518 519 // These macros are obsolete. Port away and remove. 520 521 # define BOOST_EXPLICIT_TEMPLATE_TYPE(t) 522 # define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t) 523 # define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v) 524 # define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) 525 526 # define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t) 527 # define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t) 528 # define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v) 529 # define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) 530 531 // When BOOST_NO_STD_TYPEINFO is defined, we can just import 532 // the global definition into std namespace, 533 // see https://svn.boost.org/trac10/ticket/4115 534 #if defined(BOOST_NO_STD_TYPEINFO) && defined(__cplusplus) && defined(BOOST_MSVC) 535 #include <typeinfo> 536 namespace std{ using ::type_info; } 537 // Since we do now have typeinfo, undef the macro: 538 #undef BOOST_NO_STD_TYPEINFO 539 #endif 540 541 // ---------------------------------------------------------------------------// 542 543 // Helper macro BOOST_STRINGIZE: 544 // Helper macro BOOST_JOIN: 545 546 #include <boost/config/helper_macros.hpp> 547 548 // 549 // Set some default values for compiler/library/platform names. 550 // These are for debugging config setup only: 551 // 552 # ifndef BOOST_COMPILER 553 # define BOOST_COMPILER "Unknown ISO C++ Compiler" 554 # endif 555 # ifndef BOOST_STDLIB 556 # define BOOST_STDLIB "Unknown ISO standard library" 557 # endif 558 # ifndef BOOST_PLATFORM 559 # if defined(unix) || defined(__unix) || defined(_XOPEN_SOURCE) \ 560 || defined(_POSIX_SOURCE) 561 # define BOOST_PLATFORM "Generic Unix" 562 # else 563 # define BOOST_PLATFORM "Unknown" 564 # endif 565 # endif 566 567 // 568 // Set some default values GPU support 569 // 570 # ifndef BOOST_GPU_ENABLED 571 # define BOOST_GPU_ENABLED 572 # endif 573 574 // BOOST_RESTRICT ---------------------------------------------// 575 // Macro to use in place of 'restrict' keyword variants 576 #if !defined(BOOST_RESTRICT) 577 # if defined(_MSC_VER) 578 # define BOOST_RESTRICT __restrict 579 # if !defined(BOOST_NO_RESTRICT_REFERENCES) && (_MSC_FULL_VER < 190023026) 580 # define BOOST_NO_RESTRICT_REFERENCES 581 # endif 582 # elif defined(__GNUC__) && __GNUC__ > 3 583 // Clang also defines __GNUC__ (as 4) 584 # define BOOST_RESTRICT __restrict__ 585 # else 586 # define BOOST_RESTRICT 587 # if !defined(BOOST_NO_RESTRICT_REFERENCES) 588 # define BOOST_NO_RESTRICT_REFERENCES 589 # endif 590 # endif 591 #endif 592 593 // BOOST_MAY_ALIAS -----------------------------------------------// 594 // The macro expands to an attribute to mark a type that is allowed to alias other types. 595 // The macro is defined in the compiler-specific headers. 596 #if !defined(BOOST_MAY_ALIAS) 597 # define BOOST_NO_MAY_ALIAS 598 # define BOOST_MAY_ALIAS 599 #endif 600 601 // BOOST_FORCEINLINE ---------------------------------------------// 602 // Macro to use in place of 'inline' to force a function to be inline 603 #if !defined(BOOST_FORCEINLINE) 604 # if defined(_MSC_VER) 605 # define BOOST_FORCEINLINE __forceinline 606 # elif defined(__GNUC__) && __GNUC__ > 3 607 // Clang also defines __GNUC__ (as 4) 608 # define BOOST_FORCEINLINE inline __attribute__ ((__always_inline__)) 609 # else 610 # define BOOST_FORCEINLINE inline 611 # endif 612 #endif 613 614 // BOOST_NOINLINE ---------------------------------------------// 615 // Macro to use in place of 'inline' to prevent a function to be inlined 616 #if !defined(BOOST_NOINLINE) 617 # if defined(_MSC_VER) 618 # define BOOST_NOINLINE __declspec(noinline) 619 # elif defined(__GNUC__) && __GNUC__ > 3 620 // Clang also defines __GNUC__ (as 4) 621 # if defined(__CUDACC__) 622 // nvcc doesn't always parse __noinline__, 623 // see: https://svn.boost.org/trac/boost/ticket/9392 624 # define BOOST_NOINLINE __attribute__ ((noinline)) 625 # else 626 # define BOOST_NOINLINE __attribute__ ((__noinline__)) 627 # endif 628 # else 629 # define BOOST_NOINLINE 630 # endif 631 #endif 632 633 // BOOST_NORETURN ---------------------------------------------// 634 // Macro to use before a function declaration/definition to designate 635 // the function as not returning normally (i.e. with a return statement 636 // or by leaving the function scope, if the function return type is void). 637 #if !defined(BOOST_NORETURN) 638 # if defined(_MSC_VER) 639 # define BOOST_NORETURN __declspec(noreturn) 640 # elif defined(__GNUC__) || defined(__CODEGEARC__) && defined(__clang__) 641 # define BOOST_NORETURN __attribute__ ((__noreturn__)) 642 # elif defined(__has_attribute) && defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x5130) 643 # if __has_attribute(noreturn) 644 # define BOOST_NORETURN [[noreturn]] 645 # endif 646 # elif defined(__has_cpp_attribute) 647 # if __has_cpp_attribute(noreturn) 648 # define BOOST_NORETURN [[noreturn]] 649 # endif 650 # endif 651 #endif 652 653 #if !defined(BOOST_NORETURN) 654 # define BOOST_NO_NORETURN 655 # define BOOST_NORETURN 656 #endif 657 658 // Branch prediction hints 659 // These macros are intended to wrap conditional expressions that yield true or false 660 // 661 // if (BOOST_LIKELY(var == 10)) 662 // { 663 // // the most probable code here 664 // } 665 // 666 #if !defined(BOOST_LIKELY) 667 # define BOOST_LIKELY(x) x 668 #endif 669 #if !defined(BOOST_UNLIKELY) 670 # define BOOST_UNLIKELY(x) x 671 #endif 672 673 #if !defined(BOOST_NO_CXX11_OVERRIDE) 674 # define BOOST_OVERRIDE override 675 #else 676 # define BOOST_OVERRIDE 677 #endif 678 679 // Type and data alignment specification 680 // 681 #if !defined(BOOST_ALIGNMENT) 682 # if !defined(BOOST_NO_CXX11_ALIGNAS) 683 # define BOOST_ALIGNMENT(x) alignas(x) 684 # elif defined(_MSC_VER) 685 # define BOOST_ALIGNMENT(x) __declspec(align(x)) 686 # elif defined(__GNUC__) 687 # define BOOST_ALIGNMENT(x) __attribute__ ((__aligned__(x))) 688 # else 689 # define BOOST_NO_ALIGNMENT 690 # define BOOST_ALIGNMENT(x) 691 # endif 692 #endif 693 694 // Lack of non-public defaulted functions is implied by the lack of any defaulted functions 695 #if !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS) && defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) 696 # define BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS 697 #endif 698 699 // Lack of defaulted moves is implied by the lack of either rvalue references or any defaulted functions 700 #if !defined(BOOST_NO_CXX11_DEFAULTED_MOVES) && (defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || defined(BOOST_NO_CXX11_RVALUE_REFERENCES)) 701 # define BOOST_NO_CXX11_DEFAULTED_MOVES 702 #endif 703 704 // Defaulted and deleted function declaration helpers 705 // These macros are intended to be inside a class definition. 706 // BOOST_DEFAULTED_FUNCTION accepts the function declaration and its 707 // body, which will be used if the compiler doesn't support defaulted functions. 708 // BOOST_DELETED_FUNCTION only accepts the function declaration. It 709 // will expand to a private function declaration, if the compiler doesn't support 710 // deleted functions. Because of this it is recommended to use BOOST_DELETED_FUNCTION 711 // in the end of the class definition. 712 // 713 // class my_class 714 // { 715 // public: 716 // // Default-constructible 717 // BOOST_DEFAULTED_FUNCTION(my_class(), {}) 718 // // Copying prohibited 719 // BOOST_DELETED_FUNCTION(my_class(my_class const&)) 720 // BOOST_DELETED_FUNCTION(my_class& operator= (my_class const&)) 721 // }; 722 // 723 #if !(defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)) 724 # define BOOST_DEFAULTED_FUNCTION(fun, body) fun = default; 725 #else 726 # define BOOST_DEFAULTED_FUNCTION(fun, body) fun body 727 #endif 728 729 #if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) 730 # define BOOST_DELETED_FUNCTION(fun) fun = delete; 731 #else 732 # define BOOST_DELETED_FUNCTION(fun) private: fun; 733 #endif 734 735 // 736 // Set BOOST_NO_DECLTYPE_N3276 when BOOST_NO_DECLTYPE is defined 737 // 738 #if defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276) 739 #define BOOST_NO_CXX11_DECLTYPE_N3276 BOOST_NO_CXX11_DECLTYPE 740 #endif 741 742 // -------------------- Deprecated macros for 1.50 --------------------------- 743 // These will go away in a future release 744 745 // Use BOOST_NO_CXX11_HDR_UNORDERED_SET or BOOST_NO_CXX11_HDR_UNORDERED_MAP 746 // instead of BOOST_NO_STD_UNORDERED 747 #if defined(BOOST_NO_CXX11_HDR_UNORDERED_MAP) || defined (BOOST_NO_CXX11_HDR_UNORDERED_SET) 748 # ifndef BOOST_NO_CXX11_STD_UNORDERED 749 # define BOOST_NO_CXX11_STD_UNORDERED 750 # endif 751 #endif 752 753 // Use BOOST_NO_CXX11_HDR_INITIALIZER_LIST instead of BOOST_NO_INITIALIZER_LISTS 754 #if defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) && !defined(BOOST_NO_INITIALIZER_LISTS) 755 # define BOOST_NO_INITIALIZER_LISTS 756 #endif 757 758 // Use BOOST_NO_CXX11_HDR_ARRAY instead of BOOST_NO_0X_HDR_ARRAY 759 #if defined(BOOST_NO_CXX11_HDR_ARRAY) && !defined(BOOST_NO_0X_HDR_ARRAY) 760 # define BOOST_NO_0X_HDR_ARRAY 761 #endif 762 // Use BOOST_NO_CXX11_HDR_CHRONO instead of BOOST_NO_0X_HDR_CHRONO 763 #if defined(BOOST_NO_CXX11_HDR_CHRONO) && !defined(BOOST_NO_0X_HDR_CHRONO) 764 # define BOOST_NO_0X_HDR_CHRONO 765 #endif 766 // Use BOOST_NO_CXX11_HDR_CODECVT instead of BOOST_NO_0X_HDR_CODECVT 767 #if defined(BOOST_NO_CXX11_HDR_CODECVT) && !defined(BOOST_NO_0X_HDR_CODECVT) 768 # define BOOST_NO_0X_HDR_CODECVT 769 #endif 770 // Use BOOST_NO_CXX11_HDR_CONDITION_VARIABLE instead of BOOST_NO_0X_HDR_CONDITION_VARIABLE 771 #if defined(BOOST_NO_CXX11_HDR_CONDITION_VARIABLE) && !defined(BOOST_NO_0X_HDR_CONDITION_VARIABLE) 772 # define BOOST_NO_0X_HDR_CONDITION_VARIABLE 773 #endif 774 // Use BOOST_NO_CXX11_HDR_FORWARD_LIST instead of BOOST_NO_0X_HDR_FORWARD_LIST 775 #if defined(BOOST_NO_CXX11_HDR_FORWARD_LIST) && !defined(BOOST_NO_0X_HDR_FORWARD_LIST) 776 # define BOOST_NO_0X_HDR_FORWARD_LIST 777 #endif 778 // Use BOOST_NO_CXX11_HDR_FUTURE instead of BOOST_NO_0X_HDR_FUTURE 779 #if defined(BOOST_NO_CXX11_HDR_FUTURE) && !defined(BOOST_NO_0X_HDR_FUTURE) 780 # define BOOST_NO_0X_HDR_FUTURE 781 #endif 782 783 // Use BOOST_NO_CXX11_HDR_INITIALIZER_LIST 784 // instead of BOOST_NO_0X_HDR_INITIALIZER_LIST or BOOST_NO_INITIALIZER_LISTS 785 #ifdef BOOST_NO_CXX11_HDR_INITIALIZER_LIST 786 # ifndef BOOST_NO_0X_HDR_INITIALIZER_LIST 787 # define BOOST_NO_0X_HDR_INITIALIZER_LIST 788 # endif 789 # ifndef BOOST_NO_INITIALIZER_LISTS 790 # define BOOST_NO_INITIALIZER_LISTS 791 # endif 792 #endif 793 794 // Use BOOST_NO_CXX11_HDR_MUTEX instead of BOOST_NO_0X_HDR_MUTEX 795 #if defined(BOOST_NO_CXX11_HDR_MUTEX) && !defined(BOOST_NO_0X_HDR_MUTEX) 796 # define BOOST_NO_0X_HDR_MUTEX 797 #endif 798 // Use BOOST_NO_CXX11_HDR_RANDOM instead of BOOST_NO_0X_HDR_RANDOM 799 #if defined(BOOST_NO_CXX11_HDR_RANDOM) && !defined(BOOST_NO_0X_HDR_RANDOM) 800 # define BOOST_NO_0X_HDR_RANDOM 801 #endif 802 // Use BOOST_NO_CXX11_HDR_RATIO instead of BOOST_NO_0X_HDR_RATIO 803 #if defined(BOOST_NO_CXX11_HDR_RATIO) && !defined(BOOST_NO_0X_HDR_RATIO) 804 # define BOOST_NO_0X_HDR_RATIO 805 #endif 806 // Use BOOST_NO_CXX11_HDR_REGEX instead of BOOST_NO_0X_HDR_REGEX 807 #if defined(BOOST_NO_CXX11_HDR_REGEX) && !defined(BOOST_NO_0X_HDR_REGEX) 808 # define BOOST_NO_0X_HDR_REGEX 809 #endif 810 // Use BOOST_NO_CXX11_HDR_SYSTEM_ERROR instead of BOOST_NO_0X_HDR_SYSTEM_ERROR 811 #if defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR) && !defined(BOOST_NO_0X_HDR_SYSTEM_ERROR) 812 # define BOOST_NO_0X_HDR_SYSTEM_ERROR 813 #endif 814 // Use BOOST_NO_CXX11_HDR_THREAD instead of BOOST_NO_0X_HDR_THREAD 815 #if defined(BOOST_NO_CXX11_HDR_THREAD) && !defined(BOOST_NO_0X_HDR_THREAD) 816 # define BOOST_NO_0X_HDR_THREAD 817 #endif 818 // Use BOOST_NO_CXX11_HDR_TUPLE instead of BOOST_NO_0X_HDR_TUPLE 819 #if defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_0X_HDR_TUPLE) 820 # define BOOST_NO_0X_HDR_TUPLE 821 #endif 822 // Use BOOST_NO_CXX11_HDR_TYPE_TRAITS instead of BOOST_NO_0X_HDR_TYPE_TRAITS 823 #if defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) && !defined(BOOST_NO_0X_HDR_TYPE_TRAITS) 824 # define BOOST_NO_0X_HDR_TYPE_TRAITS 825 #endif 826 // Use BOOST_NO_CXX11_HDR_TYPEINDEX instead of BOOST_NO_0X_HDR_TYPEINDEX 827 #if defined(BOOST_NO_CXX11_HDR_TYPEINDEX) && !defined(BOOST_NO_0X_HDR_TYPEINDEX) 828 # define BOOST_NO_0X_HDR_TYPEINDEX 829 #endif 830 // Use BOOST_NO_CXX11_HDR_UNORDERED_MAP instead of BOOST_NO_0X_HDR_UNORDERED_MAP 831 #if defined(BOOST_NO_CXX11_HDR_UNORDERED_MAP) && !defined(BOOST_NO_0X_HDR_UNORDERED_MAP) 832 # define BOOST_NO_0X_HDR_UNORDERED_MAP 833 #endif 834 // Use BOOST_NO_CXX11_HDR_UNORDERED_SET instead of BOOST_NO_0X_HDR_UNORDERED_SET 835 #if defined(BOOST_NO_CXX11_HDR_UNORDERED_SET) && !defined(BOOST_NO_0X_HDR_UNORDERED_SET) 836 # define BOOST_NO_0X_HDR_UNORDERED_SET 837 #endif 838 839 // ------------------ End of deprecated macros for 1.50 --------------------------- 840 841 // -------------------- Deprecated macros for 1.51 --------------------------- 842 // These will go away in a future release 843 844 // Use BOOST_NO_CXX11_AUTO_DECLARATIONS instead of BOOST_NO_AUTO_DECLARATIONS 845 #if defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && !defined(BOOST_NO_AUTO_DECLARATIONS) 846 # define BOOST_NO_AUTO_DECLARATIONS 847 #endif 848 // Use BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS instead of BOOST_NO_AUTO_MULTIDECLARATIONS 849 #if defined(BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS) && !defined(BOOST_NO_AUTO_MULTIDECLARATIONS) 850 # define BOOST_NO_AUTO_MULTIDECLARATIONS 851 #endif 852 // Use BOOST_NO_CXX11_CHAR16_T instead of BOOST_NO_CHAR16_T 853 #if defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CHAR16_T) 854 # define BOOST_NO_CHAR16_T 855 #endif 856 // Use BOOST_NO_CXX11_CHAR32_T instead of BOOST_NO_CHAR32_T 857 #if defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CHAR32_T) 858 # define BOOST_NO_CHAR32_T 859 #endif 860 // Use BOOST_NO_CXX11_TEMPLATE_ALIASES instead of BOOST_NO_TEMPLATE_ALIASES 861 #if defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && !defined(BOOST_NO_TEMPLATE_ALIASES) 862 # define BOOST_NO_TEMPLATE_ALIASES 863 #endif 864 // Use BOOST_NO_CXX11_CONSTEXPR instead of BOOST_NO_CONSTEXPR 865 #if defined(BOOST_NO_CXX11_CONSTEXPR) && !defined(BOOST_NO_CONSTEXPR) 866 # define BOOST_NO_CONSTEXPR 867 #endif 868 // Use BOOST_NO_CXX11_DECLTYPE_N3276 instead of BOOST_NO_DECLTYPE_N3276 869 #if defined(BOOST_NO_CXX11_DECLTYPE_N3276) && !defined(BOOST_NO_DECLTYPE_N3276) 870 # define BOOST_NO_DECLTYPE_N3276 871 #endif 872 // Use BOOST_NO_CXX11_DECLTYPE instead of BOOST_NO_DECLTYPE 873 #if defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_DECLTYPE) 874 # define BOOST_NO_DECLTYPE 875 #endif 876 // Use BOOST_NO_CXX11_DEFAULTED_FUNCTIONS instead of BOOST_NO_DEFAULTED_FUNCTIONS 877 #if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_DEFAULTED_FUNCTIONS) 878 # define BOOST_NO_DEFAULTED_FUNCTIONS 879 #endif 880 // Use BOOST_NO_CXX11_DELETED_FUNCTIONS instead of BOOST_NO_DELETED_FUNCTIONS 881 #if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_NO_DELETED_FUNCTIONS) 882 # define BOOST_NO_DELETED_FUNCTIONS 883 #endif 884 // Use BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS instead of BOOST_NO_EXPLICIT_CONVERSION_OPERATORS 885 #if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) && !defined(BOOST_NO_EXPLICIT_CONVERSION_OPERATORS) 886 # define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS 887 #endif 888 // Use BOOST_NO_CXX11_EXTERN_TEMPLATE instead of BOOST_NO_EXTERN_TEMPLATE 889 #if defined(BOOST_NO_CXX11_EXTERN_TEMPLATE) && !defined(BOOST_NO_EXTERN_TEMPLATE) 890 # define BOOST_NO_EXTERN_TEMPLATE 891 #endif 892 // Use BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS instead of BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS 893 #if defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && !defined(BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS) 894 # define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS 895 #endif 896 // Use BOOST_NO_CXX11_LAMBDAS instead of BOOST_NO_LAMBDAS 897 #if defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_LAMBDAS) 898 # define BOOST_NO_LAMBDAS 899 #endif 900 // Use BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS instead of BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS 901 #if defined(BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS) && !defined(BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS) 902 # define BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS 903 #endif 904 // Use BOOST_NO_CXX11_NOEXCEPT instead of BOOST_NO_NOEXCEPT 905 #if defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_NOEXCEPT) 906 # define BOOST_NO_NOEXCEPT 907 #endif 908 // Use BOOST_NO_CXX11_NULLPTR instead of BOOST_NO_NULLPTR 909 #if defined(BOOST_NO_CXX11_NULLPTR) && !defined(BOOST_NO_NULLPTR) 910 # define BOOST_NO_NULLPTR 911 #endif 912 // Use BOOST_NO_CXX11_RAW_LITERALS instead of BOOST_NO_RAW_LITERALS 913 #if defined(BOOST_NO_CXX11_RAW_LITERALS) && !defined(BOOST_NO_RAW_LITERALS) 914 # define BOOST_NO_RAW_LITERALS 915 #endif 916 // Use BOOST_NO_CXX11_RVALUE_REFERENCES instead of BOOST_NO_RVALUE_REFERENCES 917 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_RVALUE_REFERENCES) 918 # define BOOST_NO_RVALUE_REFERENCES 919 #endif 920 // Use BOOST_NO_CXX11_SCOPED_ENUMS instead of BOOST_NO_SCOPED_ENUMS 921 #if defined(BOOST_NO_CXX11_SCOPED_ENUMS) && !defined(BOOST_NO_SCOPED_ENUMS) 922 # define BOOST_NO_SCOPED_ENUMS 923 #endif 924 // Use BOOST_NO_CXX11_STATIC_ASSERT instead of BOOST_NO_STATIC_ASSERT 925 #if defined(BOOST_NO_CXX11_STATIC_ASSERT) && !defined(BOOST_NO_STATIC_ASSERT) 926 # define BOOST_NO_STATIC_ASSERT 927 #endif 928 // Use BOOST_NO_CXX11_STD_UNORDERED instead of BOOST_NO_STD_UNORDERED 929 #if defined(BOOST_NO_CXX11_STD_UNORDERED) && !defined(BOOST_NO_STD_UNORDERED) 930 # define BOOST_NO_STD_UNORDERED 931 #endif 932 // Use BOOST_NO_CXX11_UNICODE_LITERALS instead of BOOST_NO_UNICODE_LITERALS 933 #if defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(BOOST_NO_UNICODE_LITERALS) 934 # define BOOST_NO_UNICODE_LITERALS 935 #endif 936 // Use BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX instead of BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX 937 #if defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) && !defined(BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX) 938 # define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX 939 #endif 940 // Use BOOST_NO_CXX11_VARIADIC_TEMPLATES instead of BOOST_NO_VARIADIC_TEMPLATES 941 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_VARIADIC_TEMPLATES) 942 # define BOOST_NO_VARIADIC_TEMPLATES 943 #endif 944 // Use BOOST_NO_CXX11_VARIADIC_MACROS instead of BOOST_NO_VARIADIC_MACROS 945 #if defined(BOOST_NO_CXX11_VARIADIC_MACROS) && !defined(BOOST_NO_VARIADIC_MACROS) 946 # define BOOST_NO_VARIADIC_MACROS 947 #endif 948 // Use BOOST_NO_CXX11_NUMERIC_LIMITS instead of BOOST_NO_NUMERIC_LIMITS_LOWEST 949 #if defined(BOOST_NO_CXX11_NUMERIC_LIMITS) && !defined(BOOST_NO_NUMERIC_LIMITS_LOWEST) 950 # define BOOST_NO_NUMERIC_LIMITS_LOWEST 951 #endif 952 // ------------------ End of deprecated macros for 1.51 --------------------------- 953 954 955 // 956 // Helper macro for marking types and methods final 957 // 958 #if !defined(BOOST_NO_CXX11_FINAL) 959 # define BOOST_FINAL final 960 #else 961 # define BOOST_FINAL 962 #endif 963 964 // 965 // Helper macros BOOST_NOEXCEPT, BOOST_NOEXCEPT_IF, BOOST_NOEXCEPT_EXPR 966 // These aid the transition to C++11 while still supporting C++03 compilers 967 // 968 #ifdef BOOST_NO_CXX11_NOEXCEPT 969 # define BOOST_NOEXCEPT 970 # define BOOST_NOEXCEPT_OR_NOTHROW throw() 971 # define BOOST_NOEXCEPT_IF(Predicate) 972 # define BOOST_NOEXCEPT_EXPR(Expression) false 973 #else 974 # define BOOST_NOEXCEPT noexcept 975 # define BOOST_NOEXCEPT_OR_NOTHROW noexcept 976 # define BOOST_NOEXCEPT_IF(Predicate) noexcept((Predicate)) 977 # define BOOST_NOEXCEPT_EXPR(Expression) noexcept((Expression)) 978 #endif 979 // 980 // Helper macro BOOST_FALLTHROUGH 981 // Fallback definition of BOOST_FALLTHROUGH macro used to mark intended 982 // fall-through between case labels in a switch statement. We use a definition 983 // that requires a semicolon after it to avoid at least one type of misuse even 984 // on unsupported compilers. 985 // 986 #ifndef BOOST_FALLTHROUGH 987 # define BOOST_FALLTHROUGH ((void)0) 988 #endif 989 990 // 991 // constexpr workarounds 992 // 993 #if defined(BOOST_NO_CXX11_CONSTEXPR) 994 #define BOOST_CONSTEXPR 995 #define BOOST_CONSTEXPR_OR_CONST const 996 #else 997 #define BOOST_CONSTEXPR constexpr 998 #define BOOST_CONSTEXPR_OR_CONST constexpr 999 #endif 1000 #if defined(BOOST_NO_CXX14_CONSTEXPR) 1001 #define BOOST_CXX14_CONSTEXPR 1002 #else 1003 #define BOOST_CXX14_CONSTEXPR constexpr 1004 #endif 1005 1006 // 1007 // C++17 inline variables 1008 // 1009 #if !defined(BOOST_NO_CXX17_INLINE_VARIABLES) 1010 #define BOOST_INLINE_VARIABLE inline 1011 #else 1012 #define BOOST_INLINE_VARIABLE 1013 #endif 1014 // 1015 // C++17 if constexpr 1016 // 1017 #if !defined(BOOST_NO_CXX17_IF_CONSTEXPR) 1018 # define BOOST_IF_CONSTEXPR if constexpr 1019 #else 1020 # define BOOST_IF_CONSTEXPR if 1021 #endif 1022 1023 #define BOOST_INLINE_CONSTEXPR BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST 1024 1025 // 1026 // Unused variable/typedef workarounds: 1027 // 1028 #ifndef BOOST_ATTRIBUTE_UNUSED 1029 # define BOOST_ATTRIBUTE_UNUSED 1030 #endif 1031 // 1032 // [[nodiscard]]: 1033 // 1034 #if defined(__has_attribute) && defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x5130) 1035 #if __has_attribute(nodiscard) 1036 # define BOOST_ATTRIBUTE_NODISCARD [[nodiscard]] 1037 #endif 1038 #if __has_attribute(no_unique_address) 1039 # define BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS [[no_unique_address]] 1040 #endif 1041 #elif defined(__has_cpp_attribute) 1042 // clang-6 accepts [[nodiscard]] with -std=c++14, but warns about it -pedantic 1043 #if __has_cpp_attribute(nodiscard) && !(defined(__clang__) && (__cplusplus < 201703L)) 1044 # define BOOST_ATTRIBUTE_NODISCARD [[nodiscard]] 1045 #endif 1046 #if __has_cpp_attribute(no_unique_address) && !(defined(__GNUC__) && (__cplusplus < 201100)) 1047 # define BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS [[no_unique_address]] 1048 #endif 1049 #endif 1050 #ifndef BOOST_ATTRIBUTE_NODISCARD 1051 # define BOOST_ATTRIBUTE_NODISCARD 1052 #endif 1053 #ifndef BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS 1054 # define BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS 1055 #endif 1056 1057 #define BOOST_STATIC_CONSTEXPR static BOOST_CONSTEXPR_OR_CONST 1058 1059 // 1060 // Set BOOST_HAS_STATIC_ASSERT when BOOST_NO_CXX11_STATIC_ASSERT is not defined 1061 // 1062 #if !defined(BOOST_NO_CXX11_STATIC_ASSERT) && !defined(BOOST_HAS_STATIC_ASSERT) 1063 # define BOOST_HAS_STATIC_ASSERT 1064 #endif 1065 1066 // 1067 // Set BOOST_HAS_RVALUE_REFS when BOOST_NO_CXX11_RVALUE_REFERENCES is not defined 1068 // 1069 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_HAS_RVALUE_REFS) 1070 #define BOOST_HAS_RVALUE_REFS 1071 #endif 1072 1073 // 1074 // Set BOOST_HAS_VARIADIC_TMPL when BOOST_NO_CXX11_VARIADIC_TEMPLATES is not defined 1075 // 1076 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_HAS_VARIADIC_TMPL) 1077 #define BOOST_HAS_VARIADIC_TMPL 1078 #endif 1079 // 1080 // Set BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS when 1081 // BOOST_NO_CXX11_VARIADIC_TEMPLATES is set: 1082 // 1083 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS) 1084 # define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS 1085 #endif 1086 1087 // This is a catch all case for obsolete compilers / std libs: 1088 #if !defined(_YVALS) && !defined(_CPPLIB_VER) // msvc std lib already configured 1089 #if (!defined(__has_include) || (__cplusplus < 201700)) 1090 # define BOOST_NO_CXX17_HDR_OPTIONAL 1091 # define BOOST_NO_CXX17_HDR_STRING_VIEW 1092 # define BOOST_NO_CXX17_HDR_VARIANT 1093 # define BOOST_NO_CXX17_HDR_ANY 1094 # define BOOST_NO_CXX17_HDR_MEMORY_RESOURCE 1095 # define BOOST_NO_CXX17_HDR_CHARCONV 1096 # define BOOST_NO_CXX17_HDR_EXECUTION 1097 # define BOOST_NO_CXX17_HDR_FILESYSTEM 1098 #else 1099 #if !__has_include(<optional>) 1100 # define BOOST_NO_CXX17_HDR_OPTIONAL 1101 #endif 1102 #if !__has_include(<string_view>) 1103 # define BOOST_NO_CXX17_HDR_STRING_VIEW 1104 #endif 1105 #if !__has_include(<variant>) 1106 # define BOOST_NO_CXX17_HDR_VARIANT 1107 #endif 1108 #if !__has_include(<any>) 1109 # define BOOST_NO_CXX17_HDR_ANY 1110 #endif 1111 #if !__has_include(<memory_resource>) 1112 # define BOOST_NO_CXX17_HDR_MEMORY_RESOURCE 1113 #endif 1114 #if !__has_include(<charconv>) 1115 # define BOOST_NO_CXX17_HDR_CHARCONV 1116 #endif 1117 #if !__has_include(<execution>) 1118 # define BOOST_NO_CXX17_HDR_EXECUTION 1119 #endif 1120 #if !__has_include(<filesystem>) 1121 # define BOOST_NO_CXX17_HDR_FILESYSTEM 1122 #endif 1123 #endif 1124 #endif 1125 1126 // 1127 // Define composite agregate macros: 1128 // 1129 #include <boost/config/detail/cxx_composite.hpp> 1130 1131 // 1132 // Define the std level that the compiler claims to support: 1133 // 1134 #ifndef BOOST_CXX_VERSION 1135 # define BOOST_CXX_VERSION __cplusplus 1136 #endif 1137 1138 // 1139 // Finish off with checks for macros that are depricated / no longer supported, 1140 // if any of these are set then it's very likely that much of Boost will no 1141 // longer work. So stop with a #error for now, but give the user a chance 1142 // to continue at their own risk if they really want to: 1143 // 1144 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_CONFIG_ALLOW_DEPRECATED) 1145 # error "You are using a compiler which lacks features which are now a minimum requirement in order to use Boost, define BOOST_CONFIG_ALLOW_DEPRECATED if you want to continue at your own risk!!!" 1146 #endif 1147 1148 #endif 1149