EIC code displayed by LXR |
|
|
|
|||
File indexing completed on 2025-01-18 09:53:44
0001 /*============================================================================= 0002 Boost.Wave: A Standard compliant C++ preprocessor library 0003 0004 Global application configuration 0005 0006 http://www.boost.org/ 0007 0008 Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost 0009 Software License, Version 1.0. (See accompanying file 0010 LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 0011 =============================================================================*/ 0012 0013 #if !defined(BOOST_WAVE_CONFIG_HPP_F143F90A_A63F_4B27_AC41_9CA4F14F538D_INCLUDED) 0014 #define BOOST_WAVE_CONFIG_HPP_F143F90A_A63F_4B27_AC41_9CA4F14F538D_INCLUDED 0015 0016 #include <boost/config.hpp> 0017 #include <boost/config/pragma_message.hpp> 0018 #include <boost/detail/workaround.hpp> 0019 #include <boost/version.hpp> 0020 #include <boost/spirit/include/classic_version.hpp> 0021 #include <boost/wave/wave_version.hpp> 0022 0023 /////////////////////////////////////////////////////////////////////////////// 0024 // Define the maximal include nesting depth allowed. If this value isn't 0025 // defined it defaults to 1024 0026 // 0027 // To define a new initial include nesting define the following constant 0028 // before including this file. 0029 // 0030 #if !defined(BOOST_WAVE_MAX_INCLUDE_LEVEL_DEPTH) 0031 #define BOOST_WAVE_MAX_INCLUDE_LEVEL_DEPTH 1024 0032 #endif 0033 0034 /////////////////////////////////////////////////////////////////////////////// 0035 // Decide, whether to support variadics and placemarkers 0036 // 0037 // To implement support variadics and placemarkers define the following to 0038 // something not equal to zero. 0039 // 0040 #if !defined(BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS) 0041 #define BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 1 0042 #endif 0043 0044 /////////////////////////////////////////////////////////////////////////////// 0045 // Decide whether to support the C++20 __VA_OPT__ variadics feature 0046 // 0047 // 0048 #if !defined(BOOST_WAVE_SUPPORT_VA_OPT) && BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 0049 #define BOOST_WAVE_SUPPORT_VA_OPT 1 0050 #endif 0051 0052 /////////////////////////////////////////////////////////////////////////////// 0053 // Decide, whether to implement a #warning directive as an extension to the 0054 // C++ Standard (same as #error, but emits a warning, not an error) 0055 // 0056 // To disable the implementation of #warning directives, define the following 0057 // constant as zero before including this file. 0058 // 0059 #if !defined(BOOST_WAVE_SUPPORT_WARNING_DIRECTIVE) 0060 #define BOOST_WAVE_SUPPORT_WARNING_DIRECTIVE 1 0061 #endif 0062 0063 /////////////////////////////////////////////////////////////////////////////// 0064 // Decide, whether to implement #pragma once 0065 // 0066 // To disable the implementation of #pragma once, define the following 0067 // constant as zero before including this file. 0068 // 0069 #if !defined(BOOST_WAVE_SUPPORT_PRAGMA_ONCE) 0070 #define BOOST_WAVE_SUPPORT_PRAGMA_ONCE 1 0071 #endif 0072 0073 /////////////////////////////////////////////////////////////////////////////// 0074 // Decide, whether to implement #pragma message("") 0075 // 0076 // To disable the implementation of #pragma message(""), define the following 0077 // constant as zero before including this file. 0078 // 0079 #if !defined(BOOST_WAVE_SUPPORT_PRAGMA_MESSAGE) 0080 #define BOOST_WAVE_SUPPORT_PRAGMA_MESSAGE 1 0081 #endif 0082 0083 /////////////////////////////////////////////////////////////////////////////// 0084 // Decide, whether to implement #include_next 0085 // Please note, that this is an extension to the C++ Standard. 0086 // 0087 // To disable the implementation of #include_next, define the following 0088 // constant as zero before including this file. 0089 // 0090 #if !defined(BOOST_WAVE_SUPPORT_INCLUDE_NEXT) 0091 #define BOOST_WAVE_SUPPORT_INCLUDE_NEXT 1 0092 #endif 0093 0094 /////////////////////////////////////////////////////////////////////////////// 0095 // Decide, whether to support C++11 0096 // 0097 // To implement C++11 keywords and preprocessor semantics define the following 0098 // to something not equal to zero. 0099 // 0100 #if !defined(BOOST_WAVE_SUPPORT_CPP0X) 0101 #define BOOST_WAVE_SUPPORT_CPP0X 1 0102 #undef BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 0103 #define BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 1 0104 #endif 0105 0106 /////////////////////////////////////////////////////////////////////////////// 0107 // Decide whether to support C++17 0108 // 0109 #if !defined(BOOST_WAVE_SUPPORT_CPP1Z) 0110 # define BOOST_WAVE_SUPPORT_CPP1Z 1 0111 # undef BOOST_WAVE_SUPPORT_CPP0X 0112 # define BOOST_WAVE_SUPPORT_CPP0X 1 0113 # undef BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 0114 # define BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 1 0115 # if !defined(BOOST_WAVE_SUPPORT_HAS_INCLUDE) 0116 # define BOOST_WAVE_SUPPORT_HAS_INCLUDE 1 0117 # endif 0118 #elif BOOST_WAVE_SUPPORT_CPP1Z == 0 0119 # undef BOOST_WAVE_SUPPORT_HAS_INCLUDE 0120 # define BOOST_WAVE_SUPPORT_HAS_INCLUDE 0 0121 #endif 0122 0123 /////////////////////////////////////////////////////////////////////////////// 0124 // Decide whether to support C++20 0125 // 0126 #if !defined(BOOST_WAVE_SUPPORT_CPP2A) 0127 # define BOOST_WAVE_SUPPORT_CPP2A 1 0128 # undef BOOST_WAVE_SUPPORT_CPP0X 0129 # define BOOST_WAVE_SUPPORT_CPP0X 1 0130 # undef BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 0131 # define BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 1 0132 # undef BOOST_WAVE_SUPPORT_CPP1Z 0133 # define BOOST_WAVE_SUPPORT_CPP1Z 1 0134 # if !defined(BOOST_WAVE_SUPPORT_HAS_INCLUDE) 0135 # define BOOST_WAVE_SUPPORT_HAS_INCLUDE 1 0136 # endif 0137 # if !defined(BOOST_WAVE_SUPPORT_VA_OPT) 0138 # define BOOST_WAVE_SUPPORT_VA_OPT 1 0139 # endif 0140 #elif BOOST_WAVE_SUPPORT_CPP2A == 0 0141 # undef BOOST_WAVE_SUPPORT_VA_OPT 0142 # define BOOST_WAVE_SUPPORT_VA_OPT 0 0143 #endif 0144 0145 /////////////////////////////////////////////////////////////////////////////// 0146 // Undefine the following, to enable some MS specific language extensions: 0147 // __int8, __int16, __int32, __int64, __based, __declspec, __cdecl, 0148 // __fastcall, __stdcall, __try, __except, __finally, __leave, __inline, 0149 // __asm, #region, #endregion 0150 // 0151 // Note: By default this is enabled for Windows based systems, otherwise it's 0152 // disabled. 0153 #if !defined(BOOST_WAVE_SUPPORT_MS_EXTENSIONS) 0154 #if defined(BOOST_WINDOWS) 0155 #define BOOST_WAVE_SUPPORT_MS_EXTENSIONS 1 0156 #else 0157 #define BOOST_WAVE_SUPPORT_MS_EXTENSIONS 0 0158 #endif 0159 #endif 0160 0161 /////////////////////////////////////////////////////////////////////////////// 0162 // Allow the message body of the #error and #warning directives to be 0163 // preprocessed before the diagnostic is issued. 0164 // 0165 // To disable preprocessing of the body of #error and #warning directives, 0166 // define the following constant as zero before including this file. 0167 // 0168 #if !defined(BOOST_WAVE_PREPROCESS_ERROR_MESSAGE_BODY) 0169 #define BOOST_WAVE_PREPROCESS_ERROR_MESSAGE_BODY 1 0170 #endif 0171 0172 /////////////////////////////////////////////////////////////////////////////// 0173 // Allow the #pragma directives to be returned to the caller (optionally after 0174 // preprocessing the body) 0175 // 0176 // To disable the library to emit unknown #pragma directives, define the 0177 // following constant as zero before including this file. 0178 // 0179 #if !defined(BOOST_WAVE_EMIT_PRAGMA_DIRECTIVES) 0180 #define BOOST_WAVE_EMIT_PRAGMA_DIRECTIVES 1 0181 #endif 0182 0183 /////////////////////////////////////////////////////////////////////////////// 0184 // Allow the body of a #pragma directive to be preprocessed before the 0185 // directive is returned to the caller. 0186 // 0187 // To disable the preprocessing of the body of #pragma directives, define the 0188 // following constant as zero before including this file. 0189 // 0190 #if !defined(BOOST_WAVE_PREPROCESS_PRAGMA_BODY) 0191 #define BOOST_WAVE_PREPROCESS_PRAGMA_BODY 1 0192 #endif 0193 0194 /////////////////////////////////////////////////////////////////////////////// 0195 // Allow to define macros with the command line syntax (-DMACRO(x)=definition) 0196 // 0197 // To disable the possibility to define macros based on the command line 0198 // syntax, define the following constant as zero before including this file. 0199 // 0200 #if !defined(BOOST_WAVE_ENABLE_COMMANDLINE_MACROS) 0201 #define BOOST_WAVE_ENABLE_COMMANDLINE_MACROS 1 0202 #endif 0203 0204 /////////////////////////////////////////////////////////////////////////////// 0205 // Define the pragma keyword to be used by the library to recognize its own 0206 // pragma's. If nothing else is defined, then 'wave' will be used as the 0207 // default keyword, i.e. the library recognizes all 0208 // 0209 // #pragma wave option [(argument)] 0210 // 0211 // and dispatches the handling to the interpret_pragma() preprocessing hook 0212 // function (see file: preprocessing_hooks.hpp). The arguments part of the 0213 // pragma is optional. 0214 // The BOOST_WAVE_PRAGMA_KEYWORD constant needs to be defined to 0215 // resolve as a string literal value. 0216 #if !defined(BOOST_WAVE_PRAGMA_KEYWORD) 0217 #define BOOST_WAVE_PRAGMA_KEYWORD "wave" 0218 #endif 0219 0220 /////////////////////////////////////////////////////////////////////////////// 0221 // Configure Wave thread support, Boost.Spirit and Boost.Pool are configured 0222 // based on these settings automatically 0223 // 0224 // If BOOST_WAVE_SUPPORT_THREADING is not defined, Wave will use the global 0225 // Boost build settings (BOOST_HAS_THREADS), if it is defined its value 0226 // defines, whether threading will be enabled or not (should be set to '0' 0227 // or '1'). 0228 #if !defined(BOOST_WAVE_SUPPORT_THREADING) 0229 #if defined(BOOST_HAS_THREADS) 0230 #define BOOST_WAVE_SUPPORT_THREADING 1 0231 #else 0232 #define BOOST_WAVE_SUPPORT_THREADING 0 0233 #endif 0234 #endif 0235 0236 #if BOOST_WAVE_SUPPORT_THREADING != 0 0237 #ifndef BOOST_SPIRIT_THREADSAFE 0238 #define BOOST_SPIRIT_THREADSAFE 0239 #endif 0240 #define PHOENIX_THREADSAFE 1 0241 #else 0242 // disable thread support in Boost.Pool 0243 #define BOOST_NO_MT 1 0244 #endif 0245 0246 /////////////////////////////////////////////////////////////////////////////// 0247 // Define the string type to be used to store the token values and the file 0248 // names inside a file_position template class 0249 // 0250 #if !defined(BOOST_WAVE_STRINGTYPE) 0251 0252 // VC7 isn't able to compile the flex_string class, fall back to std::string 0253 // CW up to 8.3 chokes as well *sigh* 0254 // Tru64/CXX has linker problems when using flex_string 0255 #if BOOST_WORKAROUND(__MWERKS__, < 0x3200) || \ 0256 (defined(__DECCXX) && defined(__alpha)) || \ 0257 defined(BOOST_WAVE_STRINGTYPE_USE_STDSTRING) 0258 0259 #define BOOST_WAVE_STRINGTYPE std::string 0260 0261 #if !defined(BOOST_WAVE_STRINGTYPE_USE_STDSTRING) 0262 #define BOOST_WAVE_STRINGTYPE_USE_STDSTRING 1 0263 #endif 0264 0265 #else 0266 0267 // use the following, if you have a fast std::allocator<char> 0268 #define BOOST_WAVE_STRINGTYPE boost::wave::util::flex_string< \ 0269 char, std::char_traits<char>, std::allocator<char>, \ 0270 boost::wave::util::CowString< \ 0271 boost::wave::util::AllocatorStringStorage<char> \ 0272 > \ 0273 > \ 0274 /**/ 0275 0276 // This include is needed for the flex_string class used in the 0277 // BOOST_WAVE_STRINGTYPE above. 0278 #include <boost/wave/util/flex_string.hpp> 0279 0280 #endif // BOOST_WORKAROUND(__MWERKS__, < 0x3200) et.al. 0281 #endif // !defined(BOOST_WAVE_STRINGTYPE) 0282 0283 /////////////////////////////////////////////////////////////////////////////// 0284 // The following definition forces the Spirit tree code to use list's instead 0285 // of vectors, which may be more efficient on some platforms 0286 // #define BOOST_SPIRIT_USE_LIST_FOR_TREES 0287 0288 /////////////////////////////////////////////////////////////////////////////// 0289 // The following definition forces the Spirit tree code to use boost pool 0290 // allocators instead of the std::allocator for the vector/list's. 0291 // #define BOOST_SPIRIT_USE_BOOST_ALLOCATOR_FOR_TREES 0292 0293 /////////////////////////////////////////////////////////////////////////////// 0294 // Uncomment the following, if you need debug output, the 0295 // BOOST_SPIRIT_DEBUG_FLAGS_CPP constants below help to fine control the 0296 // amount of the generated debug output. 0297 //#define BOOST_SPIRIT_DEBUG 0298 0299 /////////////////////////////////////////////////////////////////////////////// 0300 // Debug flags for the Wave library, possible flags specified below. 0301 // 0302 // Note: These flags take effect only if the BOOST_SPIRIT_DEBUG constant 0303 // above is defined as well. 0304 #define BOOST_SPIRIT_DEBUG_FLAGS_CPP_GRAMMAR 0x0001 0305 #define BOOST_SPIRIT_DEBUG_FLAGS_TIME_CONVERSION 0x0002 0306 #define BOOST_SPIRIT_DEBUG_FLAGS_CPP_EXPR_GRAMMAR 0x0004 0307 #define BOOST_SPIRIT_DEBUG_FLAGS_INTLIT_GRAMMAR 0x0008 0308 #define BOOST_SPIRIT_DEBUG_FLAGS_CHLIT_GRAMMAR 0x0010 0309 #define BOOST_SPIRIT_DEBUG_FLAGS_DEFINED_GRAMMAR 0x0020 0310 #define BOOST_SPIRIT_DEBUG_FLAGS_PREDEF_MACROS_GRAMMAR 0x0040 0311 #define BOOST_SPIRIT_DEBUG_FLAGS_HAS_INCLUDE_GRAMMAR 0x0080 0312 0313 #if !defined(BOOST_SPIRIT_DEBUG_FLAGS_CPP) 0314 #define BOOST_SPIRIT_DEBUG_FLAGS_CPP 0 // default is no debugging 0315 #endif 0316 0317 /////////////////////////////////////////////////////////////////////////////// 0318 // 0319 // For all recognized preprocessor statements the output parse trees 0320 // formatted as xml are printed. The formatted parse trees are streamed to the 0321 // std::ostream defined by the WAVE_DUMP_PARSE_TREE_OUT constant. 0322 // 0323 // To enable the output of these parse trees, define the following constant 0324 // as zero something not equal to zero before including this file. 0325 // 0326 #if !defined(BOOST_WAVE_DUMP_PARSE_TREE) 0327 #define BOOST_WAVE_DUMP_PARSE_TREE 0 0328 #endif 0329 #if BOOST_WAVE_DUMP_PARSE_TREE != 0 && !defined(BOOST_WAVE_DUMP_PARSE_TREE_OUT) 0330 #define BOOST_WAVE_DUMP_PARSE_TREE_OUT std::cerr 0331 #endif 0332 0333 /////////////////////////////////////////////////////////////////////////////// 0334 // 0335 // For all #if and #elif directives the preprocessed expressions are printed. 0336 // These expressions are streamed to the std::ostream defined by the 0337 // BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS_OUT constant. 0338 // 0339 // To enable the output of the preprocessed expressions, define the following 0340 // constant as something not equal to zero before including this file. 0341 // 0342 #if !defined(BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS) 0343 #define BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS 0 0344 #endif 0345 #if BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS != 0 && \ 0346 !defined(BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS_OUT) 0347 #define BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS_OUT std::cerr 0348 #endif 0349 0350 /////////////////////////////////////////////////////////////////////////////// 0351 // Decide, whether to use the separate compilation model for the instantiation 0352 // of the C++ lexer objects. 0353 // 0354 // If this is defined, you should explicitly instantiate the C++ lexer 0355 // template with the correct parameters in a separate compilation unit of 0356 // your program (see the file instantiate_re2c_lexer.cpp). 0357 // 0358 // To use the lexer inclusion model, define the following constant as 0359 // something not equal to zero before including this file. 0360 // 0361 #if !defined(BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION) 0362 #define BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION 1 0363 #endif 0364 0365 /////////////////////////////////////////////////////////////////////////////// 0366 // Decide, whether to use the separate compilation model for the instantiation 0367 // of the grammar objects. 0368 // 0369 // If this is defined, you should explicitly instantiate the grammar 0370 // templates with the correct parameters in a separate compilation unit of 0371 // your program (see the files instantiate_cpp_grammar.cpp et.al.). 0372 // 0373 // To use the grammar inclusion model, define the following constant as 0374 // something not equal to zero before including this file. 0375 // 0376 #if !defined(BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION) 0377 #define BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION 1 0378 #endif 0379 0380 /////////////////////////////////////////////////////////////////////////////// 0381 // Decide whether to use a strict C++ lexer. 0382 // 0383 // If this is defined to something != 0, then the C++ lexers recognize the 0384 // strict C99/C++ basic source character set. If it is not defined or defined 0385 // to zero, the C++ lexers recognize the '$' character as part of identifiers. 0386 // 0387 // The default is to recognize the '$' character as part of identifiers. 0388 // 0389 #if !defined(BOOST_WAVE_USE_STRICT_LEXER) 0390 #define BOOST_WAVE_USE_STRICT_LEXER 0 0391 #endif 0392 0393 /////////////////////////////////////////////////////////////////////////////// 0394 // Decide, whether the serialization of the wave::context class should be 0395 // supported 0396 // 0397 // If this is defined to something not equal to zero the generated code will 0398 // expose routines allowing to store and reload the internal state of the 0399 // wave::context object. 0400 // 0401 // To enable the availability of the serialization functionality, define the 0402 // following constant as something not equal to zero before including this file. 0403 // 0404 #if !defined(BOOST_WAVE_SERIALIZATION) 0405 #define BOOST_WAVE_SERIALIZATION 0 0406 #endif 0407 0408 /////////////////////////////////////////////////////////////////////////////// 0409 // Decide, whether the import keyword is recognized as such 0410 // 0411 // If this is defined to something not equal to zero the Wave will recognize 0412 // import as a keyword (T_IMPORT token id) 0413 // 0414 #if !defined(BOOST_WAVE_SUPPORT_IMPORT_KEYWORD) 0415 #define BOOST_WAVE_SUPPORT_IMPORT_KEYWORD 0 0416 #endif 0417 0418 /////////////////////////////////////////////////////////////////////////////// 0419 // Decide, whether to support long long integers in the preprocessor. 0420 // 0421 // The C++ standard requires the preprocessor to use one of the following 0422 // types for integer literals: long or unsigned long depending on an optional 0423 // suffix ('u', 'l', 'ul', or 'lu') 0424 // 0425 // Sometimes it's required to preprocess integer literals bigger than that 0426 // (i.e. long long or unsigned long long). In this case you need to define the 0427 // BOOST_WAVE_SUPPORT_LONGLONG_INTEGER_LITERALS to something not equal to zero. 0428 // 0429 // This pp constant is effective only, if your target platform supports 0430 // long long integers (BOOST_HAS_LONG_LONG is defined). 0431 // 0432 // Please note, that this setting doesn't relate to the Wave support option 0433 // support_option_long_long, which enables the recognition of 'll' suffixes 0434 // only. 0435 // 0436 // Defining this pp constant enables the recognition of long long integers 0437 // even if these do not have the 'll' suffix. 0438 // 0439 #if !defined(BOOST_WAVE_SUPPORT_LONGLONG_INTEGER_LITERALS) 0440 #define BOOST_WAVE_SUPPORT_LONGLONG_INTEGER_LITERALS 0 0441 #endif 0442 0443 namespace boost { namespace wave 0444 { 0445 #if defined(BOOST_HAS_LONG_LONG) && \ 0446 BOOST_WAVE_SUPPORT_LONGLONG_INTEGER_LITERALS != 0 0447 typedef boost::long_long_type int_literal_type; 0448 typedef boost::ulong_long_type uint_literal_type; 0449 #else 0450 typedef long int_literal_type; 0451 typedef unsigned long uint_literal_type; 0452 #endif 0453 }} 0454 0455 /////////////////////////////////////////////////////////////////////////////// 0456 // On some platforms Wave will not be able to properly detect whether wchar_t 0457 // is representing a signed or unsigned integral data type. Use the 0458 // configuration constants below to force wchar_t being signed or unsigned, as 0459 // appropriate. 0460 // 0461 // The default is to use std::numeric_limits<wchar_t>::is_signed. 0462 0463 #define BOOST_WAVE_WCHAR_T_AUTOSELECT 1 0464 #define BOOST_WAVE_WCHAR_T_FORCE_SIGNED 2 0465 #define BOOST_WAVE_WCHAR_T_FORCE_UNSIGNED 3 0466 0467 #if !defined(BOOST_WAVE_WCHAR_T_SIGNEDNESS) 0468 #define BOOST_WAVE_WCHAR_T_SIGNEDNESS BOOST_WAVE_WCHAR_T_AUTOSELECT 0469 #endif 0470 0471 /////////////////////////////////////////////////////////////////////////////// 0472 // Wave needs at least 4 parameters for phoenix actors 0473 #if !defined(PHOENIX_LIMIT) 0474 #define PHOENIX_LIMIT 6 0475 #endif 0476 #if PHOENIX_LIMIT < 6 0477 // boost/home/classic/spirit/classic_attribute.hpp sets PHOENIX_LIMIT to 3! 0478 #error "Boost.Wave: the constant PHOENIX_LIMIT must be at least defined to 6" \ 0479 " to compile the library." 0480 #endif 0481 0482 /////////////////////////////////////////////////////////////////////////////// 0483 // Set up dll import/export options 0484 #if (defined(BOOST_WAVE_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)) && \ 0485 !defined(BOOST_WAVE_STATIC_LINK) 0486 0487 #if defined(BOOST_WAVE_SOURCE) 0488 #define BOOST_WAVE_DECL BOOST_SYMBOL_EXPORT 0489 #define BOOST_WAVE_BUILD_DLL 0490 #else 0491 #define BOOST_WAVE_DECL BOOST_SYMBOL_IMPORT 0492 #endif 0493 0494 #endif // building a shared library 0495 0496 #ifndef BOOST_WAVE_DECL 0497 #define BOOST_WAVE_DECL 0498 #endif 0499 0500 /////////////////////////////////////////////////////////////////////////////// 0501 // Auto library naming 0502 #if BOOST_VERSION >= 103100 0503 // auto link features work beginning from Boost V1.31.0 0504 #if !defined(BOOST_WAVE_SOURCE) && !defined(BOOST_ALL_NO_LIB) && \ 0505 !defined(BOOST_WAVE_NO_LIB) 0506 0507 #define BOOST_LIB_NAME boost_wave 0508 0509 // tell the auto-link code to select a dll when required: 0510 #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_WAVE_DYN_LINK) 0511 #define BOOST_DYN_LINK 0512 #endif 0513 0514 #include <boost/config/auto_link.hpp> 0515 0516 #endif // auto-linking disabled 0517 #endif // BOOST_VERSION 0518 0519 /////////////////////////////////////////////////////////////////////////////// 0520 // Deprecate C++03 0521 /////////////////////////////////////////////////////////////////////////////// 0522 0523 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_NO_CXX11_RVALUE_REFERENCES) \ 0524 || defined(BOOST_NO_CXX11_HDR_THREAD) \ 0525 || defined(BOOST_NO_CXX11_HDR_MUTEX) || defined(BOOST_NO_CXX11_HDR_REGEX) \ 0526 || defined(BOOST_NO_CXX11_CONSTEXPR) 0527 0528 #error "C++03 support is deprecated in Boost.Wave 1.74 and was removed in Boost.Wave 1.79." 0529 0530 #endif 0531 0532 /////////////////////////////////////////////////////////////////////////////// 0533 // Compatibility macros 0534 // (ensure interface compatibility to older Wave versions) 0535 /////////////////////////////////////////////////////////////////////////////// 0536 0537 /////////////////////////////////////////////////////////////////////////////// 0538 // The preprocessing hook signatures changed after the Boost V1.34.0 release 0539 // 0540 // The old hook signatures are no longer available as of Boost 1.76. 0541 // 0542 #if defined(BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS) && \ 0543 BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS != 0 0544 #error "The old preprocessing hooks were deprecated in Boost 1.35 and removed in 1.76." 0545 #endif 0546 0547 #endif // !defined(BOOST_WAVE_CONFIG_HPP_F143F90A_A63F_4B27_AC41_9CA4F14F538D_INCLUDED)
| [ Source navigation ] | [ Diff markup ] | [ Identifier search ] | [ general search ] |
|
This page was automatically generated by the 2.3.7 LXR engine. The LXR team |
|