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