fixing stuff
[dyninst.git] / dynutil / h / dyn_detail / boost / config / suffix.hpp
1 //  Boost config.hpp configuration header file  ------------------------------//
2
3 //  Copyright (c) 2001-2003 John Maddock
4 //  Copyright (c) 2001 Darin Adler
5 //  Copyright (c) 2001 Peter Dimov
6 //  Copyright (c) 2002 Bill Kempf 
7 //  Copyright (c) 2002 Jens Maurer
8 //  Copyright (c) 2002-2003 David Abrahams
9 //  Copyright (c) 2003 Gennaro Prota
10 //  Copyright (c) 2003 Eric Friedman
11 //
12 // Distributed under the Boost Software License, Version 1.0. (See
13 // accompanying file LICENSE_1_0.txt or copy at
14 // http://www.boost.org/LICENSE_1_0.txt)
15
16 //  See http://www.boost.org/ for most recent version.
17
18 //  Boost config.hpp policy and rationale documentation has been moved to
19 //  http://www.boost.org/libs/config/
20 //
21 //  This file is intended to be stable, and relatively unchanging.
22 //  It should contain boilerplate code only - no compiler specific
23 //  code unless it is unavoidable - no changes unless unavoidable.
24
25 #ifndef DYN_DETAIL_BOOST_CONFIG_SUFFIX_HPP
26 #define DYN_DETAIL_BOOST_CONFIG_SUFFIX_HPP
27
28 //
29 // look for long long by looking for the appropriate macros in <limits.h>.
30 // Note that we use limits.h rather than climits for maximal portability,
31 // remember that since these just declare a bunch of macros, there should be
32 // no namespace issues from this.
33 //
34 #if !defined(DYN_DETAIL_BOOST_HAS_LONG_LONG)                                               \
35    && !defined(DYN_DETAIL_BOOST_MSVC) && !defined(__BORLANDC__)
36 # include <limits.h>
37 # if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
38 #   define DYN_DETAIL_BOOST_HAS_LONG_LONG
39 # endif
40 #endif
41
42 // GCC 3.x will clean up all of those nasty macro definitions that
43 // DYN_DETAIL_BOOST_NO_CTYPE_FUNCTIONS is intended to help work around, so undefine
44 // it under GCC 3.x.
45 #if defined(__GNUC__) && (__GNUC__ >= 3) && defined(DYN_DETAIL_BOOST_NO_CTYPE_FUNCTIONS)
46 #  undef DYN_DETAIL_BOOST_NO_CTYPE_FUNCTIONS
47 #endif
48
49 //
50 // Assume any extensions are in namespace std:: unless stated otherwise:
51 //
52 #  ifndef DYN_DETAIL_BOOST_STD_EXTENSION_NAMESPACE
53 #    define DYN_DETAIL_BOOST_STD_EXTENSION_NAMESPACE std
54 #  endif
55
56 //
57 // If cv-qualified specializations are not allowed, then neither are cv-void ones:
58 //
59 #  if defined(DYN_DETAIL_BOOST_NO_CV_SPECIALIZATIONS) \
60       && !defined(DYN_DETAIL_BOOST_NO_CV_VOID_SPECIALIZATIONS)
61 #     define DYN_DETAIL_BOOST_NO_CV_VOID_SPECIALIZATIONS
62 #  endif
63
64 //
65 // If there is no numeric_limits template, then it can't have any compile time
66 // constants either!
67 //
68 #  if defined(DYN_DETAIL_BOOST_NO_LIMITS) \
69       && !defined(DYN_DETAIL_BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS)
70 #     define DYN_DETAIL_BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
71 #     define DYN_DETAIL_BOOST_NO_MS_INT64_NUMERIC_LIMITS
72 #     define DYN_DETAIL_BOOST_NO_LONG_LONG_NUMERIC_LIMITS
73 #  endif
74
75 //
76 // if there is no long long then there is no specialisation
77 // for numeric_limits<long long> either:
78 //
79 #if !defined(DYN_DETAIL_BOOST_HAS_LONG_LONG) && !defined(DYN_DETAIL_BOOST_NO_LONG_LONG_NUMERIC_LIMITS)
80 #  define DYN_DETAIL_BOOST_NO_LONG_LONG_NUMERIC_LIMITS
81 #endif
82
83 //
84 // if there is no __int64 then there is no specialisation
85 // for numeric_limits<__int64> either:
86 //
87 #if !defined(DYN_DETAIL_BOOST_HAS_MS_INT64) && !defined(DYN_DETAIL_BOOST_NO_MS_INT64_NUMERIC_LIMITS)
88 #  define DYN_DETAIL_BOOST_NO_MS_INT64_NUMERIC_LIMITS
89 #endif
90
91 //
92 // if member templates are supported then so is the
93 // VC6 subset of member templates:
94 //
95 #  if !defined(DYN_DETAIL_BOOST_NO_MEMBER_TEMPLATES) \
96        && !defined(DYN_DETAIL_BOOST_MSVC6_MEMBER_TEMPLATES)
97 #     define DYN_DETAIL_BOOST_MSVC6_MEMBER_TEMPLATES
98 #  endif
99
100 //
101 // Without partial specialization, can't test for partial specialisation bugs:
102 //
103 #  if defined(DYN_DETAIL_BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
104       && !defined(DYN_DETAIL_BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)
105 #     define DYN_DETAIL_BOOST_BCB_PARTIAL_SPECIALIZATION_BUG
106 #  endif
107
108 //
109 // Without partial specialization, we can't have array-type partial specialisations:
110 //
111 #  if defined(DYN_DETAIL_BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
112       && !defined(DYN_DETAIL_BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
113 #     define DYN_DETAIL_BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS
114 #  endif
115
116 //
117 // Without partial specialization, std::iterator_traits can't work:
118 //
119 #  if defined(DYN_DETAIL_BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
120       && !defined(DYN_DETAIL_BOOST_NO_STD_ITERATOR_TRAITS)
121 #     define DYN_DETAIL_BOOST_NO_STD_ITERATOR_TRAITS
122 #  endif
123
124 //
125 // Without partial specialization, partial 
126 // specialization with default args won't work either:
127 //
128 #  if defined(DYN_DETAIL_BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
129       && !defined(DYN_DETAIL_BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
130 #     define DYN_DETAIL_BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
131 #  endif
132
133 //
134 // Without member template support, we can't have template constructors
135 // in the standard library either:
136 //
137 #  if defined(DYN_DETAIL_BOOST_NO_MEMBER_TEMPLATES) \
138       && !defined(DYN_DETAIL_BOOST_MSVC6_MEMBER_TEMPLATES) \
139       && !defined(DYN_DETAIL_BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
140 #     define DYN_DETAIL_BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
141 #  endif
142
143 //
144 // Without member template support, we can't have a conforming
145 // std::allocator template either:
146 //
147 #  if defined(DYN_DETAIL_BOOST_NO_MEMBER_TEMPLATES) \
148       && !defined(DYN_DETAIL_BOOST_MSVC6_MEMBER_TEMPLATES) \
149       && !defined(DYN_DETAIL_BOOST_NO_STD_ALLOCATOR)
150 #     define DYN_DETAIL_BOOST_NO_STD_ALLOCATOR
151 #  endif
152
153 //
154 // without ADL support then using declarations will break ADL as well:
155 //
156 #if defined(DYN_DETAIL_BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) && !defined(DYN_DETAIL_BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
157 #  define DYN_DETAIL_BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
158 #endif
159
160 //
161 // Without typeid support we have no dynamic RTTI either:
162 //
163 #if defined(DYN_DETAIL_BOOST_NO_TYPEID) && !defined(DYN_DETAIL_BOOST_NO_RTTI)
164 #  define DYN_DETAIL_BOOST_NO_RTTI
165 #endif
166
167 //
168 // If we have a standard allocator, then we have a partial one as well:
169 //
170 #if !defined(DYN_DETAIL_BOOST_NO_STD_ALLOCATOR)
171 #  define DYN_DETAIL_BOOST_HAS_PARTIAL_STD_ALLOCATOR
172 #endif
173
174 //
175 // We can't have a working std::use_facet if there is no std::locale:
176 //
177 #  if defined(DYN_DETAIL_BOOST_NO_STD_LOCALE) && !defined(DYN_DETAIL_BOOST_NO_STD_USE_FACET)
178 #     define DYN_DETAIL_BOOST_NO_STD_USE_FACET
179 #  endif
180
181 //
182 // We can't have a std::messages facet if there is no std::locale:
183 //
184 #  if defined(DYN_DETAIL_BOOST_NO_STD_LOCALE) && !defined(DYN_DETAIL_BOOST_NO_STD_MESSAGES)
185 #     define DYN_DETAIL_BOOST_NO_STD_MESSAGES
186 #  endif
187
188 //
189 // We can't have a working std::wstreambuf if there is no std::locale:
190 //
191 #  if defined(DYN_DETAIL_BOOST_NO_STD_LOCALE) && !defined(DYN_DETAIL_BOOST_NO_STD_WSTREAMBUF)
192 #     define DYN_DETAIL_BOOST_NO_STD_WSTREAMBUF
193 #  endif
194
195 //
196 // We can't have a <cwctype> if there is no <cwchar>:
197 //
198 #  if defined(DYN_DETAIL_BOOST_NO_CWCHAR) && !defined(DYN_DETAIL_BOOST_NO_CWCTYPE)
199 #     define DYN_DETAIL_BOOST_NO_CWCTYPE
200 #  endif
201
202 //
203 // We can't have a swprintf if there is no <cwchar>:
204 //
205 #  if defined(DYN_DETAIL_BOOST_NO_CWCHAR) && !defined(DYN_DETAIL_BOOST_NO_SWPRINTF)
206 #     define DYN_DETAIL_BOOST_NO_SWPRINTF
207 #  endif
208
209 //
210 // If Win32 support is turned off, then we must turn off
211 // threading support also, unless there is some other
212 // thread API enabled:
213 //
214 #if defined(DYN_DETAIL_BOOST_DISABLE_WIN32) && defined(_WIN32) \
215    && !defined(DYN_DETAIL_BOOST_DISABLE_THREADS) && !defined(DYN_DETAIL_BOOST_HAS_PTHREADS)
216 #  define DYN_DETAIL_BOOST_DISABLE_THREADS
217 #endif
218
219 //
220 // Turn on threading support if the compiler thinks that it's in
221 // multithreaded mode.  We put this here because there are only a
222 // limited number of macros that identify this (if there's any missing
223 // from here then add to the appropriate compiler section):
224 //
225 #if (defined(__MT__) || defined(_MT) || defined(_REENTRANT) \
226     || defined(_PTHREADS)) && !defined(DYN_DETAIL_BOOST_HAS_THREADS)
227 #  define DYN_DETAIL_BOOST_HAS_THREADS
228 #endif
229
230 //
231 // Turn threading support off if DYN_DETAIL_BOOST_DISABLE_THREADS is defined:
232 //
233 #if defined(DYN_DETAIL_BOOST_DISABLE_THREADS) && defined(DYN_DETAIL_BOOST_HAS_THREADS)
234 #  undef DYN_DETAIL_BOOST_HAS_THREADS
235 #endif
236
237 //
238 // Turn threading support off if we don't recognise the threading API:
239 //
240 #if defined(DYN_DETAIL_BOOST_HAS_THREADS) && !defined(DYN_DETAIL_BOOST_HAS_PTHREADS)\
241       && !defined(DYN_DETAIL_BOOST_HAS_WINTHREADS) && !defined(DYN_DETAIL_BOOST_HAS_BETHREADS)\
242       && !defined(DYN_DETAIL_BOOST_HAS_MPTASKS)
243 #  undef DYN_DETAIL_BOOST_HAS_THREADS
244 #endif
245
246 //
247 // Turn threading detail macros off if we don't (want to) use threading
248 //
249 #ifndef DYN_DETAIL_BOOST_HAS_THREADS
250 #  undef DYN_DETAIL_BOOST_HAS_PTHREADS
251 #  undef DYN_DETAIL_BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
252 #  undef DYN_DETAIL_BOOST_HAS_PTHREAD_YIELD
253 #  undef DYN_DETAIL_BOOST_HAS_PTHREAD_DELAY_NP
254 #  undef DYN_DETAIL_BOOST_HAS_WINTHREADS
255 #  undef DYN_DETAIL_BOOST_HAS_BETHREADS
256 #  undef DYN_DETAIL_BOOST_HAS_MPTASKS
257 #endif
258
259 //
260 // If the compiler claims to be C99 conformant, then it had better
261 // have a <stdint.h>:
262 //
263 #  if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
264 #     define DYN_DETAIL_BOOST_HAS_STDINT_H
265 #     ifndef DYN_DETAIL_BOOST_HAS_LOG1P
266 #        define DYN_DETAIL_BOOST_HAS_LOG1P
267 #     endif
268 #     ifndef DYN_DETAIL_BOOST_HAS_EXPM1
269 #        define DYN_DETAIL_BOOST_HAS_EXPM1
270 #     endif
271 #  endif
272
273 //
274 // Define DYN_DETAIL_BOOST_NO_SLIST and DYN_DETAIL_BOOST_NO_HASH if required.
275 // Note that this is for backwards compatibility only.
276 //
277 #  if !defined(DYN_DETAIL_BOOST_HAS_SLIST) && !defined(DYN_DETAIL_BOOST_NO_SLIST)
278 #     define DYN_DETAIL_BOOST_NO_SLIST
279 #  endif
280
281 #  if !defined(DYN_DETAIL_BOOST_HAS_HASH) && !defined(DYN_DETAIL_BOOST_NO_HASH)
282 #     define DYN_DETAIL_BOOST_NO_HASH
283 #  endif
284
285 //
286 // Set DYN_DETAIL_BOOST_SLIST_HEADER if not set already:
287 //
288 #if defined(DYN_DETAIL_BOOST_HAS_SLIST) && !defined(DYN_DETAIL_BOOST_SLIST_HEADER)
289 #  define DYN_DETAIL_BOOST_SLIST_HEADER <slist>
290 #endif
291
292 //
293 // Set DYN_DETAIL_BOOST_HASH_SET_HEADER if not set already:
294 //
295 #if defined(DYN_DETAIL_BOOST_HAS_HASH) && !defined(DYN_DETAIL_BOOST_HASH_SET_HEADER)
296 #  define DYN_DETAIL_BOOST_HASH_SET_HEADER <hash_set>
297 #endif
298
299 //
300 // Set DYN_DETAIL_BOOST_HASH_MAP_HEADER if not set already:
301 //
302 #if defined(DYN_DETAIL_BOOST_HAS_HASH) && !defined(DYN_DETAIL_BOOST_HASH_MAP_HEADER)
303 #  define DYN_DETAIL_BOOST_HASH_MAP_HEADER <hash_map>
304 #endif
305
306 //  DYN_DETAIL_BOOST_HAS_ABI_HEADERS
307 //  This macro gets set if we have headers that fix the ABI,
308 //  and prevent ODR violations when linking to external libraries:
309 #if defined(DYN_DETAIL_BOOST_ABI_PREFIX) && defined(DYN_DETAIL_BOOST_ABI_SUFFIX) && !defined(DYN_DETAIL_BOOST_HAS_ABI_HEADERS)
310 #  define DYN_DETAIL_BOOST_HAS_ABI_HEADERS
311 #endif
312
313 #if defined(DYN_DETAIL_BOOST_HAS_ABI_HEADERS) && defined(DYN_DETAIL_BOOST_DISABLE_ABI_HEADERS)
314 #  undef DYN_DETAIL_BOOST_HAS_ABI_HEADERS
315 #endif
316
317 //  DYN_DETAIL_BOOST_NO_STDC_NAMESPACE workaround  --------------------------------------//
318 //  Because std::size_t usage is so common, even in boost headers which do not
319 //  otherwise use the C library, the <cstddef> workaround is included here so
320 //  that ugly workaround code need not appear in many other boost headers.
321 //  NOTE WELL: This is a workaround for non-conforming compilers; <cstddef>
322 //  must still be #included in the usual places so that <cstddef> inclusion
323 //  works as expected with standard conforming compilers.  The resulting
324 //  double inclusion of <cstddef> is harmless.
325
326 # ifdef DYN_DETAIL_BOOST_NO_STDC_NAMESPACE
327 #   include <cstddef>
328     namespace std { using ::ptrdiff_t; using ::size_t; }
329 # endif
330
331 //  Workaround for the unfortunate min/max macros defined by some platform headers
332
333 #define DYN_DETAIL_BOOST_PREVENT_MACRO_SUBSTITUTION
334
335 #ifndef DYN_DETAIL_BOOST_USING_STD_MIN
336 #  define DYN_DETAIL_BOOST_USING_STD_MIN() using std::min
337 #endif
338
339 #ifndef DYN_DETAIL_BOOST_USING_STD_MAX
340 #  define DYN_DETAIL_BOOST_USING_STD_MAX() using std::max
341 #endif
342
343 //  DYN_DETAIL_BOOST_NO_STD_MIN_MAX workaround  -----------------------------------------//
344
345 #  ifdef DYN_DETAIL_BOOST_NO_STD_MIN_MAX
346
347 namespace std {
348   template <class _Tp>
349   inline const _Tp& min DYN_DETAIL_BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) {
350     return __b < __a ? __b : __a;
351   }
352   template <class _Tp>
353   inline const _Tp& max DYN_DETAIL_BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) {
354     return  __a < __b ? __b : __a;
355   }
356 }
357
358 #  endif
359
360 // DYN_DETAIL_BOOST_STATIC_CONSTANT workaround --------------------------------------- //
361 // On compilers which don't allow in-class initialization of static integral
362 // constant members, we must use enums as a workaround if we want the constants
363 // to be available at compile-time. This macro gives us a convenient way to
364 // declare such constants.
365
366 #  ifdef DYN_DETAIL_BOOST_NO_INCLASS_MEMBER_INITIALIZATION
367 #       define DYN_DETAIL_BOOST_STATIC_CONSTANT(type, assignment) enum { assignment }
368 #  else
369 #     define DYN_DETAIL_BOOST_STATIC_CONSTANT(type, assignment) static const type assignment
370 #  endif
371
372 // DYN_DETAIL_BOOST_USE_FACET / HAS_FACET workaround ----------------------------------//
373 // When the standard library does not have a conforming std::use_facet there
374 // are various workarounds available, but they differ from library to library.
375 // The same problem occurs with has_facet.
376 // These macros provide a consistent way to access a locale's facets.
377 // Usage:
378 //    replace
379 //       std::use_facet<Type>(loc);
380 //    with
381 //       DYN_DETAIL_BOOST_USE_FACET(Type, loc);
382 //    Note do not add a std:: prefix to the front of DYN_DETAIL_BOOST_USE_FACET!
383 //  Use for DYN_DETAIL_BOOST_HAS_FACET is analogous.
384
385 #if defined(DYN_DETAIL_BOOST_NO_STD_USE_FACET)
386 #  ifdef DYN_DETAIL_BOOST_HAS_TWO_ARG_USE_FACET
387 #     define DYN_DETAIL_BOOST_USE_FACET(Type, loc) std::use_facet(loc, static_cast<Type*>(0))
388 #     define DYN_DETAIL_BOOST_HAS_FACET(Type, loc) std::has_facet(loc, static_cast<Type*>(0))
389 #  elif defined(DYN_DETAIL_BOOST_HAS_MACRO_USE_FACET)
390 #     define DYN_DETAIL_BOOST_USE_FACET(Type, loc) std::_USE(loc, Type)
391 #     define DYN_DETAIL_BOOST_HAS_FACET(Type, loc) std::_HAS(loc, Type)
392 #  elif defined(DYN_DETAIL_BOOST_HAS_STLP_USE_FACET)
393 #     define DYN_DETAIL_BOOST_USE_FACET(Type, loc) (*std::_Use_facet<Type >(loc))
394 #     define DYN_DETAIL_BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc)
395 #  endif
396 #else
397 #  define DYN_DETAIL_BOOST_USE_FACET(Type, loc) std::use_facet< Type >(loc)
398 #  define DYN_DETAIL_BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc)
399 #endif
400
401 // DYN_DETAIL_BOOST_NESTED_TEMPLATE workaround ------------------------------------------//
402 // Member templates are supported by some compilers even though they can't use
403 // the A::template member<U> syntax, as a workaround replace:
404 //
405 // typedef typename A::template rebind<U> binder;
406 //
407 // with:
408 //
409 // typedef typename A::DYN_DETAIL_BOOST_NESTED_TEMPLATE rebind<U> binder;
410
411 #ifndef DYN_DETAIL_BOOST_NO_MEMBER_TEMPLATE_KEYWORD
412 #  define DYN_DETAIL_BOOST_NESTED_TEMPLATE template
413 #else
414 #  define DYN_DETAIL_BOOST_NESTED_TEMPLATE
415 #endif
416
417 // DYN_DETAIL_BOOST_UNREACHABLE_RETURN(x) workaround -------------------------------------//
418 // Normally evaluates to nothing, unless DYN_DETAIL_BOOST_NO_UNREACHABLE_RETURN_DETECTION
419 // is defined, in which case it evaluates to return x; Use when you have a return
420 // statement that can never be reached.
421
422 #ifdef DYN_DETAIL_BOOST_NO_UNREACHABLE_RETURN_DETECTION
423 #  define DYN_DETAIL_BOOST_UNREACHABLE_RETURN(x) return x;
424 #else
425 #  define DYN_DETAIL_BOOST_UNREACHABLE_RETURN(x)
426 #endif
427
428 // DYN_DETAIL_BOOST_DEDUCED_TYPENAME workaround ------------------------------------------//
429 //
430 // Some compilers don't support the use of `typename' for dependent
431 // types in deduced contexts, e.g.
432 //
433 //     template <class T> void f(T, typename T::type);
434 //                                  ^^^^^^^^
435 // Replace these declarations with:
436 //
437 //     template <class T> void f(T, DYN_DETAIL_BOOST_DEDUCED_TYPENAME T::type);
438
439 #ifndef DYN_DETAIL_BOOST_NO_DEDUCED_TYPENAME
440 #  define DYN_DETAIL_BOOST_DEDUCED_TYPENAME typename
441 #else
442 #  define DYN_DETAIL_BOOST_DEDUCED_TYPENAME
443 #endif
444
445 #ifndef DYN_DETAIL_BOOST_NO_TYPENAME_WITH_CTOR
446 #  define DYN_DETAIL_BOOST_CTOR_TYPENAME typename
447 #else
448 #  define DYN_DETAIL_BOOST_CTOR_TYPENAME
449 #endif
450
451 // long long workaround ------------------------------------------//
452 // On gcc (and maybe other compilers?) long long is alway supported
453 // but it's use may generate either warnings (with -ansi), or errors
454 // (with -pedantic -ansi) unless it's use is prefixed by __extension__
455 //
456 #if defined(DYN_DETAIL_BOOST_HAS_LONG_LONG)
457 namespace dyn_detail
458 {
459 namespace boost{
460 #  ifdef __GNUC__
461    __extension__ typedef long long long_long_type;
462    __extension__ typedef unsigned long long ulong_long_type;
463 #  else
464    typedef long long long_long_type;
465    typedef unsigned long long ulong_long_type;
466 #  endif
467 }
468 }
469 #endif
470
471 // DYN_DETAIL_BOOST_[APPEND_]EXPLICIT_TEMPLATE_[NON_]TYPE macros --------------------------//
472 //
473 // Some compilers have problems with function templates whose template
474 // parameters don't appear in the function parameter list (basically
475 // they just link one instantiation of the template in the final
476 // executable). These macros provide a uniform way to cope with the
477 // problem with no effects on the calling syntax.
478
479 // Example:
480 //
481 //  #include <iostream>
482 //  #include <ostream>
483 //  #include <typeinfo>
484 //
485 //  template <int n>
486 //  void f() { std::cout << n << ' '; }
487 //
488 //  template <typename T>
489 //  void g() { std::cout << typeid(T).name() << ' '; }
490 //
491 //  int main() {
492 //    f<1>();
493 //    f<2>();
494 //
495 //    g<int>();
496 //    g<double>();
497 //  }
498 //
499 // With VC++ 6.0 the output is:
500 //
501 //   2 2 double double
502 //
503 // To fix it, write
504 //
505 //   template <int n>
506 //   void f(DYN_DETAIL_BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, n)) { ... }
507 //
508 //   template <typename T>
509 //   void g(DYN_DETAIL_BOOST_EXPLICIT_TEMPLATE_TYPE(T)) { ... }
510 //
511
512
513 #if defined DYN_DETAIL_BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
514
515 #  include "boost/type.hpp"
516 #  include "boost/non_type.hpp"
517
518 #  define DYN_DETAIL_BOOST_EXPLICIT_TEMPLATE_TYPE(t)              boost::type<t>* = 0
519 #  define DYN_DETAIL_BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t)         boost::type<t>*
520 #  define DYN_DETAIL_BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v)       boost::non_type<t, v>* = 0
521 #  define DYN_DETAIL_BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)  boost::non_type<t, v>*
522
523 #  define DYN_DETAIL_BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t)        \
524              , DYN_DETAIL_BOOST_EXPLICIT_TEMPLATE_TYPE(t)
525 #  define DYN_DETAIL_BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t)   \
526              , DYN_DETAIL_BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
527 #  define DYN_DETAIL_BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v) \
528              , DYN_DETAIL_BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
529 #  define DYN_DETAIL_BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)    \
530              , DYN_DETAIL_BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
531
532 #else
533
534 // no workaround needed: expand to nothing
535
536 #  define DYN_DETAIL_BOOST_EXPLICIT_TEMPLATE_TYPE(t)
537 #  define DYN_DETAIL_BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
538 #  define DYN_DETAIL_BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
539 #  define DYN_DETAIL_BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
540
541 #  define DYN_DETAIL_BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t)
542 #  define DYN_DETAIL_BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
543 #  define DYN_DETAIL_BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
544 #  define DYN_DETAIL_BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
545
546
547 #endif // defined DYN_DETAIL_BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
548
549
550 // ---------------------------------------------------------------------------//
551
552 //
553 // Helper macro DYN_DETAIL_BOOST_STRINGIZE:
554 // Converts the parameter X to a string after macro replacement
555 // on X has been performed.
556 //
557 #define DYN_DETAIL_BOOST_STRINGIZE(X) DYN_DETAIL_BOOST_DO_STRINGIZE(X)
558 #define DYN_DETAIL_BOOST_DO_STRINGIZE(X) #X
559
560 //
561 // Helper macro DYN_DETAIL_BOOST_JOIN:
562 // The following piece of macro magic joins the two
563 // arguments together, even when one of the arguments is
564 // itself a macro (see 16.3.1 in C++ standard).  The key
565 // is that macro expansion of macro arguments does not
566 // occur in DYN_DETAIL_BOOST_DO_JOIN2 but does in DYN_DETAIL_BOOST_DO_JOIN.
567 //
568 #define DYN_DETAIL_BOOST_JOIN( X, Y ) DYN_DETAIL_BOOST_DO_JOIN( X, Y )
569 #define DYN_DETAIL_BOOST_DO_JOIN( X, Y ) DYN_DETAIL_BOOST_DO_JOIN2(X,Y)
570 #define DYN_DETAIL_BOOST_DO_JOIN2( X, Y ) X##Y
571
572 //
573 // Set some default values for compiler/library/platform names.
574 // These are for debugging config setup only:
575 //
576 #  ifndef DYN_DETAIL_BOOST_COMPILER
577 #     define DYN_DETAIL_BOOST_COMPILER "Unknown ISO C++ Compiler"
578 #  endif
579 #  ifndef DYN_DETAIL_BOOST_STDLIB
580 #     define DYN_DETAIL_BOOST_STDLIB "Unknown ISO standard library"
581 #  endif
582 #  ifndef DYN_DETAIL_BOOST_PLATFORM
583 #     if defined(unix) || defined(__unix) || defined(_XOPEN_SOURCE) \
584          || defined(_POSIX_SOURCE)
585 #        define DYN_DETAIL_BOOST_PLATFORM "Generic Unix"
586 #     else
587 #        define DYN_DETAIL_BOOST_PLATFORM "Unknown"
588 #     endif
589 #  endif
590
591 #endif
592
593