1 /*============================================================================= 2 Boost.Wave: A Standard compliant C++ preprocessor library 3 4 Global application configuration 5 6 http://www.boost.org/ 7 8 Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost 9 Software License, Version 1.0. (See accompanying file 10 LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 11 =============================================================================*/ 12 13 #if !defined(BOOST_WAVE_CONFIG_HPP_F143F90A_A63F_4B27_AC41_9CA4F14F538D_INCLUDED) 14 #define BOOST_WAVE_CONFIG_HPP_F143F90A_A63F_4B27_AC41_9CA4F14F538D_INCLUDED 15 16 #include <boost/config.hpp> 17 #include <boost/config/pragma_message.hpp> 18 #include <boost/detail/workaround.hpp> 19 #include <boost/version.hpp> 20 #include <boost/spirit/include/classic_version.hpp> 21 #include <boost/wave/wave_version.hpp> 22 23 /////////////////////////////////////////////////////////////////////////////// 24 // Define the maximal include nesting depth allowed. If this value isn't 25 // defined it defaults to 1024 26 // 27 // To define a new initial include nesting define the following constant 28 // before including this file. 29 // 30 #if !defined(BOOST_WAVE_MAX_INCLUDE_LEVEL_DEPTH) 31 #define BOOST_WAVE_MAX_INCLUDE_LEVEL_DEPTH 1024 32 #endif 33 34 /////////////////////////////////////////////////////////////////////////////// 35 // Decide, whether to support variadics and placemarkers 36 // 37 // To implement support variadics and placemarkers define the following to 38 // something not equal to zero. 39 // 40 #if !defined(BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS) 41 #define BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 1 42 #endif 43 44 /////////////////////////////////////////////////////////////////////////////// 45 // Decide whether to support the C++20 __VA_OPT__ variadics feature 46 // 47 // 48 #if !defined(BOOST_WAVE_SUPPORT_VA_OPT) && BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 49 #define BOOST_WAVE_SUPPORT_VA_OPT 1 50 #endif 51 52 /////////////////////////////////////////////////////////////////////////////// 53 // Decide, whether to implement a #warning directive as an extension to the 54 // C++ Standard (same as #error, but emits a warning, not an error) 55 // 56 // To disable the implementation of #warning directives, define the following 57 // constant as zero before including this file. 58 // 59 #if !defined(BOOST_WAVE_SUPPORT_WARNING_DIRECTIVE) 60 #define BOOST_WAVE_SUPPORT_WARNING_DIRECTIVE 1 61 #endif 62 63 /////////////////////////////////////////////////////////////////////////////// 64 // Decide, whether to implement #pragma once 65 // 66 // To disable the implementation of #pragma once, define the following 67 // constant as zero before including this file. 68 // 69 #if !defined(BOOST_WAVE_SUPPORT_PRAGMA_ONCE) 70 #define BOOST_WAVE_SUPPORT_PRAGMA_ONCE 1 71 #endif 72 73 /////////////////////////////////////////////////////////////////////////////// 74 // Decide, whether to implement #pragma message("") 75 // 76 // To disable the implementation of #pragma message(""), define the following 77 // constant as zero before including this file. 78 // 79 #if !defined(BOOST_WAVE_SUPPORT_PRAGMA_MESSAGE) 80 #define BOOST_WAVE_SUPPORT_PRAGMA_MESSAGE 1 81 #endif 82 83 /////////////////////////////////////////////////////////////////////////////// 84 // Decide, whether to implement #include_next 85 // Please note, that this is an extension to the C++ Standard. 86 // 87 // To disable the implementation of #include_next, define the following 88 // constant as zero before including this file. 89 // 90 #if !defined(BOOST_WAVE_SUPPORT_INCLUDE_NEXT) 91 #define BOOST_WAVE_SUPPORT_INCLUDE_NEXT 1 92 #endif 93 94 /////////////////////////////////////////////////////////////////////////////// 95 // Decide, whether to support C++11 96 // 97 // To implement C++11 keywords and preprocessor semantics define the following 98 // to something not equal to zero. 99 // 100 #if !defined(BOOST_WAVE_SUPPORT_CPP0X) 101 #define BOOST_WAVE_SUPPORT_CPP0X 1 102 #undef BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 103 #define BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 1 104 #endif 105 106 /////////////////////////////////////////////////////////////////////////////// 107 // Decide whether to support C++17 108 // 109 #if !defined(BOOST_WAVE_SUPPORT_CPP1Z) 110 # define BOOST_WAVE_SUPPORT_CPP1Z 1 111 # undef BOOST_WAVE_SUPPORT_CPP0X 112 # define BOOST_WAVE_SUPPORT_CPP0X 1 113 # undef BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 114 # define BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 1 115 # if !defined(BOOST_WAVE_SUPPORT_HAS_INCLUDE) 116 # define BOOST_WAVE_SUPPORT_HAS_INCLUDE 1 117 # endif 118 #elif BOOST_WAVE_SUPPORT_CPP1Z == 0 119 # undef BOOST_WAVE_SUPPORT_HAS_INCLUDE 120 # define BOOST_WAVE_SUPPORT_HAS_INCLUDE 0 121 #endif 122 123 /////////////////////////////////////////////////////////////////////////////// 124 // Decide whether to support C++20 125 // 126 #if !defined(BOOST_WAVE_SUPPORT_CPP2A) 127 # define BOOST_WAVE_SUPPORT_CPP2A 1 128 # undef BOOST_WAVE_SUPPORT_CPP0X 129 # define BOOST_WAVE_SUPPORT_CPP0X 1 130 # undef BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 131 # define BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 1 132 # undef BOOST_WAVE_SUPPORT_CPP1Z 133 # define BOOST_WAVE_SUPPORT_CPP1Z 1 134 # if !defined(BOOST_WAVE_SUPPORT_HAS_INCLUDE) 135 # define BOOST_WAVE_SUPPORT_HAS_INCLUDE 1 136 # endif 137 # if !defined(BOOST_WAVE_SUPPORT_VA_OPT) 138 # define BOOST_WAVE_SUPPORT_VA_OPT 1 139 # endif 140 #elif BOOST_WAVE_SUPPORT_CPP2A == 0 141 # undef BOOST_WAVE_SUPPORT_VA_OPT 142 # define BOOST_WAVE_SUPPORT_VA_OPT 0 143 #endif 144 145 /////////////////////////////////////////////////////////////////////////////// 146 // Undefine the following, to enable some MS specific language extensions: 147 // __int8, __int16, __int32, __int64, __based, __declspec, __cdecl, 148 // __fastcall, __stdcall, __try, __except, __finally, __leave, __inline, 149 // __asm, #region, #endregion 150 // 151 // Note: By default this is enabled for Windows based systems, otherwise it's 152 // disabled. 153 #if !defined(BOOST_WAVE_SUPPORT_MS_EXTENSIONS) 154 #if defined(BOOST_WINDOWS) 155 #define BOOST_WAVE_SUPPORT_MS_EXTENSIONS 1 156 #else 157 #define BOOST_WAVE_SUPPORT_MS_EXTENSIONS 0 158 #endif 159 #endif 160 161 /////////////////////////////////////////////////////////////////////////////// 162 // Allow the message body of the #error and #warning directives to be 163 // preprocessed before the diagnostic is issued. 164 // 165 // To disable preprocessing of the body of #error and #warning directives, 166 // define the following constant as zero before including this file. 167 // 168 #if !defined(BOOST_WAVE_PREPROCESS_ERROR_MESSAGE_BODY) 169 #define BOOST_WAVE_PREPROCESS_ERROR_MESSAGE_BODY 1 170 #endif 171 172 /////////////////////////////////////////////////////////////////////////////// 173 // Allow the #pragma directives to be returned to the caller (optionally after 174 // preprocessing the body) 175 // 176 // To disable the library to emit unknown #pragma directives, define the 177 // following constant as zero before including this file. 178 // 179 #if !defined(BOOST_WAVE_EMIT_PRAGMA_DIRECTIVES) 180 #define BOOST_WAVE_EMIT_PRAGMA_DIRECTIVES 1 181 #endif 182 183 /////////////////////////////////////////////////////////////////////////////// 184 // Allow the body of a #pragma directive to be preprocessed before the 185 // directive is returned to the caller. 186 // 187 // To disable the preprocessing of the body of #pragma directives, define the 188 // following constant as zero before including this file. 189 // 190 #if !defined(BOOST_WAVE_PREPROCESS_PRAGMA_BODY) 191 #define BOOST_WAVE_PREPROCESS_PRAGMA_BODY 1 192 #endif 193 194 /////////////////////////////////////////////////////////////////////////////// 195 // Allow to define macros with the command line syntax (-DMACRO(x)=definition) 196 // 197 // To disable the possibility to define macros based on the command line 198 // syntax, define the following constant as zero before including this file. 199 // 200 #if !defined(BOOST_WAVE_ENABLE_COMMANDLINE_MACROS) 201 #define BOOST_WAVE_ENABLE_COMMANDLINE_MACROS 1 202 #endif 203 204 /////////////////////////////////////////////////////////////////////////////// 205 // Define the pragma keyword to be used by the library to recognize its own 206 // pragma's. If nothing else is defined, then 'wave' will be used as the 207 // default keyword, i.e. the library recognizes all 208 // 209 // #pragma wave option [(argument)] 210 // 211 // and dispatches the handling to the interpret_pragma() preprocessing hook 212 // function (see file: preprocessing_hooks.hpp). The arguments part of the 213 // pragma is optional. 214 // The BOOST_WAVE_PRAGMA_KEYWORD constant needs to be defined to 215 // resolve as a string literal value. 216 #if !defined(BOOST_WAVE_PRAGMA_KEYWORD) 217 #define BOOST_WAVE_PRAGMA_KEYWORD "wave" 218 #endif 219 220 /////////////////////////////////////////////////////////////////////////////// 221 // Configure Wave thread support, Boost.Spirit and Boost.Pool are configured 222 // based on these settings automatically 223 // 224 // If BOOST_WAVE_SUPPORT_THREADING is not defined, Wave will use the global 225 // Boost build settings (BOOST_HAS_THREADS), if it is defined its value 226 // defines, whether threading will be enabled or not (should be set to '0' 227 // or '1'). 228 #if !defined(BOOST_WAVE_SUPPORT_THREADING) 229 #if defined(BOOST_HAS_THREADS) 230 #define BOOST_WAVE_SUPPORT_THREADING 1 231 #else 232 #define BOOST_WAVE_SUPPORT_THREADING 0 233 #endif 234 #endif 235 236 #if BOOST_WAVE_SUPPORT_THREADING != 0 237 #ifndef BOOST_SPIRIT_THREADSAFE 238 #define BOOST_SPIRIT_THREADSAFE 239 #endif 240 #define PHOENIX_THREADSAFE 1 241 #else 242 // disable thread support in Boost.Pool 243 #define BOOST_NO_MT 1 244 #endif 245 246 /////////////////////////////////////////////////////////////////////////////// 247 // Define the string type to be used to store the token values and the file 248 // names inside a file_position template class 249 // 250 #if !defined(BOOST_WAVE_STRINGTYPE) 251 252 // VC7 isn't able to compile the flex_string class, fall back to std::string 253 // CW up to 8.3 chokes as well *sigh* 254 // Tru64/CXX has linker problems when using flex_string 255 #if BOOST_WORKAROUND(__MWERKS__, < 0x3200) || \ 256 (defined(__DECCXX) && defined(__alpha)) || \ 257 defined(BOOST_WAVE_STRINGTYPE_USE_STDSTRING) 258 259 #define BOOST_WAVE_STRINGTYPE std::string 260 261 #if !defined(BOOST_WAVE_STRINGTYPE_USE_STDSTRING) 262 #define BOOST_WAVE_STRINGTYPE_USE_STDSTRING 1 263 #endif 264 265 #else 266 267 // use the following, if you have a fast std::allocator<char> 268 #define BOOST_WAVE_STRINGTYPE boost::wave::util::flex_string< \ 269 char, std::char_traits<char>, std::allocator<char>, \ 270 boost::wave::util::CowString< \ 271 boost::wave::util::AllocatorStringStorage<char> \ 272 > \ 273 > \ 274 /**/ 275 276 // This include is needed for the flex_string class used in the 277 // BOOST_WAVE_STRINGTYPE above. 278 #include <boost/wave/util/flex_string.hpp> 279 280 #endif // BOOST_WORKAROUND(__MWERKS__, < 0x3200) et.al. 281 #endif // !defined(BOOST_WAVE_STRINGTYPE) 282 283 /////////////////////////////////////////////////////////////////////////////// 284 // The following definition forces the Spirit tree code to use list's instead 285 // of vectors, which may be more efficient on some platforms 286 // #define BOOST_SPIRIT_USE_LIST_FOR_TREES 287 288 /////////////////////////////////////////////////////////////////////////////// 289 // The following definition forces the Spirit tree code to use boost pool 290 // allocators instead of the std::allocator for the vector/list's. 291 // #define BOOST_SPIRIT_USE_BOOST_ALLOCATOR_FOR_TREES 292 293 /////////////////////////////////////////////////////////////////////////////// 294 // Uncomment the following, if you need debug output, the 295 // BOOST_SPIRIT_DEBUG_FLAGS_CPP constants below help to fine control the 296 // amount of the generated debug output. 297 //#define BOOST_SPIRIT_DEBUG 298 299 /////////////////////////////////////////////////////////////////////////////// 300 // Debug flags for the Wave library, possible flags specified below. 301 // 302 // Note: These flags take effect only if the BOOST_SPIRIT_DEBUG constant 303 // above is defined as well. 304 #define BOOST_SPIRIT_DEBUG_FLAGS_CPP_GRAMMAR 0x0001 305 #define BOOST_SPIRIT_DEBUG_FLAGS_TIME_CONVERSION 0x0002 306 #define BOOST_SPIRIT_DEBUG_FLAGS_CPP_EXPR_GRAMMAR 0x0004 307 #define BOOST_SPIRIT_DEBUG_FLAGS_INTLIT_GRAMMAR 0x0008 308 #define BOOST_SPIRIT_DEBUG_FLAGS_CHLIT_GRAMMAR 0x0010 309 #define BOOST_SPIRIT_DEBUG_FLAGS_DEFINED_GRAMMAR 0x0020 310 #define BOOST_SPIRIT_DEBUG_FLAGS_PREDEF_MACROS_GRAMMAR 0x0040 311 #define BOOST_SPIRIT_DEBUG_FLAGS_HAS_INCLUDE_GRAMMAR 0x0080 312 313 #if !defined(BOOST_SPIRIT_DEBUG_FLAGS_CPP) 314 #define BOOST_SPIRIT_DEBUG_FLAGS_CPP 0 // default is no debugging 315 #endif 316 317 /////////////////////////////////////////////////////////////////////////////// 318 // 319 // For all recognized preprocessor statements the output parse trees 320 // formatted as xml are printed. The formatted parse trees are streamed to the 321 // std::ostream defined by the WAVE_DUMP_PARSE_TREE_OUT constant. 322 // 323 // To enable the output of these parse trees, define the following constant 324 // as zero something not equal to zero before including this file. 325 // 326 #if !defined(BOOST_WAVE_DUMP_PARSE_TREE) 327 #define BOOST_WAVE_DUMP_PARSE_TREE 0 328 #endif 329 #if BOOST_WAVE_DUMP_PARSE_TREE != 0 && !defined(BOOST_WAVE_DUMP_PARSE_TREE_OUT) 330 #define BOOST_WAVE_DUMP_PARSE_TREE_OUT std::cerr 331 #endif 332 333 /////////////////////////////////////////////////////////////////////////////// 334 // 335 // For all #if and #elif directives the preprocessed expressions are printed. 336 // These expressions are streamed to the std::ostream defined by the 337 // BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS_OUT constant. 338 // 339 // To enable the output of the preprocessed expressions, define the following 340 // constant as something not equal to zero before including this file. 341 // 342 #if !defined(BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS) 343 #define BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS 0 344 #endif 345 #if BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS != 0 && \ 346 !defined(BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS_OUT) 347 #define BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS_OUT std::cerr 348 #endif 349 350 /////////////////////////////////////////////////////////////////////////////// 351 // Decide, whether to use the separate compilation model for the instantiation 352 // of the C++ lexer objects. 353 // 354 // If this is defined, you should explicitly instantiate the C++ lexer 355 // template with the correct parameters in a separate compilation unit of 356 // your program (see the file instantiate_re2c_lexer.cpp). 357 // 358 // To use the lexer inclusion model, define the following constant as 359 // something not equal to zero before including this file. 360 // 361 #if !defined(BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION) 362 #define BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION 1 363 #endif 364 365 /////////////////////////////////////////////////////////////////////////////// 366 // Decide, whether to use the separate compilation model for the instantiation 367 // of the grammar objects. 368 // 369 // If this is defined, you should explicitly instantiate the grammar 370 // templates with the correct parameters in a separate compilation unit of 371 // your program (see the files instantiate_cpp_grammar.cpp et.al.). 372 // 373 // To use the grammar inclusion model, define the following constant as 374 // something not equal to zero before including this file. 375 // 376 #if !defined(BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION) 377 #define BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION 1 378 #endif 379 380 /////////////////////////////////////////////////////////////////////////////// 381 // Decide whether to use a strict C++ lexer. 382 // 383 // If this is defined to something != 0, then the C++ lexers recognize the 384 // strict C99/C++ basic source character set. If it is not defined or defined 385 // to zero, the C++ lexers recognize the '$' character as part of identifiers. 386 // 387 // The default is to recognize the '$' character as part of identifiers. 388 // 389 #if !defined(BOOST_WAVE_USE_STRICT_LEXER) 390 #define BOOST_WAVE_USE_STRICT_LEXER 0 391 #endif 392 393 /////////////////////////////////////////////////////////////////////////////// 394 // Decide, whether the serialization of the wave::context class should be 395 // supported 396 // 397 // If this is defined to something not equal to zero the generated code will 398 // expose routines allowing to store and reload the internal state of the 399 // wave::context object. 400 // 401 // To enable the availability of the serialization functionality, define the 402 // following constant as something not equal to zero before including this file. 403 // 404 #if !defined(BOOST_WAVE_SERIALIZATION) 405 #define BOOST_WAVE_SERIALIZATION 0 406 #endif 407 408 /////////////////////////////////////////////////////////////////////////////// 409 // Decide, whether the import keyword is recognized as such 410 // 411 // If this is defined to something not equal to zero the Wave will recognize 412 // import as a keyword (T_IMPORT token id) 413 // 414 #if !defined(BOOST_WAVE_SUPPORT_IMPORT_KEYWORD) 415 #define BOOST_WAVE_SUPPORT_IMPORT_KEYWORD 0 416 #endif 417 418 /////////////////////////////////////////////////////////////////////////////// 419 // Decide, whether to support long long integers in the preprocessor. 420 // 421 // The C++ standard requires the preprocessor to use one of the following 422 // types for integer literals: long or unsigned long depending on an optional 423 // suffix ('u', 'l', 'ul', or 'lu') 424 // 425 // Sometimes it's required to preprocess integer literals bigger than that 426 // (i.e. long long or unsigned long long). In this case you need to define the 427 // BOOST_WAVE_SUPPORT_LONGLONG_INTEGER_LITERALS to something not equal to zero. 428 // 429 // This pp constant is effective only, if your target platform supports 430 // long long integers (BOOST_HAS_LONG_LONG is defined). 431 // 432 // Please note, that this setting doesn't relate to the Wave support option 433 // support_option_long_long, which enables the recognition of 'll' suffixes 434 // only. 435 // 436 // Defining this pp constant enables the recognition of long long integers 437 // even if these do not have the 'll' suffix. 438 // 439 #if !defined(BOOST_WAVE_SUPPORT_LONGLONG_INTEGER_LITERALS) 440 #define BOOST_WAVE_SUPPORT_LONGLONG_INTEGER_LITERALS 0 441 #endif 442 443 namespace boost { namespace wave 444 { 445 #if defined(BOOST_HAS_LONG_LONG) && \ 446 BOOST_WAVE_SUPPORT_LONGLONG_INTEGER_LITERALS != 0 447 typedef boost::long_long_type int_literal_type; 448 typedef boost::ulong_long_type uint_literal_type; 449 #else 450 typedef long int_literal_type; 451 typedef unsigned long uint_literal_type; 452 #endif 453 }} 454 455 /////////////////////////////////////////////////////////////////////////////// 456 // On some platforms Wave will not be able to properly detect whether wchar_t 457 // is representing a signed or unsigned integral data type. Use the 458 // configuration constants below to force wchar_t being signed or unsigned, as 459 // appropriate. 460 // 461 // The default is to use std::numeric_limits<wchar_t>::is_signed. 462 463 #define BOOST_WAVE_WCHAR_T_AUTOSELECT 1 464 #define BOOST_WAVE_WCHAR_T_FORCE_SIGNED 2 465 #define BOOST_WAVE_WCHAR_T_FORCE_UNSIGNED 3 466 467 #if !defined(BOOST_WAVE_WCHAR_T_SIGNEDNESS) 468 #define BOOST_WAVE_WCHAR_T_SIGNEDNESS BOOST_WAVE_WCHAR_T_AUTOSELECT 469 #endif 470 471 /////////////////////////////////////////////////////////////////////////////// 472 // Wave needs at least 4 parameters for phoenix actors 473 #if !defined(PHOENIX_LIMIT) 474 #define PHOENIX_LIMIT 6 475 #endif 476 #if PHOENIX_LIMIT < 6 477 // boost/home/classic/spirit/classic_attribute.hpp sets PHOENIX_LIMIT to 3! 478 #error "Boost.Wave: the constant PHOENIX_LIMIT must be at least defined to 6" \ 479 " to compile the library." 480 #endif 481 482 /////////////////////////////////////////////////////////////////////////////// 483 // Set up dll import/export options 484 #if (defined(BOOST_WAVE_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)) && \ 485 !defined(BOOST_WAVE_STATIC_LINK) 486 487 #if defined(BOOST_WAVE_SOURCE) 488 #define BOOST_WAVE_DECL BOOST_SYMBOL_EXPORT 489 #define BOOST_WAVE_BUILD_DLL 490 #else 491 #define BOOST_WAVE_DECL BOOST_SYMBOL_IMPORT 492 #endif 493 494 #endif // building a shared library 495 496 #ifndef BOOST_WAVE_DECL 497 #define BOOST_WAVE_DECL 498 #endif 499 500 /////////////////////////////////////////////////////////////////////////////// 501 // Auto library naming 502 #if BOOST_VERSION >= 103100 503 // auto link features work beginning from Boost V1.31.0 504 #if !defined(BOOST_WAVE_SOURCE) && !defined(BOOST_ALL_NO_LIB) && \ 505 !defined(BOOST_WAVE_NO_LIB) 506 507 #define BOOST_LIB_NAME boost_wave 508 509 // tell the auto-link code to select a dll when required: 510 #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_WAVE_DYN_LINK) 511 #define BOOST_DYN_LINK 512 #endif 513 514 #include <boost/config/auto_link.hpp> 515 516 #endif // auto-linking disabled 517 #endif // BOOST_VERSION 518 519 /////////////////////////////////////////////////////////////////////////////// 520 // Deprecate C++03 521 /////////////////////////////////////////////////////////////////////////////// 522 523 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_NO_CXX11_RVALUE_REFERENCES) \ 524 || defined(BOOST_NO_CXX11_HDR_MEMORY) || defined(BOOST_NO_CXX11_HDR_THREAD) \ 525 || defined(BOOST_NO_CXX11_HDR_MUTEX) || defined(BOOST_NO_CXX11_HDR_REGEX) 526 527 BOOST_PRAGMA_MESSAGE("C++03 support is deprecated in Boost.Wave 1.74 and will be removed in Boost.Wave 1.77.") 528 529 #endif 530 531 /////////////////////////////////////////////////////////////////////////////// 532 // Compatibility macros 533 // (ensure interface compatibility to older Wave versions) 534 /////////////////////////////////////////////////////////////////////////////// 535 536 /////////////////////////////////////////////////////////////////////////////// 537 // The preprocessing hook signatures changed after the Boost V1.34.0 release 538 // 539 // To use the preprocessing hook signatures as released with Boost V1.34.0 540 // you need to define the BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS 541 // constant to something not equal zero. 542 // 543 // To force using the new interface define this constant to zero. 544 // 545 #if !defined(BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS) 546 #if BOOST_VERSION < 103500 // before Boost V1.35.0 547 #define BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS 1 548 #else 549 #define BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS 0 550 #endif 551 #elif BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS != 0 552 BOOST_PRAGMA_MESSAGE("The old preprocessing hooks were deprecated in Boost 1.35 and will be removed in 1.76. See https://www.boost.org/doc/libs/1_74_0/libs/wave/doc/class_ref_ctxpolicy_depr.html for details") 553 #endif 554 555 #endif // !defined(BOOST_WAVE_CONFIG_HPP_F143F90A_A63F_4B27_AC41_9CA4F14F538D_INCLUDED) 556