|
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-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 =============================================================================*/ |
|
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/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 // 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 |
|
90 // |
|
91 // Note: By default this is enabled for Windows based systems, otherwise it's |
|
92 // disabled. |
|
93 #if !defined(BOOST_WAVE_SUPPORT_MS_EXTENSIONS) |
|
94 #if defined(BOOST_WINDOWS) |
|
95 #define BOOST_WAVE_SUPPORT_MS_EXTENSIONS 1 |
|
96 #else |
|
97 #define BOOST_WAVE_SUPPORT_MS_EXTENSIONS 0 |
|
98 #endif |
|
99 #endif |
|
100 |
|
101 /////////////////////////////////////////////////////////////////////////////// |
|
102 // Allow the message body of the #error and #warning directives to be |
|
103 // preprocessed before the diagnostic is issued. |
|
104 // |
|
105 // To disable preprocessing of the body of #error and #warning directives, |
|
106 // define the following constant as zero before including this file. |
|
107 // |
|
108 #if !defined(BOOST_WAVE_PREPROCESS_ERROR_MESSAGE_BODY) |
|
109 #define BOOST_WAVE_PREPROCESS_ERROR_MESSAGE_BODY 1 |
|
110 #endif |
|
111 |
|
112 /////////////////////////////////////////////////////////////////////////////// |
|
113 // Allow the #pragma directives to be returned to the caller (optionally after |
|
114 // preprocessing the body) |
|
115 // |
|
116 // To disable the library to emit unknown #pragma directives, define the |
|
117 // following constant as zero before including this file. |
|
118 // |
|
119 #if !defined(BOOST_WAVE_EMIT_PRAGMA_DIRECTIVES) |
|
120 #define BOOST_WAVE_EMIT_PRAGMA_DIRECTIVES 1 |
|
121 #endif |
|
122 |
|
123 /////////////////////////////////////////////////////////////////////////////// |
|
124 // Allow the body of a #pragma directive to be preprocessed before the |
|
125 // directive is returned to the caller. |
|
126 // |
|
127 // To disable the preprocessing of the body of #pragma directives, define the |
|
128 // following constant as zero before including this file. |
|
129 // |
|
130 #if !defined(BOOST_WAVE_PREPROCESS_PRAGMA_BODY) |
|
131 #define BOOST_WAVE_PREPROCESS_PRAGMA_BODY 1 |
|
132 #endif |
|
133 |
|
134 /////////////////////////////////////////////////////////////////////////////// |
|
135 // Allow to define macros with the command line syntax (-DMACRO(x)=definition) |
|
136 // |
|
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. |
|
139 // |
|
140 #if !defined(BOOST_WAVE_ENABLE_COMMANDLINE_MACROS) |
|
141 #define BOOST_WAVE_ENABLE_COMMANDLINE_MACROS 1 |
|
142 #endif |
|
143 |
|
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 |
|
148 // |
|
149 // #pragma wave option [(argument)] |
|
150 // |
|
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" |
|
158 #endif |
|
159 |
|
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 |
|
163 // |
|
164 #if !defined(BOOST_WAVE_STRINGTYPE) |
|
165 |
|
166 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || \ |
|
167 BOOST_WORKAROUND(__MWERKS__, < 0x3200) || \ |
|
168 (defined(__DECCXX) && defined(__alpha)) || \ |
|
169 defined(BOOST_WAVE_STRINGTYPE_USE_STDSTRING) |
|
170 |
|
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 |
|
177 #endif |
|
178 |
|
179 #else |
|
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> \ |
|
185 > \ |
|
186 > \ |
|
187 /**/ |
|
188 |
|
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> \ |
|
194 > \ |
|
195 > \ |
|
196 > \ |
|
197 */ /**/ |
|
198 |
|
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> |
|
202 |
|
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> |
|
208 |
|
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> |
|
213 // |
|
214 //#include <boost/const_string/const_string.hpp> |
|
215 //#include <boost/const_string/io.hpp> |
|
216 //#include <boost/const_string/concatenation.hpp> |
|
217 |
|
218 #endif // BOOST_WORKAROUND(_MSC_VER, <= 1300) |
|
219 #endif |
|
220 |
|
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 |
|
225 |
|
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 |
|
230 |
|
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 |
|
236 |
|
237 /////////////////////////////////////////////////////////////////////////////// |
|
238 // Debug flags for the Wave library, possible flags specified below. |
|
239 // |
|
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 |
|
249 |
|
250 #if !defined(BOOST_SPIRIT_DEBUG_FLAGS_CPP) |
|
251 #define BOOST_SPIRIT_DEBUG_FLAGS_CPP 0 // default is no debugging |
|
252 #endif |
|
253 |
|
254 /////////////////////////////////////////////////////////////////////////////// |
|
255 // |
|
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. |
|
259 // |
|
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. |
|
262 // |
|
263 #if !defined(BOOST_WAVE_DUMP_PARSE_TREE) |
|
264 #define BOOST_WAVE_DUMP_PARSE_TREE 0 |
|
265 #endif |
|
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 |
|
268 #endif |
|
269 |
|
270 /////////////////////////////////////////////////////////////////////////////// |
|
271 // |
|
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. |
|
275 // |
|
276 // To enable the output of the preprocessed expressions, define the following |
|
277 // constant as something not equal to zero before including this file. |
|
278 // |
|
279 #if !defined(BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS) |
|
280 #define BOOST_WAVE_DUMP_CONDITIONAL_EXPRESSIONS 0 |
|
281 #endif |
|
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 |
|
285 #endif |
|
286 |
|
287 /////////////////////////////////////////////////////////////////////////////// |
|
288 // Decide, whether to use the separate compilation model for the instantiation |
|
289 // of the C++ lexer objects. |
|
290 // |
|
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). |
|
294 // |
|
295 // To use the lexer inclusion model, define the following constant as |
|
296 // something not equal to zero before including this file. |
|
297 // |
|
298 #if !defined(BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION) |
|
299 #define BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION 1 |
|
300 #endif |
|
301 |
|
302 /////////////////////////////////////////////////////////////////////////////// |
|
303 // Decide, whether to use the separate compilation model for the instantiation |
|
304 // of the grammar objects. |
|
305 // |
|
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.). |
|
309 // |
|
310 // To use the grammar inclusion model, define the following constant as |
|
311 // something not equal to zero before including this file. |
|
312 // |
|
313 #if !defined(BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION) |
|
314 #define BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION 1 |
|
315 #endif |
|
316 |
|
317 /////////////////////////////////////////////////////////////////////////////// |
|
318 // Decide whether to use a strict C++ lexer. |
|
319 // |
|
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. |
|
323 // |
|
324 // The default is to recognize the '$' character as part of identifiers. |
|
325 // |
|
326 #if !defined(BOOST_WAVE_USE_STRICT_LEXER) |
|
327 #define BOOST_WAVE_USE_STRICT_LEXER 0 |
|
328 #endif |
|
329 |
|
330 /////////////////////////////////////////////////////////////////////////////// |
|
331 // Decide, whether the serialization of the wave::context class should be |
|
332 // supported |
|
333 // |
|
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. |
|
337 // |
|
338 // To enable the availability of the serialization functionality, define the |
|
339 // following constant as something not equal to zero before including this file. |
|
340 // |
|
341 #if !defined(BOOST_WAVE_SERIALIZATION) |
|
342 #define BOOST_WAVE_SERIALIZATION 0 |
|
343 #endif |
|
344 |
|
345 /////////////////////////////////////////////////////////////////////////////// |
|
346 // configure Boost.Pool thread support (for now: no thread support at all) |
|
347 #if !defined(BOOST_NO_MT) |
|
348 #define BOOST_NO_MT |
|
349 #endif // !defined(BOOST_NO_MT) |
|
350 |
|
351 //#if !defined(BOOST_DISABLE_THREADS) |
|
352 //#define BOOST_DISABLE_THREADS |
|
353 //#endif // !defined(BOOST_DISABLE_THREADS) |
|
354 |
|
355 /////////////////////////////////////////////////////////////////////////////// |
|
356 // Wave needs at least 4 parameters for phoenix actors |
|
357 #if !defined(PHOENIX_LIMIT) |
|
358 #define PHOENIX_LIMIT 6 |
|
359 #endif |
|
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." |
|
363 #endif |
|
364 |
|
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) |
|
370 |
|
371 #if defined(BOOST_WAVE_SOURCE) |
|
372 #define BOOST_WAVE_DECL __declspec(dllexport) |
|
373 #define BOOST_WAVE_BUILD_DLL |
|
374 #else |
|
375 #define BOOST_WAVE_DECL __declspec(dllimport) |
|
376 #endif |
|
377 |
|
378 #endif // building a shared library |
|
379 |
|
380 #ifndef BOOST_WAVE_DECL |
|
381 #define BOOST_WAVE_DECL |
|
382 #endif |
|
383 |
|
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) |
|
390 |
|
391 #define BOOST_LIB_NAME boost_wave |
|
392 |
|
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 |
|
396 #endif |
|
397 |
|
398 #include <boost/config/auto_link.hpp> |
|
399 |
|
400 #endif // auto-linking disabled |
|
401 #endif // BOOST_VERSION |
|
402 |
|
403 #endif // !defined(WAVE_CONFIG_HPP_F143F90A_A63F_4B27_AC41_9CA4F14F538D_INCLUDED) |