Ticket #3919: suffix.hpp

File suffix.hpp, 18.7 KB (added by joel.falcou@…, 13 years ago)

suffix.hpp patched to define BOOST_GPU_ENABLED if not set up before

Line 
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// Copyright (c) 2010 Eric Jourdanneau, Joel Falcou
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 BOOST_CONFIG_SUFFIX_HPP
26#define 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(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG) \
35 && !defined(BOOST_MSVC) && !defined(__BORLANDC__)
36# include <limits.h>
37# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
38# define BOOST_HAS_LONG_LONG
39# else
40# define BOOST_NO_LONG_LONG
41# endif
42#endif
43
44// GCC 3.x will clean up all of those nasty macro definitions that
45// BOOST_NO_CTYPE_FUNCTIONS is intended to help work around, so undefine
46// it under GCC 3.x.
47#if defined(__GNUC__) && (__GNUC__ >= 3) && defined(BOOST_NO_CTYPE_FUNCTIONS)
48# undef BOOST_NO_CTYPE_FUNCTIONS
49#endif
50
51//
52// Assume any extensions are in namespace std:: unless stated otherwise:
53//
54# ifndef BOOST_STD_EXTENSION_NAMESPACE
55# define BOOST_STD_EXTENSION_NAMESPACE std
56# endif
57
58//
59// If cv-qualified specializations are not allowed, then neither are cv-void ones:
60//
61# if defined(BOOST_NO_CV_SPECIALIZATIONS) \
62 && !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)
63# define BOOST_NO_CV_VOID_SPECIALIZATIONS
64# endif
65
66//
67// If there is no numeric_limits template, then it can't have any compile time
68// constants either!
69//
70# if defined(BOOST_NO_LIMITS) \
71 && !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS)
72# define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
73# define BOOST_NO_MS_INT64_NUMERIC_LIMITS
74# define BOOST_NO_LONG_LONG_NUMERIC_LIMITS
75# endif
76
77//
78// if there is no long long then there is no specialisation
79// for numeric_limits<long long> either:
80//
81#if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS)
82# define BOOST_NO_LONG_LONG_NUMERIC_LIMITS
83#endif
84
85//
86// if there is no __int64 then there is no specialisation
87// for numeric_limits<__int64> either:
88//
89#if !defined(BOOST_HAS_MS_INT64) && !defined(BOOST_NO_MS_INT64_NUMERIC_LIMITS)
90# define BOOST_NO_MS_INT64_NUMERIC_LIMITS
91#endif
92
93//
94// if member templates are supported then so is the
95// VC6 subset of member templates:
96//
97# if !defined(BOOST_NO_MEMBER_TEMPLATES) \
98 && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
99# define BOOST_MSVC6_MEMBER_TEMPLATES
100# endif
101
102//
103// Without partial specialization, can't test for partial specialisation bugs:
104//
105# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
106 && !defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)
107# define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG
108# endif
109
110//
111// Without partial specialization, we can't have array-type partial specialisations:
112//
113# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
114 && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
115# define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS
116# endif
117
118//
119// Without partial specialization, std::iterator_traits can't work:
120//
121# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
122 && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
123# define BOOST_NO_STD_ITERATOR_TRAITS
124# endif
125
126//
127// Without partial specialization, partial
128// specialization with default args won't work either:
129//
130# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
131 && !defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
132# define BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
133# endif
134
135//
136// Without member template support, we can't have template constructors
137// in the standard library either:
138//
139# if defined(BOOST_NO_MEMBER_TEMPLATES) \
140 && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \
141 && !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
142# define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
143# endif
144
145//
146// Without member template support, we can't have a conforming
147// std::allocator template either:
148//
149# if defined(BOOST_NO_MEMBER_TEMPLATES) \
150 && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \
151 && !defined(BOOST_NO_STD_ALLOCATOR)
152# define BOOST_NO_STD_ALLOCATOR
153# endif
154
155//
156// without ADL support then using declarations will break ADL as well:
157//
158#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
159# define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
160#endif
161
162//
163// Without typeid support we have no dynamic RTTI either:
164//
165#if defined(BOOST_NO_TYPEID) && !defined(BOOST_NO_RTTI)
166# define BOOST_NO_RTTI
167#endif
168
169//
170// If we have a standard allocator, then we have a partial one as well:
171//
172#if !defined(BOOST_NO_STD_ALLOCATOR)
173# define BOOST_HAS_PARTIAL_STD_ALLOCATOR
174#endif
175
176//
177// We can't have a working std::use_facet if there is no std::locale:
178//
179# if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_USE_FACET)
180# define BOOST_NO_STD_USE_FACET
181# endif
182
183//
184// We can't have a std::messages facet if there is no std::locale:
185//
186# if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_MESSAGES)
187# define BOOST_NO_STD_MESSAGES
188# endif
189
190//
191// We can't have a working std::wstreambuf if there is no std::locale:
192//
193# if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_WSTREAMBUF)
194# define BOOST_NO_STD_WSTREAMBUF
195# endif
196
197//
198// We can't have a <cwctype> if there is no <cwchar>:
199//
200# if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_CWCTYPE)
201# define BOOST_NO_CWCTYPE
202# endif
203
204//
205// We can't have a swprintf if there is no <cwchar>:
206//
207# if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_SWPRINTF)
208# define BOOST_NO_SWPRINTF
209# endif
210
211//
212// If Win32 support is turned off, then we must turn off
213// threading support also, unless there is some other
214// thread API enabled:
215//
216#if defined(BOOST_DISABLE_WIN32) && defined(_WIN32) \
217 && !defined(BOOST_DISABLE_THREADS) && !defined(BOOST_HAS_PTHREADS)
218# define BOOST_DISABLE_THREADS
219#endif
220
221//
222// Turn on threading support if the compiler thinks that it's in
223// multithreaded mode. We put this here because there are only a
224// limited number of macros that identify this (if there's any missing
225// from here then add to the appropriate compiler section):
226//
227#if (defined(__MT__) || defined(_MT) || defined(_REENTRANT) \
228 || defined(_PTHREADS) || defined(__APPLE__) || defined(__DragonFly__)) \
229 && !defined(BOOST_HAS_THREADS)
230# define BOOST_HAS_THREADS
231#endif
232
233//
234// Turn threading support off if BOOST_DISABLE_THREADS is defined:
235//
236#if defined(BOOST_DISABLE_THREADS) && defined(BOOST_HAS_THREADS)
237# undef BOOST_HAS_THREADS
238#endif
239
240//
241// Turn threading support off if we don't recognise the threading API:
242//
243#if defined(BOOST_HAS_THREADS) && !defined(BOOST_HAS_PTHREADS)\
244 && !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_BETHREADS)\
245 && !defined(BOOST_HAS_MPTASKS)
246# undef BOOST_HAS_THREADS
247#endif
248
249//
250// Turn threading detail macros off if we don't (want to) use threading
251//
252#ifndef BOOST_HAS_THREADS
253# undef BOOST_HAS_PTHREADS
254# undef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
255# undef BOOST_HAS_PTHREAD_YIELD
256# undef BOOST_HAS_PTHREAD_DELAY_NP
257# undef BOOST_HAS_WINTHREADS
258# undef BOOST_HAS_BETHREADS
259# undef BOOST_HAS_MPTASKS
260#endif
261
262//
263// If the compiler claims to be C99 conformant, then it had better
264// have a <stdint.h>:
265//
266# if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
267# define BOOST_HAS_STDINT_H
268# ifndef BOOST_HAS_LOG1P
269# define BOOST_HAS_LOG1P
270# endif
271# ifndef BOOST_HAS_EXPM1
272# define BOOST_HAS_EXPM1
273# endif
274# endif
275
276//
277// Define BOOST_NO_SLIST and BOOST_NO_HASH if required.
278// Note that this is for backwards compatibility only.
279//
280# if !defined(BOOST_HAS_SLIST) && !defined(BOOST_NO_SLIST)
281# define BOOST_NO_SLIST
282# endif
283
284# if !defined(BOOST_HAS_HASH) && !defined(BOOST_NO_HASH)
285# define BOOST_NO_HASH
286# endif
287
288//
289// Set BOOST_SLIST_HEADER if not set already:
290//
291#if defined(BOOST_HAS_SLIST) && !defined(BOOST_SLIST_HEADER)
292# define BOOST_SLIST_HEADER <slist>
293#endif
294
295//
296// Set BOOST_HASH_SET_HEADER if not set already:
297//
298#if defined(BOOST_HAS_HASH) && !defined(BOOST_HASH_SET_HEADER)
299# define BOOST_HASH_SET_HEADER <hash_set>
300#endif
301
302//
303// Set BOOST_HASH_MAP_HEADER if not set already:
304//
305#if defined(BOOST_HAS_HASH) && !defined(BOOST_HASH_MAP_HEADER)
306# define BOOST_HASH_MAP_HEADER <hash_map>
307#endif
308
309//
310// Set BOOST_NO_INITIALIZER_LISTS if there is no library support.
311//
312
313#if defined(BOOST_NO_0X_HDR_INITIALIZER_LIST) && !defined(BOOST_NO_INITIALIZER_LISTS)
314# define BOOST_NO_INITIALIZER_LISTS
315#endif
316
317// BOOST_HAS_ABI_HEADERS
318// This macro gets set if we have headers that fix the ABI,
319// and prevent ODR violations when linking to external libraries:
320#if defined(BOOST_ABI_PREFIX) && defined(BOOST_ABI_SUFFIX) && !defined(BOOST_HAS_ABI_HEADERS)
321# define BOOST_HAS_ABI_HEADERS
322#endif
323
324#if defined(BOOST_HAS_ABI_HEADERS) && defined(BOOST_DISABLE_ABI_HEADERS)
325# undef BOOST_HAS_ABI_HEADERS
326#endif
327
328// BOOST_NO_STDC_NAMESPACE workaround --------------------------------------//
329// Because std::size_t usage is so common, even in boost headers which do not
330// otherwise use the C library, the <cstddef> workaround is included here so
331// that ugly workaround code need not appear in many other boost headers.
332// NOTE WELL: This is a workaround for non-conforming compilers; <cstddef>
333// must still be #included in the usual places so that <cstddef> inclusion
334// works as expected with standard conforming compilers. The resulting
335// double inclusion of <cstddef> is harmless.
336
337# ifdef BOOST_NO_STDC_NAMESPACE
338# include <cstddef>
339 namespace std { using ::ptrdiff_t; using ::size_t; }
340# endif
341
342// Workaround for the unfortunate min/max macros defined by some platform headers
343
344#define BOOST_PREVENT_MACRO_SUBSTITUTION
345
346#ifndef BOOST_USING_STD_MIN
347# define BOOST_USING_STD_MIN() using std::min
348#endif
349
350#ifndef BOOST_USING_STD_MAX
351# define BOOST_USING_STD_MAX() using std::max
352#endif
353
354// BOOST_NO_STD_MIN_MAX workaround -----------------------------------------//
355
356# ifdef BOOST_NO_STD_MIN_MAX
357
358namespace std {
359 template <class _Tp>
360 inline const _Tp& min BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) {
361 return __b < __a ? __b : __a;
362 }
363 template <class _Tp>
364 inline const _Tp& max BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) {
365 return __a < __b ? __b : __a;
366 }
367}
368
369# endif
370
371// BOOST_STATIC_CONSTANT workaround --------------------------------------- //
372// On compilers which don't allow in-class initialization of static integral
373// constant members, we must use enums as a workaround if we want the constants
374// to be available at compile-time. This macro gives us a convenient way to
375// declare such constants.
376
377# ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
378# define BOOST_STATIC_CONSTANT(type, assignment) enum { assignment }
379# else
380# define BOOST_STATIC_CONSTANT(type, assignment) static const type assignment
381# endif
382
383// BOOST_USE_FACET / HAS_FACET workaround ----------------------------------//
384// When the standard library does not have a conforming std::use_facet there
385// are various workarounds available, but they differ from library to library.
386// The same problem occurs with has_facet.
387// These macros provide a consistent way to access a locale's facets.
388// Usage:
389// replace
390// std::use_facet<Type>(loc);
391// with
392// BOOST_USE_FACET(Type, loc);
393// Note do not add a std:: prefix to the front of BOOST_USE_FACET!
394// Use for BOOST_HAS_FACET is analogous.
395
396#if defined(BOOST_NO_STD_USE_FACET)
397# ifdef BOOST_HAS_TWO_ARG_USE_FACET
398# define BOOST_USE_FACET(Type, loc) std::use_facet(loc, static_cast<Type*>(0))
399# define BOOST_HAS_FACET(Type, loc) std::has_facet(loc, static_cast<Type*>(0))
400# elif defined(BOOST_HAS_MACRO_USE_FACET)
401# define BOOST_USE_FACET(Type, loc) std::_USE(loc, Type)
402# define BOOST_HAS_FACET(Type, loc) std::_HAS(loc, Type)
403# elif defined(BOOST_HAS_STLP_USE_FACET)
404# define BOOST_USE_FACET(Type, loc) (*std::_Use_facet<Type >(loc))
405# define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc)
406# endif
407#else
408# define BOOST_USE_FACET(Type, loc) std::use_facet< Type >(loc)
409# define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc)
410#endif
411
412// BOOST_NESTED_TEMPLATE workaround ------------------------------------------//
413// Member templates are supported by some compilers even though they can't use
414// the A::template member<U> syntax, as a workaround replace:
415//
416// typedef typename A::template rebind<U> binder;
417//
418// with:
419//
420// typedef typename A::BOOST_NESTED_TEMPLATE rebind<U> binder;
421
422#ifndef BOOST_NO_MEMBER_TEMPLATE_KEYWORD
423# define BOOST_NESTED_TEMPLATE template
424#else
425# define BOOST_NESTED_TEMPLATE
426#endif
427
428// BOOST_UNREACHABLE_RETURN(x) workaround -------------------------------------//
429// Normally evaluates to nothing, unless BOOST_NO_UNREACHABLE_RETURN_DETECTION
430// is defined, in which case it evaluates to return x; Use when you have a return
431// statement that can never be reached.
432
433#ifdef BOOST_NO_UNREACHABLE_RETURN_DETECTION
434# define BOOST_UNREACHABLE_RETURN(x) return x;
435#else
436# define BOOST_UNREACHABLE_RETURN(x)
437#endif
438
439// BOOST_DEDUCED_TYPENAME workaround ------------------------------------------//
440//
441// Some compilers don't support the use of `typename' for dependent
442// types in deduced contexts, e.g.
443//
444// template <class T> void f(T, typename T::type);
445// ^^^^^^^^
446// Replace these declarations with:
447//
448// template <class T> void f(T, BOOST_DEDUCED_TYPENAME T::type);
449
450#ifndef BOOST_NO_DEDUCED_TYPENAME
451# define BOOST_DEDUCED_TYPENAME typename
452#else
453# define BOOST_DEDUCED_TYPENAME
454#endif
455
456#ifndef BOOST_NO_TYPENAME_WITH_CTOR
457# define BOOST_CTOR_TYPENAME typename
458#else
459# define BOOST_CTOR_TYPENAME
460#endif
461
462// long long workaround ------------------------------------------//
463// On gcc (and maybe other compilers?) long long is alway supported
464// but it's use may generate either warnings (with -ansi), or errors
465// (with -pedantic -ansi) unless it's use is prefixed by __extension__
466//
467#if defined(BOOST_HAS_LONG_LONG)
468namespace boost{
469# ifdef __GNUC__
470 __extension__ typedef long long long_long_type;
471 __extension__ typedef unsigned long long ulong_long_type;
472# else
473 typedef long long long_long_type;
474 typedef unsigned long long ulong_long_type;
475# endif
476}
477#endif
478
479// BOOST_[APPEND_]EXPLICIT_TEMPLATE_[NON_]TYPE macros --------------------------//
480//
481// Some compilers have problems with function templates whose template
482// parameters don't appear in the function parameter list (basically
483// they just link one instantiation of the template in the final
484// executable). These macros provide a uniform way to cope with the
485// problem with no effects on the calling syntax.
486
487// Example:
488//
489// #include <iostream>
490// #include <ostream>
491// #include <typeinfo>
492//
493// template <int n>
494// void f() { std::cout << n << ' '; }
495//
496// template <typename T>
497// void g() { std::cout << typeid(T).name() << ' '; }
498//
499// int main() {
500// f<1>();
501// f<2>();
502//
503// g<int>();
504// g<double>();
505// }
506//
507// With VC++ 6.0 the output is:
508//
509// 2 2 double double
510//
511// To fix it, write
512//
513// template <int n>
514// void f(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, n)) { ... }
515//
516// template <typename T>
517// void g(BOOST_EXPLICIT_TEMPLATE_TYPE(T)) { ... }
518//
519
520
521#if defined BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
522
523# include "boost/type.hpp"
524# include "boost/non_type.hpp"
525
526# define BOOST_EXPLICIT_TEMPLATE_TYPE(t) boost::type<t>* = 0
527# define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t) boost::type<t>*
528# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v) boost::non_type<t, v>* = 0
529# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) boost::non_type<t, v>*
530
531# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t) \
532 , BOOST_EXPLICIT_TEMPLATE_TYPE(t)
533# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t) \
534 , BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
535# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v) \
536 , BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
537# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) \
538 , BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
539
540#else
541
542// no workaround needed: expand to nothing
543
544# define BOOST_EXPLICIT_TEMPLATE_TYPE(t)
545# define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
546# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
547# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
548
549# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t)
550# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
551# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
552# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
553
554
555#endif // defined BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
556
557
558// ---------------------------------------------------------------------------//
559
560//
561// Helper macro BOOST_STRINGIZE:
562// Converts the parameter X to a string after macro replacement
563// on X has been performed.
564//
565#define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X)
566#define BOOST_DO_STRINGIZE(X) #X
567
568//
569// Helper macro BOOST_JOIN:
570// The following piece of macro magic joins the two
571// arguments together, even when one of the arguments is
572// itself a macro (see 16.3.1 in C++ standard). The key
573// is that macro expansion of macro arguments does not
574// occur in BOOST_DO_JOIN2 but does in BOOST_DO_JOIN.
575//
576#define BOOST_JOIN( X, Y ) BOOST_DO_JOIN( X, Y )
577#define BOOST_DO_JOIN( X, Y ) BOOST_DO_JOIN2(X,Y)
578#define BOOST_DO_JOIN2( X, Y ) X##Y
579
580//
581// Set some default values for compiler/library/platform names.
582// These are for debugging config setup only:
583//
584# ifndef BOOST_COMPILER
585# define BOOST_COMPILER "Unknown ISO C++ Compiler"
586# endif
587# ifndef BOOST_STDLIB
588# define BOOST_STDLIB "Unknown ISO standard library"
589# endif
590# ifndef BOOST_PLATFORM
591# if defined(unix) || defined(__unix) || defined(_XOPEN_SOURCE) \
592 || defined(_POSIX_SOURCE)
593# define BOOST_PLATFORM "Generic Unix"
594# else
595# define BOOST_PLATFORM "Unknown"
596# endif
597# endif
598
599//
600// Set some default values GPU support
601//
602# ifndef BOOST_GPU_ENABLED
603# define BOOST_GPU_ENABLED
604# endif
605#endif
606