[ceph.git] / ceph / src / boost / libs / wave / include / boost / wave / wave_config.hpp

/*=============================================================================
    Boost.Wave: A Standard compliant C++ preprocessor library

    Global application configuration
    
    http://www.boost.org/

    Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost
    Software License, Version 1.0. (See accompanying file
    LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/

#if !defined(WAVE_CONFIG_HPP_F143F90A_A63F_4B27_AC41_9CA4F14F538D_INCLUDED)
#define WAVE_CONFIG_HPP_F143F90A_A63F_4B27_AC41_9CA4F14F538D_INCLUDED

#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/version.hpp>
#include <boost/spirit/include/classic_version.hpp>
#include <boost/wave/wave_version.hpp>

///////////////////////////////////////////////////////////////////////////////
//  Define the maximal include nesting depth allowed. If this value isn't 
//  defined it defaults to 1024
//
//  To define a new initial include nesting define the following constant 
//  before including this file.
//
#if !defined(BOOST_WAVE_MAX_INCLUDE_LEVEL_DEPTH)
#define BOOST_WAVE_MAX_INCLUDE_LEVEL_DEPTH 1024
#endif

///////////////////////////////////////////////////////////////////////////////
//  Decide, whether to support variadics and placemarkers
//
//  To implement support variadics and placemarkers define the following to 
//  something not equal to zero.
//
#if !defined(BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS)
#define BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 1
#endif

///////////////////////////////////////////////////////////////////////////////
//  Decide, whether to implement a #warning directive as an extension to the 
//  C++ Standard (same as #error, but emits a warning, not an error)
//
//  To disable the implementation of #warning directives, define the following 
//  constant as zero before including this file.
//
#if !defined(BOOST_WAVE_SUPPORT_WARNING_DIRECTIVE)
#define BOOST_WAVE_SUPPORT_WARNING_DIRECTIVE 1
#endif

///////////////////////////////////////////////////////////////////////////////
//  Decide, whether to implement #pragma once 
//
//  To disable the implementation of #pragma once, define the following 
//  constant as zero before including this file.
//
#if !defined(BOOST_WAVE_SUPPORT_PRAGMA_ONCE)
#define BOOST_WAVE_SUPPORT_PRAGMA_ONCE 1
#endif

///////////////////////////////////////////////////////////////////////////////
//  Decide, whether to implement #pragma message("") 
//
//  To disable the implementation of #pragma message(""), define the following 
//  constant as zero before including this file.
//
#if !defined(BOOST_WAVE_SUPPORT_PRAGMA_MESSAGE)
#define BOOST_WAVE_SUPPORT_PRAGMA_MESSAGE 1
#endif

///////////////////////////////////////////////////////////////////////////////
//  Decide, whether to implement #include_next
//  Please note, that this is an extension to the C++ Standard.
//
//  To disable the implementation of #include_next, define the following 
//  constant as zero before including this file.
//
#if !defined(BOOST_WAVE_SUPPORT_INCLUDE_NEXT)
#define BOOST_WAVE_SUPPORT_INCLUDE_NEXT 1
#endif

///////////////////////////////////////////////////////////////////////////////
//  Decide, whether to support C++11
//
//  To implement C++11 keywords and preprocessor semantics define the following 
//  to something not equal to zero.
//
#if !defined(BOOST_WAVE_SUPPORT_CPP0X)
#define BOOST_WAVE_SUPPORT_CPP0X 1
#undef BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS
#define BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 1
#endif

///////////////////////////////////////////////////////////////////////////////
//  Undefine the following, to enable some MS specific language extensions:
//  __int8, __int16, __int32, __int64, __based, __declspec, __cdecl, 
//  __fastcall, __stdcall, __try, __except, __finally, __leave, __inline,
//  __asm, #region, #endregion
//
//  Note: By default this is enabled for Windows based systems, otherwise it's 
//        disabled.
#if !defined(BOOST_WAVE_SUPPORT_MS_EXTENSIONS)
#if defined(BOOST_WINDOWS)
#define BOOST_WAVE_SUPPORT_MS_EXTENSIONS 1
#else
#define BOOST_WAVE_SUPPORT_MS_EXTENSIONS 0
#endif
#endif

///////////////////////////////////////////////////////////////////////////////
//  Allow the message body of the #error and #warning directives to be 
//  preprocessed before the diagnostic is issued.
//
//  To disable preprocessing of the body of #error and #warning directives, 
//  define the following constant as zero before including this file.
//
#if !defined(BOOST_WAVE_PREPROCESS_ERROR_MESSAGE_BODY)
#define BOOST_WAVE_PREPROCESS_ERROR_MESSAGE_BODY 1
#endif

///////////////////////////////////////////////////////////////////////////////
//  Allow the #pragma directives to be returned to the caller (optionally after 
//  preprocessing the body) 
//
//  To disable the library to emit unknown #pragma directives, define the 
//  following constant as zero before including this file.
//
#if !defined(BOOST_WAVE_EMIT_PRAGMA_DIRECTIVES)
#define BOOST_WAVE_EMIT_PRAGMA_DIRECTIVES 1
#endif

///////////////////////////////////////////////////////////////////////////////
//  Allow the body of a #pragma directive to be preprocessed before the 
//  directive is returned to the caller.
//
//  To disable the preprocessing of the body of #pragma directives, define the 
//  following constant as zero before including this file.
//
#if !defined(BOOST_WAVE_PREPROCESS_PRAGMA_BODY)
#define BOOST_WAVE_PREPROCESS_PRAGMA_BODY 1
#endif

///////////////////////////////////////////////////////////////////////////////
//  Allow to define macros with the command line syntax (-DMACRO(x)=definition)
//
//  To disable the possibility to define macros based on the command line 
//  syntax, define the following constant as zero before including this file.
//
#if !defined(BOOST_WAVE_ENABLE_COMMANDLINE_MACROS)
#define BOOST_WAVE_ENABLE_COMMANDLINE_MACROS 1
#endif

///////////////////////////////////////////////////////////////////////////////
//  Define the pragma keyword to be used by the library to recognize its own
//  pragma's. If nothing else is defined, then 'wave' will be used as the 
//  default keyword, i.e. the library recognizes all 
//
//      #pragma wave option [(argument)]
//
//  and dispatches the handling to the interpret_pragma() preprocessing hook 
//  function (see file: preprocessing_hooks.hpp). The arguments part of the
//  pragma is optional.
//  The BOOST_WAVE_PRAGMA_KEYWORD constant needs to be defined to
//  resolve as a string literal value.
#if !defined(BOOST_WAVE_PRAGMA_KEYWORD)
#define BOOST_WAVE_PRAGMA_KEYWORD "wave"
#endif 

///////////////////////////////////////////////////////////////////////////////
//  Configure Wave thread support, Boost.Spirit and Boost.Pool are configured 
//  based on these settings automatically
//
//  If BOOST_WAVE_SUPPORT_THREADING is not defined, Wave will use the global 
//  Boost build settings (BOOST_HAS_THREADS), if it is defined its value
//  defines, whether threading will be enabled or not (should be set to '0' 
//  or '1').
#if !defined(BOOST_WAVE_SUPPORT_THREADING)
#if defined(BOOST_HAS_THREADS)
#define BOOST_WAVE_SUPPORT_THREADING 1
#else
#define BOOST_WAVE_SUPPORT_THREADING 0
#endif
#endif

#if BOOST_WAVE_SUPPORT_THREADING != 0 
#define BOOST_SPIRIT_THREADSAFE 1
#define PHOENIX_THREADSAFE 1
#else
// disable thread support in Boost.Pool
#define BOOST_NO_MT 1
#endif

///////////////////////////////////////////////////////////////////////////////
//  Define the string type to be used to store the token values and the file 
//  names inside a file_position template class
//
#if !defined(BOOST_WAVE_STRINGTYPE)

// VC7 isn't able to compile the flex_string class, fall back to std::string 
// CW up to 8.3 chokes as well *sigh*
// Tru64/CXX has linker problems when using flex_string
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || \
    BOOST_WORKAROUND(__MWERKS__, < 0x3200) || \
    (defined(__DECCXX) && defined(__alpha)) || \
    defined(BOOST_WAVE_STRINGTYPE_USE_STDSTRING) 

#define BOOST_WAVE_STRINGTYPE std::string

#if !defined(BOOST_WAVE_STRINGTYPE_USE_STDSTRING)
#define BOOST_WAVE_STRINGTYPE_USE_STDSTRING 1
#endif

#else

// use the following, if you have a fast std::allocator<char>
#define BOOST_WAVE_STRINGTYPE boost::wave::util::flex_string<                 \
        char, std::char_traits<char>, std::allocator<char>,                   \
        boost::wave::util::CowString<                                         \
            boost::wave::util::AllocatorStringStorage<char>                   \
        >                                                                     \
    >                                                                         \
    /**/
    
//  This include is needed for the flex_string class used in the 
//  BOOST_WAVE_STRINGTYPE above.
#include <boost/wave/util/flex_string.hpp>

#endif // BOOST_WORKAROUND(_MSC_VER, <= 1300) et.al.
#endif // !defined(BOOST_WAVE_STRINGTYPE)

///////////////////////////////////////////////////////////////////////////////
//  The following definition forces the Spirit tree code to use list's instead
//  of vectors, which may be more efficient on some platforms
// #define BOOST_SPIRIT_USE_LIST_FOR_TREES

///////////////////////////////////////////////////////////////////////////////
//  The following definition forces the Spirit tree code to use boost pool 
//  allocators instead of the std::allocator for the vector/list's.
// #define BOOST_SPIRIT_USE_BOOST_ALLOCATOR_FOR_TREES

///////////////////////////////////////////////////////////////////////////////
//  Uncomment the following, if you need debug output, the 
//  BOOST_SPIRIT_DEBUG_FLAGS_CPP constants below help to fine control the 
//  amount of the generated debug output.
//#define BOOST_SPIRIT_DEBUG

///////////////////////////////////////////////////////////////////////////////
//  Debug flags for the Wave library, possible flags specified below.
//
//  Note: These flags take effect only if the BOOST_SPIRIT_DEBUG constant
//        above is defined as well.
#define BOOST_SPIRIT_DEBUG_FLAGS_CPP_GRAMMAR            0x0001
#define BOOST_SPIRIT_DEBUG_FLAGS_TIME_CONVERSION        0x0002
#define BOOST_SPIRIT_DEBUG_FLAGS_CPP_EXPR_GRAMMAR       0x0004
#define BOOST_SPIRIT_DEBUG_FLAGS_INTLIT_GRAMMAR         0x0008
#define BOOST_SPIRIT_DEBUG_FLAGS_CHLIT_GRAMMAR          0x0010
#define BOOST_SPIRIT_DEBUG_FLAGS_DEFINED_GRAMMAR        0x0020
#define BOOST_SPIRIT_DEBUG_FLAGS_PREDEF_MACROS_GRAMMAR  0x0040

#if !defined(BOOST_SPIRIT_DEBUG_FLAGS_CPP)
#define BOOST_SPIRIT_DEBUG_FLAGS_CPP    0    // default is no debugging
#endif 

///////////////////////////////////////////////////////////////////////////////
//
//  For all recognized preprocessor statements the output parse trees 
//  formatted as xml are printed. The formatted parse trees are streamed to the 
//  std::ostream defined by the WAVE_DUMP_PARSE_TREE_OUT constant.
//
//  To enable the output of these parse trees, define the following constant 
//  as zero something not equal to zero before including this file. 
//
#if !defined(BOOST_WAVE_DUMP_PARSE_TREE)
#define BOOST_WAVE_DUMP_PARSE_TREE 0
#endif
#if BOOST_WAVE_DUMP_PARSE_TREE != 0 && !defined(BOOST_WAVE_DUMP_PARSE_TREE_OUT)
#define BOOST_WAVE_DUMP_PARSE_TREE_OUT std::cerr
#endif

///////////////////////////////////////////////////////////////////////////////
//
//  For all #if and #elif directives the preprocessed expressions are printed.
//  These expressions are streamed to the std::ostream defined by the 
//  BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS_OUT constant.
//
//  To enable the output of the preprocessed expressions, define the following 
//  constant as something not equal to zero before including this file.
//
#if !defined(BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS)
#define BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS 0
#endif
#if BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS != 0 && \
   !defined(BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS_OUT)
#define BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS_OUT std::cerr
#endif

///////////////////////////////////////////////////////////////////////////////
//  Decide, whether to use the separate compilation model for the instantiation 
//  of the C++ lexer objects.
//
//  If this is defined, you should explicitly instantiate the C++ lexer
//  template with the correct parameters in a separate compilation unit of
//  your program (see the file instantiate_re2c_lexer.cpp). 
//
//  To use the lexer inclusion model, define the following constant as 
//  something not equal to zero before including this file.
//
#if !defined(BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION)
#define BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION 1
#endif

///////////////////////////////////////////////////////////////////////////////
//  Decide, whether to use the separate compilation model for the instantiation 
//  of the grammar objects.
//
//  If this is defined, you should explicitly instantiate the grammar
//  templates with the correct parameters in a separate compilation unit of
//  your program (see the files instantiate_cpp_grammar.cpp et.al.). 
//
//  To use the grammar inclusion model, define the following constant as 
//  something not equal to zero before including this file.
//
#if !defined(BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION)
#define BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION 1
#endif

///////////////////////////////////////////////////////////////////////////////
//  Decide whether to use a strict C++ lexer.
//  
//  If this is defined to something != 0, then the C++ lexers recognize the 
//  strict C99/C++ basic source character set. If it is not defined or defined 
//  to zero, the C++ lexers recognize the '$' character as part of identifiers.
//
//  The default is to recognize the '$' character as part of identifiers.
//
#if !defined(BOOST_WAVE_USE_STRICT_LEXER)
#define BOOST_WAVE_USE_STRICT_LEXER 0
#endif

///////////////////////////////////////////////////////////////////////////////
//  Decide, whether the serialization of the wave::context class should be 
//  supported
//
//  If this is defined to something not equal to zero the generated code will
//  expose routines allowing to store and reload the internal state of the 
//  wave::context object.
//
//  To enable the availability of the serialization functionality, define the 
//  following constant as something not equal to zero before including this file.
//
#if !defined(BOOST_WAVE_SERIALIZATION)
#define BOOST_WAVE_SERIALIZATION 0
#endif

///////////////////////////////////////////////////////////////////////////////
//  Decide, whether the import keyword is recognized as such
//
//  If this is defined to something not equal to zero the Wave will recognize
//  import as a keyword (T_IMPORT token id)
//
#if !defined(BOOST_WAVE_SUPPORT_IMPORT_KEYWORD)
#define BOOST_WAVE_SUPPORT_IMPORT_KEYWORD 0
#endif

///////////////////////////////////////////////////////////////////////////////
//  Decide, whether to support long long integers in the preprocessor.
//
//  The C++ standard requires the preprocessor to use one of the following 
//  types for integer literals: long or unsigned long depending on an optional 
//  suffix ('u', 'l', 'ul', or 'lu')
//
//  Sometimes it's required to preprocess integer literals bigger than that
//  (i.e. long long or unsigned long long). In this case you need to define the 
//  BOOST_WAVE_SUPPORT_LONGLONG_INTEGER_LITERALS to something not equal to zero.
//
//  This pp constant is effective only, if your target platform supports 
//  long long integers (BOOST_HAS_LONG_LONG is defined).
//
//  Please note, that this setting doesn't relate to the Wave support option
//  support_option_long_long, which enables the recognition of 'll' suffixes 
//  only.
//
//  Defining this pp constant enables the recognition of long long integers
//  even if these do not have the 'll' suffix.
//
#if !defined(BOOST_WAVE_SUPPORT_LONGLONG_INTEGER_LITERALS)
#define BOOST_WAVE_SUPPORT_LONGLONG_INTEGER_LITERALS 0
#endif

namespace boost { namespace wave 
{
#if defined(BOOST_HAS_LONG_LONG) && \
    BOOST_WAVE_SUPPORT_LONGLONG_INTEGER_LITERALS != 0
    typedef boost::long_long_type int_literal_type;
    typedef boost::ulong_long_type uint_literal_type;
#else
    typedef long int_literal_type;
    typedef unsigned long uint_literal_type;
#endif
}}

///////////////////////////////////////////////////////////////////////////////
//  On some platforms Wave will not be able to properly detect whether wchar_t
//  is representing a signed or unsigned integral data type. Use the 
//  configuration constants below to force wchar_t being signed or unsigned, as
//  appropriate.
//
//  The default is to use std::numeric_limits<wchar_t>::is_signed.

#define BOOST_WAVE_WCHAR_T_AUTOSELECT       1
#define BOOST_WAVE_WCHAR_T_FORCE_SIGNED     2
#define BOOST_WAVE_WCHAR_T_FORCE_UNSIGNED   3

#if !defined(BOOST_WAVE_WCHAR_T_SIGNEDNESS)
#define BOOST_WAVE_WCHAR_T_SIGNEDNESS BOOST_WAVE_WCHAR_T_AUTOSELECT
#endif

///////////////////////////////////////////////////////////////////////////////
//  Wave needs at least 4 parameters for phoenix actors
#if !defined(PHOENIX_LIMIT)
#define PHOENIX_LIMIT 6
#endif
#if PHOENIX_LIMIT < 6
// boost/home/classic/spirit/classic_attribute.hpp sets PHOENIX_LIMIT to 3! 
#error "Boost.Wave: the constant PHOENIX_LIMIT must be at least defined to 6" \
" to compile the library."
#endif

///////////////////////////////////////////////////////////////////////////////
//  Set up dll import/export options
#if (defined(BOOST_WAVE_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)) && \
    !defined(BOOST_WAVE_STATIC_LINK)
    
#if defined(BOOST_WAVE_SOURCE)
#define BOOST_WAVE_DECL BOOST_SYMBOL_EXPORT 
#define BOOST_WAVE_BUILD_DLL
#else
#define BOOST_WAVE_DECL BOOST_SYMBOL_IMPORT 
#endif

#endif // building a shared library

#ifndef BOOST_WAVE_DECL
#define BOOST_WAVE_DECL
#endif

///////////////////////////////////////////////////////////////////////////////
//  Auto library naming
#if BOOST_VERSION >= 103100   
// auto link features work beginning from Boost V1.31.0
#if !defined(BOOST_WAVE_SOURCE) && !defined(BOOST_ALL_NO_LIB) && \
    !defined(BOOST_WAVE_NO_LIB)

#define BOOST_LIB_NAME boost_wave

// tell the auto-link code to select a dll when required:
#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_WAVE_DYN_LINK)
#define BOOST_DYN_LINK
#endif

#include <boost/config/auto_link.hpp>

#endif  // auto-linking disabled
#endif  // BOOST_VERSION

///////////////////////////////////////////////////////////////////////////////
//  Compatibility macros 
//  (ensure interface compatibility to older Wave versions)
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////
//  The preprocessing hook signatures changed after the Boost V1.34.0 release
//
//  To use the preprocessing hook signatures as released with Boost V1.34.0 
//  you need to define the BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS 
//  constant to something not equal zero.
//
//  To force using the new interface define this constant to zero.
//
#if !defined(BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS)
#if BOOST_VERSION < 103500  // before Boost V1.35.0
#define BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS 1
#else
#define BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS 0
#endif
#endif

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