ceph/src/boost/boost/wave/wave_config.hpp

   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_THREAD) \
 525     || defined(BOOST_NO_CXX11_HDR_MUTEX) || defined(BOOST_NO_CXX11_HDR_REGEX) \
 526     || defined(BOOST_NO_CXX11_CONSTEXPR)
 527
 528 #error "C++03 support is deprecated in Boost.Wave 1.74 and was removed in Boost.Wave 1.79."
 529
 530 #endif
 531
 532 ///////////////////////////////////////////////////////////////////////////////
 533 //  Compatibility macros
 534 //  (ensure interface compatibility to older Wave versions)
 535 ///////////////////////////////////////////////////////////////////////////////
 536
 537 ///////////////////////////////////////////////////////////////////////////////
 538 //  The preprocessing hook signatures changed after the Boost V1.34.0 release
 539 //
 540 //  The old hook signatures are no longer available as of Boost 1.76.
 541 //
 542 #if defined(BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS) && \
 543     BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS != 0
 544 #error "The old preprocessing hooks were deprecated in Boost 1.35 and removed in 1.76."
 545 #endif
 546
 547 #endif // !defined(BOOST_WAVE_CONFIG_HPP_F143F90A_A63F_4B27_AC41_9CA4F14F538D_INCLUDED)