]>
Commit | Line | Data |
---|---|---|
1 | // boost cstdint.hpp header file ------------------------------------------// | |
2 | ||
3 | // (C) Copyright Beman Dawes 1999. | |
4 | // (C) Copyright Jens Mauer 2001 | |
5 | // (C) Copyright John Maddock 2001 | |
6 | // Distributed under the Boost | |
7 | // Software License, Version 1.0. (See accompanying file | |
8 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
9 | ||
10 | // See http://www.boost.org/libs/integer for documentation. | |
11 | ||
12 | // Revision History | |
13 | // 31 Oct 01 use BOOST_HAS_LONG_LONG to check for "long long" (Jens M.) | |
14 | // 16 Apr 01 check LONGLONG_MAX when looking for "long long" (Jens Maurer) | |
15 | // 23 Jan 01 prefer "long" over "int" for int32_t and intmax_t (Jens Maurer) | |
16 | // 12 Nov 00 Merged <boost/stdint.h> (Jens Maurer) | |
17 | // 23 Sep 00 Added INTXX_C macro support (John Maddock). | |
18 | // 22 Sep 00 Better 64-bit support (John Maddock) | |
19 | // 29 Jun 00 Reimplement to avoid including stdint.h within namespace boost | |
20 | // 8 Aug 99 Initial version (Beman Dawes) | |
21 | ||
22 | ||
23 | #ifndef BOOST_CSTDINT_HPP | |
24 | #define BOOST_CSTDINT_HPP | |
25 | ||
26 | // | |
27 | // Since we always define the INT#_C macros as per C++0x, | |
28 | // define __STDC_CONSTANT_MACROS so that <stdint.h> does the right | |
29 | // thing if possible, and so that the user knows that the macros | |
30 | // are actually defined as per C99. | |
31 | // | |
32 | #ifndef __STDC_CONSTANT_MACROS | |
33 | # define __STDC_CONSTANT_MACROS | |
34 | #endif | |
35 | ||
36 | #include <boost/config.hpp> | |
37 | // | |
38 | // For the following code we get several warnings along the lines of: | |
39 | // | |
40 | // boost/cstdint.hpp:428:35: error: use of C99 long long integer constant | |
41 | // | |
42 | // So we declare this a system header to suppress these warnings. | |
43 | // See also https://github.com/boostorg/config/issues/190 | |
44 | // | |
45 | #if defined(__GNUC__) && (__GNUC__ >= 4) | |
46 | #pragma GCC system_header | |
47 | #endif | |
48 | ||
49 | // | |
50 | // Note that GLIBC is a bit inconsistent about whether int64_t is defined or not | |
51 | // depending upon what headers happen to have been included first... | |
52 | // so we disable use of stdint.h when GLIBC does not define __GLIBC_HAVE_LONG_LONG. | |
53 | // See https://svn.boost.org/trac/boost/ticket/3548 and http://sources.redhat.com/bugzilla/show_bug.cgi?id=10990 | |
54 | // | |
55 | #if defined(BOOST_HAS_STDINT_H) \ | |
56 | && (!defined(__GLIBC__) \ | |
57 | || defined(__GLIBC_HAVE_LONG_LONG) \ | |
58 | || (defined(__GLIBC__) && ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 17))))) | |
59 | ||
60 | // The following #include is an implementation artifact; not part of interface. | |
61 | # ifdef __hpux | |
62 | // HP-UX has a vaguely nice <stdint.h> in a non-standard location | |
63 | # include <inttypes.h> | |
64 | # ifdef __STDC_32_MODE__ | |
65 | // this is triggered with GCC, because it defines __cplusplus < 199707L | |
66 | # define BOOST_NO_INT64_T | |
67 | # endif | |
68 | # elif defined(__FreeBSD__) || defined(__IBMCPP__) || defined(_AIX) | |
69 | # include <inttypes.h> | |
70 | # else | |
71 | # include <stdint.h> | |
72 | ||
73 | // There is a bug in Cygwin two _C macros | |
74 | # if defined(INTMAX_C) && defined(__CYGWIN__) | |
75 | # undef INTMAX_C | |
76 | # undef UINTMAX_C | |
77 | # define INTMAX_C(c) c##LL | |
78 | # define UINTMAX_C(c) c##ULL | |
79 | # endif | |
80 | ||
81 | # endif | |
82 | ||
83 | #if defined(__QNX__) && defined(__EXT_QNX) | |
84 | ||
85 | // QNX (Dinkumware stdlib) defines these as non-standard names. | |
86 | // Reflect to the standard names. | |
87 | ||
88 | typedef ::intleast8_t int_least8_t; | |
89 | typedef ::intfast8_t int_fast8_t; | |
90 | typedef ::uintleast8_t uint_least8_t; | |
91 | typedef ::uintfast8_t uint_fast8_t; | |
92 | ||
93 | typedef ::intleast16_t int_least16_t; | |
94 | typedef ::intfast16_t int_fast16_t; | |
95 | typedef ::uintleast16_t uint_least16_t; | |
96 | typedef ::uintfast16_t uint_fast16_t; | |
97 | ||
98 | typedef ::intleast32_t int_least32_t; | |
99 | typedef ::intfast32_t int_fast32_t; | |
100 | typedef ::uintleast32_t uint_least32_t; | |
101 | typedef ::uintfast32_t uint_fast32_t; | |
102 | ||
103 | # ifndef BOOST_NO_INT64_T | |
104 | ||
105 | typedef ::intleast64_t int_least64_t; | |
106 | typedef ::intfast64_t int_fast64_t; | |
107 | typedef ::uintleast64_t uint_least64_t; | |
108 | typedef ::uintfast64_t uint_fast64_t; | |
109 | ||
110 | # endif | |
111 | ||
112 | #endif | |
113 | ||
114 | namespace boost | |
115 | { | |
116 | ||
117 | using ::int8_t; | |
118 | using ::int_least8_t; | |
119 | using ::int_fast8_t; | |
120 | using ::uint8_t; | |
121 | using ::uint_least8_t; | |
122 | using ::uint_fast8_t; | |
123 | ||
124 | using ::int16_t; | |
125 | using ::int_least16_t; | |
126 | using ::int_fast16_t; | |
127 | using ::uint16_t; | |
128 | using ::uint_least16_t; | |
129 | using ::uint_fast16_t; | |
130 | ||
131 | using ::int32_t; | |
132 | using ::int_least32_t; | |
133 | using ::int_fast32_t; | |
134 | using ::uint32_t; | |
135 | using ::uint_least32_t; | |
136 | using ::uint_fast32_t; | |
137 | ||
138 | # ifndef BOOST_NO_INT64_T | |
139 | ||
140 | using ::int64_t; | |
141 | using ::int_least64_t; | |
142 | using ::int_fast64_t; | |
143 | using ::uint64_t; | |
144 | using ::uint_least64_t; | |
145 | using ::uint_fast64_t; | |
146 | ||
147 | # endif | |
148 | ||
149 | using ::intmax_t; | |
150 | using ::uintmax_t; | |
151 | ||
152 | } // namespace boost | |
153 | ||
154 | #elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__) || defined(__VMS) || defined(__SOLARIS9__) || defined(__NetBSD__) | |
155 | // FreeBSD and Tru64 have an <inttypes.h> that contains much of what we need. | |
156 | # include <inttypes.h> | |
157 | ||
158 | namespace boost { | |
159 | ||
160 | using ::int8_t; | |
161 | typedef int8_t int_least8_t; | |
162 | typedef int8_t int_fast8_t; | |
163 | using ::uint8_t; | |
164 | typedef uint8_t uint_least8_t; | |
165 | typedef uint8_t uint_fast8_t; | |
166 | ||
167 | using ::int16_t; | |
168 | typedef int16_t int_least16_t; | |
169 | typedef int16_t int_fast16_t; | |
170 | using ::uint16_t; | |
171 | typedef uint16_t uint_least16_t; | |
172 | typedef uint16_t uint_fast16_t; | |
173 | ||
174 | using ::int32_t; | |
175 | typedef int32_t int_least32_t; | |
176 | typedef int32_t int_fast32_t; | |
177 | using ::uint32_t; | |
178 | typedef uint32_t uint_least32_t; | |
179 | typedef uint32_t uint_fast32_t; | |
180 | ||
181 | # ifndef BOOST_NO_INT64_T | |
182 | ||
183 | using ::int64_t; | |
184 | typedef int64_t int_least64_t; | |
185 | typedef int64_t int_fast64_t; | |
186 | using ::uint64_t; | |
187 | typedef uint64_t uint_least64_t; | |
188 | typedef uint64_t uint_fast64_t; | |
189 | ||
190 | typedef int64_t intmax_t; | |
191 | typedef uint64_t uintmax_t; | |
192 | ||
193 | # else | |
194 | ||
195 | typedef int32_t intmax_t; | |
196 | typedef uint32_t uintmax_t; | |
197 | ||
198 | # endif | |
199 | ||
200 | } // namespace boost | |
201 | ||
202 | #else // BOOST_HAS_STDINT_H | |
203 | ||
204 | # include <boost/limits.hpp> // implementation artifact; not part of interface | |
205 | # include <limits.h> // needed for limits macros | |
206 | ||
207 | ||
208 | namespace boost | |
209 | { | |
210 | ||
211 | // These are fairly safe guesses for some 16-bit, and most 32-bit and 64-bit | |
212 | // platforms. For other systems, they will have to be hand tailored. | |
213 | // | |
214 | // Because the fast types are assumed to be the same as the undecorated types, | |
215 | // it may be possible to hand tailor a more efficient implementation. Such | |
216 | // an optimization may be illusionary; on the Intel x86-family 386 on, for | |
217 | // example, byte arithmetic and load/stores are as fast as "int" sized ones. | |
218 | ||
219 | // 8-bit types ------------------------------------------------------------// | |
220 | ||
221 | # if UCHAR_MAX == 0xff | |
222 | typedef signed char int8_t; | |
223 | typedef signed char int_least8_t; | |
224 | typedef signed char int_fast8_t; | |
225 | typedef unsigned char uint8_t; | |
226 | typedef unsigned char uint_least8_t; | |
227 | typedef unsigned char uint_fast8_t; | |
228 | # else | |
229 | # error defaults not correct; you must hand modify boost/cstdint.hpp | |
230 | # endif | |
231 | ||
232 | // 16-bit types -----------------------------------------------------------// | |
233 | ||
234 | # if USHRT_MAX == 0xffff | |
235 | # if defined(__crayx1) | |
236 | // The Cray X1 has a 16-bit short, however it is not recommend | |
237 | // for use in performance critical code. | |
238 | typedef short int16_t; | |
239 | typedef short int_least16_t; | |
240 | typedef int int_fast16_t; | |
241 | typedef unsigned short uint16_t; | |
242 | typedef unsigned short uint_least16_t; | |
243 | typedef unsigned int uint_fast16_t; | |
244 | # else | |
245 | typedef short int16_t; | |
246 | typedef short int_least16_t; | |
247 | typedef short int_fast16_t; | |
248 | typedef unsigned short uint16_t; | |
249 | typedef unsigned short uint_least16_t; | |
250 | typedef unsigned short uint_fast16_t; | |
251 | # endif | |
252 | # elif (USHRT_MAX == 0xffffffff) && defined(__MTA__) | |
253 | // On MTA / XMT short is 32 bits unless the -short16 compiler flag is specified | |
254 | // MTA / XMT does support the following non-standard integer types | |
255 | typedef __short16 int16_t; | |
256 | typedef __short16 int_least16_t; | |
257 | typedef __short16 int_fast16_t; | |
258 | typedef unsigned __short16 uint16_t; | |
259 | typedef unsigned __short16 uint_least16_t; | |
260 | typedef unsigned __short16 uint_fast16_t; | |
261 | # elif (USHRT_MAX == 0xffffffff) && defined(CRAY) | |
262 | // no 16-bit types on Cray: | |
263 | typedef short int_least16_t; | |
264 | typedef short int_fast16_t; | |
265 | typedef unsigned short uint_least16_t; | |
266 | typedef unsigned short uint_fast16_t; | |
267 | # else | |
268 | # error defaults not correct; you must hand modify boost/cstdint.hpp | |
269 | # endif | |
270 | ||
271 | // 32-bit types -----------------------------------------------------------// | |
272 | ||
273 | # if UINT_MAX == 0xffffffff | |
274 | typedef int int32_t; | |
275 | typedef int int_least32_t; | |
276 | typedef int int_fast32_t; | |
277 | typedef unsigned int uint32_t; | |
278 | typedef unsigned int uint_least32_t; | |
279 | typedef unsigned int uint_fast32_t; | |
280 | # elif (USHRT_MAX == 0xffffffff) | |
281 | typedef short int32_t; | |
282 | typedef short int_least32_t; | |
283 | typedef short int_fast32_t; | |
284 | typedef unsigned short uint32_t; | |
285 | typedef unsigned short uint_least32_t; | |
286 | typedef unsigned short uint_fast32_t; | |
287 | # elif ULONG_MAX == 0xffffffff | |
288 | typedef long int32_t; | |
289 | typedef long int_least32_t; | |
290 | typedef long int_fast32_t; | |
291 | typedef unsigned long uint32_t; | |
292 | typedef unsigned long uint_least32_t; | |
293 | typedef unsigned long uint_fast32_t; | |
294 | # elif (UINT_MAX == 0xffffffffffffffff) && defined(__MTA__) | |
295 | // Integers are 64 bits on the MTA / XMT | |
296 | typedef __int32 int32_t; | |
297 | typedef __int32 int_least32_t; | |
298 | typedef __int32 int_fast32_t; | |
299 | typedef unsigned __int32 uint32_t; | |
300 | typedef unsigned __int32 uint_least32_t; | |
301 | typedef unsigned __int32 uint_fast32_t; | |
302 | # else | |
303 | # error defaults not correct; you must hand modify boost/cstdint.hpp | |
304 | # endif | |
305 | ||
306 | // 64-bit types + intmax_t and uintmax_t ----------------------------------// | |
307 | ||
308 | # if defined(BOOST_HAS_LONG_LONG) && \ | |
309 | !defined(BOOST_MSVC) && !defined(__BORLANDC__) && \ | |
310 | (!defined(__GLIBCPP__) || defined(_GLIBCPP_USE_LONG_LONG)) && \ | |
311 | (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX)) | |
312 | # if defined(__hpux) | |
313 | // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions | |
314 | # elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) || (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) || (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL) | |
315 | // 2**64 - 1 | |
316 | # else | |
317 | # error defaults not correct; you must hand modify boost/cstdint.hpp | |
318 | # endif | |
319 | ||
320 | typedef ::boost::long_long_type intmax_t; | |
321 | typedef ::boost::ulong_long_type uintmax_t; | |
322 | typedef ::boost::long_long_type int64_t; | |
323 | typedef ::boost::long_long_type int_least64_t; | |
324 | typedef ::boost::long_long_type int_fast64_t; | |
325 | typedef ::boost::ulong_long_type uint64_t; | |
326 | typedef ::boost::ulong_long_type uint_least64_t; | |
327 | typedef ::boost::ulong_long_type uint_fast64_t; | |
328 | ||
329 | # elif ULONG_MAX != 0xffffffff | |
330 | ||
331 | # if ULONG_MAX == 18446744073709551615 // 2**64 - 1 | |
332 | typedef long intmax_t; | |
333 | typedef unsigned long uintmax_t; | |
334 | typedef long int64_t; | |
335 | typedef long int_least64_t; | |
336 | typedef long int_fast64_t; | |
337 | typedef unsigned long uint64_t; | |
338 | typedef unsigned long uint_least64_t; | |
339 | typedef unsigned long uint_fast64_t; | |
340 | # else | |
341 | # error defaults not correct; you must hand modify boost/cstdint.hpp | |
342 | # endif | |
343 | # elif defined(__GNUC__) && defined(BOOST_HAS_LONG_LONG) | |
344 | __extension__ typedef long long intmax_t; | |
345 | __extension__ typedef unsigned long long uintmax_t; | |
346 | __extension__ typedef long long int64_t; | |
347 | __extension__ typedef long long int_least64_t; | |
348 | __extension__ typedef long long int_fast64_t; | |
349 | __extension__ typedef unsigned long long uint64_t; | |
350 | __extension__ typedef unsigned long long uint_least64_t; | |
351 | __extension__ typedef unsigned long long uint_fast64_t; | |
352 | # elif defined(BOOST_HAS_MS_INT64) | |
353 | // | |
354 | // we have Borland/Intel/Microsoft __int64: | |
355 | // | |
356 | typedef __int64 intmax_t; | |
357 | typedef unsigned __int64 uintmax_t; | |
358 | typedef __int64 int64_t; | |
359 | typedef __int64 int_least64_t; | |
360 | typedef __int64 int_fast64_t; | |
361 | typedef unsigned __int64 uint64_t; | |
362 | typedef unsigned __int64 uint_least64_t; | |
363 | typedef unsigned __int64 uint_fast64_t; | |
364 | # else // assume no 64-bit integers | |
365 | # define BOOST_NO_INT64_T | |
366 | typedef int32_t intmax_t; | |
367 | typedef uint32_t uintmax_t; | |
368 | # endif | |
369 | ||
370 | } // namespace boost | |
371 | ||
372 | ||
373 | #endif // BOOST_HAS_STDINT_H | |
374 | ||
375 | // intptr_t/uintptr_t are defined separately because they are optional and not universally available | |
376 | #if defined(BOOST_WINDOWS) && !defined(_WIN32_WCE) && !defined(BOOST_HAS_STDINT_H) | |
377 | // Older MSVC don't have stdint.h and have intptr_t/uintptr_t defined in stddef.h | |
378 | #include <stddef.h> | |
379 | #endif | |
380 | ||
381 | #if (defined(BOOST_WINDOWS) && !defined(_WIN32_WCE)) \ | |
382 | || (defined(_XOPEN_UNIX) && (_XOPEN_UNIX+0 > 0) && !defined(__UCLIBC__)) \ | |
383 | || defined(__CYGWIN__) || defined(__VXWORKS__) \ | |
384 | || defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) \ | |
385 | || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || (defined(sun) && !defined(BOOST_HAS_STDINT_H)) || defined(INTPTR_MAX) | |
386 | ||
387 | namespace boost { | |
388 | using ::intptr_t; | |
389 | using ::uintptr_t; | |
390 | } | |
391 | #define BOOST_HAS_INTPTR_T | |
392 | ||
393 | // Clang pretends to be GCC, so it'll match this condition | |
394 | #elif defined(__GNUC__) && defined(__INTPTR_TYPE__) && defined(__UINTPTR_TYPE__) | |
395 | ||
396 | namespace boost { | |
397 | typedef __INTPTR_TYPE__ intptr_t; | |
398 | typedef __UINTPTR_TYPE__ uintptr_t; | |
399 | } | |
400 | #define BOOST_HAS_INTPTR_T | |
401 | ||
402 | #endif | |
403 | ||
404 | #endif // BOOST_CSTDINT_HPP | |
405 | ||
406 | ||
407 | /**************************************************** | |
408 | ||
409 | Macro definition section: | |
410 | ||
411 | Added 23rd September 2000 (John Maddock). | |
412 | Modified 11th September 2001 to be excluded when | |
413 | BOOST_HAS_STDINT_H is defined (John Maddock). | |
414 | Modified 11th Dec 2009 to always define the | |
415 | INT#_C macros if they're not already defined (John Maddock). | |
416 | ||
417 | ******************************************************/ | |
418 | ||
419 | #if !defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && \ | |
420 | (!defined(INT8_C) || !defined(INT16_C) || !defined(INT32_C) || !defined(INT64_C)) | |
421 | // | |
422 | // Undef the macros as a precaution, since we may get here if <stdint.h> has failed | |
423 | // to define them all, see https://svn.boost.org/trac/boost/ticket/12786 | |
424 | // | |
425 | #undef INT8_C | |
426 | #undef INT16_C | |
427 | #undef INT32_C | |
428 | #undef INT64_C | |
429 | #undef INTMAX_C | |
430 | #undef UINT8_C | |
431 | #undef UINT16_C | |
432 | #undef UINT32_C | |
433 | #undef UINT64_C | |
434 | #undef UINTMAX_C | |
435 | ||
436 | #include <limits.h> | |
437 | # define BOOST__STDC_CONSTANT_MACROS_DEFINED | |
438 | # if defined(BOOST_HAS_MS_INT64) | |
439 | // | |
440 | // Borland/Intel/Microsoft compilers have width specific suffixes: | |
441 | // | |
442 | #ifndef INT8_C | |
443 | # define INT8_C(value) value##i8 | |
444 | #endif | |
445 | #ifndef INT16_C | |
446 | # define INT16_C(value) value##i16 | |
447 | #endif | |
448 | #ifndef INT32_C | |
449 | # define INT32_C(value) value##i32 | |
450 | #endif | |
451 | #ifndef INT64_C | |
452 | # define INT64_C(value) value##i64 | |
453 | #endif | |
454 | # ifdef __BORLANDC__ | |
455 | // Borland bug: appending ui8 makes the type a signed char | |
456 | # define UINT8_C(value) static_cast<unsigned char>(value##u) | |
457 | # else | |
458 | # define UINT8_C(value) value##ui8 | |
459 | # endif | |
460 | #ifndef UINT16_C | |
461 | # define UINT16_C(value) value##ui16 | |
462 | #endif | |
463 | #ifndef UINT32_C | |
464 | # define UINT32_C(value) value##ui32 | |
465 | #endif | |
466 | #ifndef UINT64_C | |
467 | # define UINT64_C(value) value##ui64 | |
468 | #endif | |
469 | #ifndef INTMAX_C | |
470 | # define INTMAX_C(value) value##i64 | |
471 | # define UINTMAX_C(value) value##ui64 | |
472 | #endif | |
473 | ||
474 | # else | |
475 | // do it the old fashioned way: | |
476 | ||
477 | // 8-bit types ------------------------------------------------------------// | |
478 | ||
479 | # if (UCHAR_MAX == 0xff) && !defined(INT8_C) | |
480 | # define INT8_C(value) static_cast<boost::int8_t>(value) | |
481 | # define UINT8_C(value) static_cast<boost::uint8_t>(value##u) | |
482 | # endif | |
483 | ||
484 | // 16-bit types -----------------------------------------------------------// | |
485 | ||
486 | # if (USHRT_MAX == 0xffff) && !defined(INT16_C) | |
487 | # define INT16_C(value) static_cast<boost::int16_t>(value) | |
488 | # define UINT16_C(value) static_cast<boost::uint16_t>(value##u) | |
489 | # endif | |
490 | ||
491 | // 32-bit types -----------------------------------------------------------// | |
492 | #ifndef INT32_C | |
493 | # if (UINT_MAX == 0xffffffff) | |
494 | # define INT32_C(value) value | |
495 | # define UINT32_C(value) value##u | |
496 | # elif ULONG_MAX == 0xffffffff | |
497 | # define INT32_C(value) value##L | |
498 | # define UINT32_C(value) value##uL | |
499 | # endif | |
500 | #endif | |
501 | ||
502 | // 64-bit types + intmax_t and uintmax_t ----------------------------------// | |
503 | #ifndef INT64_C | |
504 | # if defined(BOOST_HAS_LONG_LONG) && \ | |
505 | (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX) || defined(_ULLONG_MAX) || defined(_LLONG_MAX)) | |
506 | ||
507 | # if defined(__hpux) | |
508 | // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions | |
509 | # define INT64_C(value) value##LL | |
510 | # define UINT64_C(value) value##uLL | |
511 | # elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) || \ | |
512 | (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) || \ | |
513 | (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL) || \ | |
514 | (defined(_ULLONG_MAX) && _ULLONG_MAX == 18446744073709551615ULL) || \ | |
515 | (defined(_LLONG_MAX) && _LLONG_MAX == 9223372036854775807LL) | |
516 | ||
517 | # define INT64_C(value) value##LL | |
518 | # define UINT64_C(value) value##uLL | |
519 | # else | |
520 | # error defaults not correct; you must hand modify boost/cstdint.hpp | |
521 | # endif | |
522 | # elif ULONG_MAX != 0xffffffff | |
523 | ||
524 | # if ULONG_MAX == 18446744073709551615U // 2**64 - 1 | |
525 | # define INT64_C(value) value##L | |
526 | # define UINT64_C(value) value##uL | |
527 | # else | |
528 | # error defaults not correct; you must hand modify boost/cstdint.hpp | |
529 | # endif | |
530 | # elif defined(BOOST_HAS_LONG_LONG) | |
531 | // Usual macros not defined, work things out for ourselves: | |
532 | # if(~0uLL == 18446744073709551615ULL) | |
533 | # define INT64_C(value) value##LL | |
534 | # define UINT64_C(value) value##uLL | |
535 | # else | |
536 | # error defaults not correct; you must hand modify boost/cstdint.hpp | |
537 | # endif | |
538 | # else | |
539 | # error defaults not correct; you must hand modify boost/cstdint.hpp | |
540 | # endif | |
541 | ||
542 | # ifdef BOOST_NO_INT64_T | |
543 | # define INTMAX_C(value) INT32_C(value) | |
544 | # define UINTMAX_C(value) UINT32_C(value) | |
545 | # else | |
546 | # define INTMAX_C(value) INT64_C(value) | |
547 | # define UINTMAX_C(value) UINT64_C(value) | |
548 | # endif | |
549 | #endif | |
550 | # endif // Borland/Microsoft specific width suffixes | |
551 | ||
552 | #endif // INT#_C macros. | |
553 | ||
554 | ||
555 | ||
556 |