1 /*=============================================================================
2 Boost.Wave: A Standard compliant C++ preprocessor library
4 Global application configuration
8 Copyright (c) 2001-2007 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 =============================================================================*/
13 #if !defined(WAVE_CONFIG_HPP_F143F90A_A63F_4B27_AC41_9CA4F14F538D_INCLUDED)
14 #define WAVE_CONFIG_HPP_F143F90A_A63F_4B27_AC41_9CA4F14F538D_INCLUDED
16 #include <boost/config.hpp>
17 #include <boost/detail/workaround.hpp>
18 #include <boost/version.hpp>
19 #include <boost/spirit/version.hpp>
20 #include <boost/wave/wave_version.hpp>
22 ///////////////////////////////////////////////////////////////////////////////
23 // Define the maximal include nesting depth allowed. If this value isn't
24 // defined it defaults to 1024
26 // To define a new initial include nesting define the following constant
27 // before including this file.
29 #if !defined(BOOST_WAVE_MAX_INCLUDE_LEVEL_DEPTH)
30 #define BOOST_WAVE_MAX_INCLUDE_LEVEL_DEPTH 1024
33 ///////////////////////////////////////////////////////////////////////////////
34 // Decide, whether to support variadics and placemarkers
36 // To implement support variadics and placemarkers define the following to
37 // something not equal to zero.
39 #if !defined(BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS)
40 #define BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS 1
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)
47 // To disable the implementation of #warning directives, define the following
48 // constant as zero before including this file.
50 #if !defined(BOOST_WAVE_SUPPORT_WARNING_DIRECTIVE)
51 #define BOOST_WAVE_SUPPORT_WARNING_DIRECTIVE 1
54 ///////////////////////////////////////////////////////////////////////////////
55 // Decide, whether to implement #pragma once
57 // To disable the implementation of #pragma once, define the following
58 // constant as zero before including this file.
60 #if !defined(BOOST_WAVE_SUPPORT_PRAGMA_ONCE)
61 #define BOOST_WAVE_SUPPORT_PRAGMA_ONCE 1
64 ///////////////////////////////////////////////////////////////////////////////
65 // Decide, whether to implement #pragma message("")
67 // To disable the implementation of #pragma message(""), define the following
68 // constant as zero before including this file.
70 #if !defined(BOOST_WAVE_SUPPORT_PRAGMA_MESSAGE)
71 #define BOOST_WAVE_SUPPORT_PRAGMA_MESSAGE 1
74 ///////////////////////////////////////////////////////////////////////////////
75 // Decide, whether to implement #include_next
76 // Please note, that this is an extension to the C++ Standard.
78 // To disable the implementation of #include_next, define the following
79 // constant as zero before including this file.
81 #if !defined(BOOST_WAVE_SUPPORT_INCLUDE_NEXT)
82 #define BOOST_WAVE_SUPPORT_INCLUDE_NEXT 1
85 ///////////////////////////////////////////////////////////////////////////////
86 // Undefine the following, to enable some MS specific language extensions:
87 // __int8, __int16, __int32, __int64, __based, __declspec, __cdecl,
88 // __fastcall, __stdcall, __try, __except, __finally, __leave, __inline,
89 // __asm, #region, #endregion
91 // Note: By default this is enabled for Windows based systems, otherwise it's
93 #if !defined(BOOST_WAVE_SUPPORT_MS_EXTENSIONS)
94 #if defined(BOOST_WINDOWS)
95 #define BOOST_WAVE_SUPPORT_MS_EXTENSIONS 1
97 #define BOOST_WAVE_SUPPORT_MS_EXTENSIONS 0
101 ///////////////////////////////////////////////////////////////////////////////
102 // Allow the message body of the #error and #warning directives to be
103 // preprocessed before the diagnostic is issued.
105 // To disable preprocessing of the body of #error and #warning directives,
106 // define the following constant as zero before including this file.
108 #if !defined(BOOST_WAVE_PREPROCESS_ERROR_MESSAGE_BODY)
109 #define BOOST_WAVE_PREPROCESS_ERROR_MESSAGE_BODY 1
112 ///////////////////////////////////////////////////////////////////////////////
113 // Allow the #pragma directives to be returned to the caller (optionally after
114 // preprocessing the body)
116 // To disable the library to emit unknown #pragma directives, define the
117 // following constant as zero before including this file.
119 #if !defined(BOOST_WAVE_EMIT_PRAGMA_DIRECTIVES)
120 #define BOOST_WAVE_EMIT_PRAGMA_DIRECTIVES 1
123 ///////////////////////////////////////////////////////////////////////////////
124 // Allow the body of a #pragma directive to be preprocessed before the
125 // directive is returned to the caller.
127 // To disable the preprocessing of the body of #pragma directives, define the
128 // following constant as zero before including this file.
130 #if !defined(BOOST_WAVE_PREPROCESS_PRAGMA_BODY)
131 #define BOOST_WAVE_PREPROCESS_PRAGMA_BODY 1
134 ///////////////////////////////////////////////////////////////////////////////
135 // Allow to define macros with the command line syntax (-DMACRO(x)=definition)
137 // To disable the the possibility to define macros based on the command line
138 // syntax, define the following constant as zero before including this file.
140 #if !defined(BOOST_WAVE_ENABLE_COMMANDLINE_MACROS)
141 #define BOOST_WAVE_ENABLE_COMMANDLINE_MACROS 1
144 ///////////////////////////////////////////////////////////////////////////////
145 // Define the pragma keyword to be used by the library to recognize its own
146 // pragma's. If nothing else is defined, then 'wave' will be used as the
147 // default keyword, i.e. the library recognizes all
149 // #pragma wave option [(argument)]
151 // and dispatches the handling to the interpret_pragma() preprocessing hook
152 // function (see file: preprocessing_hooks.hpp). The arguments part of the
153 // pragma is optional.
154 // The BOOST_WAVE_PRAGMA_KEYWORD constant needs to be defined to
155 // resolve as a string literal value.
156 #if !defined(BOOST_WAVE_PRAGMA_KEYWORD)
157 #define BOOST_WAVE_PRAGMA_KEYWORD "wave"
160 ///////////////////////////////////////////////////////////////////////////////
161 // Define the string type to be used to store the token values and the file
162 // names inside a file_position template class
164 #if !defined(BOOST_WAVE_STRINGTYPE)
166 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || \
167 BOOST_WORKAROUND(__MWERKS__, < 0x3200) || \
168 (defined(__DECCXX) && defined(__alpha)) || \
169 defined(BOOST_WAVE_STRINGTYPE_USE_STDSTRING)
171 // VC7 isn't able to compile the flex_string class, fall back to std::string
172 // CW up to 8.3 chokes as well *sigh*
173 // Tru64/CXX has linker problems when using flex_string
174 #define BOOST_WAVE_STRINGTYPE std::string
175 #if !defined(BOOST_WAVE_STRINGTYPE_USE_STDSTRING)
176 #define BOOST_WAVE_STRINGTYPE_USE_STDSTRING 1
180 // use the following, if you have a fast std::allocator<char>
181 #define BOOST_WAVE_STRINGTYPE boost::wave::util::flex_string< \
182 char, std::char_traits<char>, std::allocator<char>, \
183 boost::wave::util::CowString</*char, */\
184 boost::wave::util::AllocatorStringStorage<char> \
189 /* #define BOOST_WAVE_STRINGTYPE boost::wave::util::flex_string< \
190 char, std::char_traits<char>, boost::fast_pool_allocator<char>, \
191 boost::wave::util::CowString<char, \
192 boost::wave::util::AllocatorStringStorage<char, \
193 boost::fast_pool_allocator<char> \
199 // This include is needed for the flex_string class used in the
200 // BOOST_WAVE_STRINGTYPE above.
201 #include <boost/wave/util/flex_string.hpp>
203 // This include is needed for the boost::fast_allocator class used in the
204 // BOOST_WAVE_STRINGTYPE above.
205 // Configure Boost.Pool thread support (for now: no thread support at all)
206 //#define BOOST_NO_MT
207 //#include <boost/pool/pool_alloc.hpp>
209 // Use the following, if you want to incorporate Maxim Yegorushkin's
210 // const_string library (http://sourceforge.net/projects/conststring/), which
211 // may be even faster, than using the flex_string class from above
212 //#define BOOST_WAVE_STRINGTYPE boost::const_string<char>
214 //#include <boost/const_string/const_string.hpp>
215 //#include <boost/const_string/io.hpp>
216 //#include <boost/const_string/concatenation.hpp>
218 #endif // BOOST_WORKAROUND(_MSC_VER, <= 1300)
221 ///////////////////////////////////////////////////////////////////////////////
222 // The following definition forces the Spirit tree code to use list's instead
223 // of vectors, which may be more efficient on some platforms
224 // #define BOOST_SPIRIT_USE_LIST_FOR_TREES
226 ///////////////////////////////////////////////////////////////////////////////
227 // The following definition forces the Spirit tree code to use boost pool
228 // allocators in stead of the std::allocator for the vector/list's.
229 // #define BOOST_SPIRIT_USE_BOOST_ALLOCATOR_FOR_TREES
231 ///////////////////////////////////////////////////////////////////////////////
232 // Uncomment the following, if you need debug output, the
233 // BOOST_SPIRIT_DEBUG_FLAGS_CPP constants below help to fine control the
234 // amount of the generated debug output.
235 //#define BOOST_SPIRIT_DEBUG
237 ///////////////////////////////////////////////////////////////////////////////
238 // Debug flags for the Wave library, possible flags specified below.
240 // Note: These flags take effect only if the BOOST_SPIRIT_DEBUG constant
241 // above is defined as well.
242 #define BOOST_SPIRIT_DEBUG_FLAGS_CPP_GRAMMAR 0x0001
243 #define BOOST_SPIRIT_DEBUG_FLAGS_TIME_CONVERSION 0x0002
244 #define BOOST_SPIRIT_DEBUG_FLAGS_CPP_EXPR_GRAMMAR 0x0004
245 #define BOOST_SPIRIT_DEBUG_FLAGS_INTLIT_GRAMMAR 0x0008
246 #define BOOST_SPIRIT_DEBUG_FLAGS_CHLIT_GRAMMAR 0x0010
247 #define BOOST_SPIRIT_DEBUG_FLAGS_DEFINED_GRAMMAR 0x0020
248 #define BOOST_SPIRIT_DEBUG_FLAGS_PREDEF_MACROS_GRAMMAR 0x0040
250 #if !defined(BOOST_SPIRIT_DEBUG_FLAGS_CPP)
251 #define BOOST_SPIRIT_DEBUG_FLAGS_CPP 0 // default is no debugging
254 ///////////////////////////////////////////////////////////////////////////////
256 // For all recognized preprocessor statements the output parse trees
257 // formatted as xml are printed. The formatted parse trees are streamed to the
258 // std::ostream defined by the WAVE_DUMP_PARSE_TREE_OUT constant.
260 // To enable the output of these parse trees, define the following constant
261 // as zero something not equal to zero before including this file.
263 #if !defined(BOOST_WAVE_DUMP_PARSE_TREE)
264 #define BOOST_WAVE_DUMP_PARSE_TREE 0
266 #if BOOST_WAVE_DUMP_PARSE_TREE != 0 && !defined(BOOST_WAVE_DUMP_PARSE_TREE_OUT)
267 #define BOOST_WAVE_DUMP_PARSE_TREE_OUT std::cerr
270 ///////////////////////////////////////////////////////////////////////////////
272 // For all #if and #elif directives the preprocessed expressions are printed.
273 // These expressions are streamed to the std::ostream defined by the
274 // BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS_OUT constant.
276 // To enable the output of the preprocessed expressions, define the following
277 // constant as something not equal to zero before including this file.
279 #if !defined(BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS)
280 #define BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS 0
282 #if BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS != 0 && \
283 !defined(BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS_OUT)
284 #define BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS_OUT std::cerr
287 ///////////////////////////////////////////////////////////////////////////////
288 // Decide, whether to use the separate compilation model for the instantiation
289 // of the C++ lexer objects.
291 // If this is defined, you should explicitly instantiate the C++ lexer
292 // template with the correct parameters in a separate compilation unit of
293 // your program (see the file instantiate_re2c_lexer.cpp).
295 // To use the lexer inclusion model, define the following constant as
296 // something not equal to zero before including this file.
298 #if !defined(BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION)
299 #define BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION 1
302 ///////////////////////////////////////////////////////////////////////////////
303 // Decide, whether to use the separate compilation model for the instantiation
304 // of the grammar objects.
306 // If this is defined, you should explicitly instantiate the grammar
307 // templates with the correct parameters in a separate compilation unit of
308 // your program (see the files instantiate_cpp_grammar.cpp et.al.).
310 // To use the grammar inclusion model, define the following constant as
311 // something not equal to zero before including this file.
313 #if !defined(BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION)
314 #define BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION 1
317 ///////////////////////////////////////////////////////////////////////////////
318 // Decide whether to use a strict C++ lexer.
320 // If this is defined to something != 0, then the C++ lexers recognize the
321 // strict C99/C++ basic source character set. If it is not defined or defined
322 // to zero, the C++ lexers recognize the '$' character as part of identifiers.
324 // The default is to recognize the '$' character as part of identifiers.
326 #if !defined(BOOST_WAVE_USE_STRICT_LEXER)
327 #define BOOST_WAVE_USE_STRICT_LEXER 0
330 ///////////////////////////////////////////////////////////////////////////////
331 // Decide, whether the serialization of the wave::context class should be
334 // If this is defined to something not equal to zero the generated code will
335 // expose routines allowing to store and reload the internal state of the
336 // wave::context object.
338 // To enable the availability of the serialization functionality, define the
339 // following constant as something not equal to zero before including this file.
341 #if !defined(BOOST_WAVE_SERIALIZATION)
342 #define BOOST_WAVE_SERIALIZATION 0
345 ///////////////////////////////////////////////////////////////////////////////
346 // configure Boost.Pool thread support (for now: no thread support at all)
347 #if !defined(BOOST_NO_MT)
349 #endif // !defined(BOOST_NO_MT)
351 //#if !defined(BOOST_DISABLE_THREADS)
352 //#define BOOST_DISABLE_THREADS
353 //#endif // !defined(BOOST_DISABLE_THREADS)
355 ///////////////////////////////////////////////////////////////////////////////
356 // Wave needs at least 4 parameters for phoenix actors
357 #if !defined(PHOENIX_LIMIT)
358 #define PHOENIX_LIMIT 6
360 #if PHOENIX_LIMIT < 6
361 #error "Boost.Wave: the constant PHOENIX_LIMIT must be at least defined to 4" \
362 " to compile the library."
365 ///////////////////////////////////////////////////////////////////////////////
366 // Set up dll import/export options
367 #if defined(BOOST_HAS_DECLSPEC) && \
368 (defined(BOOST_WAVE_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)) && \
369 !defined(BOOST_WAVE_STATIC_LINK)
371 #if defined(BOOST_WAVE_SOURCE)
372 #define BOOST_WAVE_DECL __declspec(dllexport)
373 #define BOOST_WAVE_BUILD_DLL
375 #define BOOST_WAVE_DECL __declspec(dllimport)
378 #endif // building a shared library
380 #ifndef BOOST_WAVE_DECL
381 #define BOOST_WAVE_DECL
384 ///////////////////////////////////////////////////////////////////////////////
385 // Auto library naming
386 #if BOOST_VERSION >= 103100
387 // auto link features work beginning from Boost V1.31.0
388 #if !defined(BOOST_WAVE_SOURCE) && !defined(BOOST_ALL_NO_LIB) && \
389 !defined(BOOST_WAVE_NO_LIB)
391 #define BOOST_LIB_NAME boost_wave
393 // tell the auto-link code to select a dll when required:
394 #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_WAVE_DYN_LINK)
395 #define BOOST_DYN_LINK
398 #include <boost/config/auto_link.hpp>
400 #endif // auto-linking disabled
401 #endif // BOOST_VERSION
403 #endif // !defined(WAVE_CONFIG_HPP_F143F90A_A63F_4B27_AC41_9CA4F14F538D_INCLUDED)