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