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