From c3d2838f557b23d800988ee4cdd81a7cefcb6485 Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Sun, 12 Nov 2000 18:35:33 +0000 Subject: [PATCH] Folded stdint.h into cstdint.hpp to avoid ISO C99 incompatibilities [SVN r8174] --- include/boost/cstdint.hpp | 247 ++++++++++++++++++++++++++++++++++++-- include/boost/stdint.h | 20 ++- 2 files changed, 258 insertions(+), 9 deletions(-) diff --git a/include/boost/cstdint.hpp b/include/boost/cstdint.hpp index f2c5131..10d2bd7 100644 --- a/include/boost/cstdint.hpp +++ b/include/boost/cstdint.hpp @@ -1,4 +1,4 @@ -// boost cstdint.hpp header file -------------------------------------------// +// boost cstdint.hpp header file ------------------------------------------// // (C) Copyright boost.org 1999. Permission to copy, use, modify, sell // and distribute this software is granted provided this copyright @@ -9,21 +9,23 @@ // See http://www.boost.org for most recent version including documentation. // Revision History +// 12 Nov 00 Merged (Jens Maurer) // 23 Sep 00 Added INTXX_C macro support (John Maddock). // 22 Sep 00 Better 64-bit support (John Maddock) // 29 Jun 00 Reimplement to avoid including stdint.h within namespace boost // 8 Aug 99 Initial version (Beman Dawes) -// -// this has to go before the include guard (JM): -#include #ifndef BOOST_CSTDINT_HPP #define BOOST_CSTDINT_HPP -#include // implementation artifact; not part of interface +#include +#ifdef BOOST_SYSTEM_HAS_STDINT_H + +# include // implementation artifact; not part of interface + namespace boost { @@ -48,7 +50,7 @@ namespace boost using ::uint_least32_t; using ::uint_fast32_t; -#ifndef BOOST_NO_INT64_T +# ifndef BOOST_NO_INT64_T using ::int64_t; using ::int_least64_t; @@ -57,12 +59,241 @@ namespace boost using ::uint_least64_t; using ::uint_fast64_t; -#endif +# endif using ::intmax_t; using ::uintmax_t; } // namespace boost -#endif +#else // BOOST_SYSTEM_HAS_STDINT_H + + +# include // implementation artifact; not part of interface + + +namespace boost +{ + +// These are fairly safe guesses for some 16-bit, and most 32-bit and 64-bit +// platforms. For other systems, they will have to be hand tailored. +// +// Because the fast types are assumed to be the same as the undecorated types, +// it may be possible to hand tailor a more efficient implementation. Such +// an optimization may be illusionary; on the Intel x86-family 386 on, for +// example, byte arithmetic and load/stores are as fast as "int" sized ones. + +// 8-bit types ------------------------------------------------------------// + +# if UCHAR_MAX == 0xff + typedef signed char int8_t; + typedef signed char int_least8_t; + typedef signed char int_fast8_t; + typedef unsigned char uint8_t; + typedef unsigned char uint_least8_t; + typedef unsigned char uint_fast8_t; +# else +# error defaults not correct; you must hand modify boost/cstdint.hpp +# endif + +// 16-bit types -----------------------------------------------------------// + +# if USHRT_MAX == 0xffff + typedef short int16_t; + typedef short int_least16_t; + typedef short int_fast16_t; + typedef unsigned short uint16_t; + typedef unsigned short uint_least16_t; + typedef unsigned short uint_fast16_t; +# else +# error defaults not correct; you must hand modify boost/cstdint.hpp +# endif + +// 32-bit types -----------------------------------------------------------// + +# if UINT_MAX == 0xffffffff + typedef int int32_t; + typedef int int_least32_t; + typedef int int_fast32_t; + typedef unsigned int uint32_t; + typedef unsigned int uint_least32_t; + typedef unsigned int uint_fast32_t; +# elif ULONG_MAX == 0xffffffff + typedef long int32_t; + typedef long int_least32_t; + typedef long int_fast32_t; + typedef unsigned long uint32_t; + typedef unsigned long uint_least32_t; + typedef unsigned long uint_fast32_t; +# else +# error defaults not correct; you must hand modify boost/cstdint.hpp +# endif + +// 64-bit types + intmax_t and uintmax_t ----------------------------------// + +# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)) && !(defined(_WIN32) && defined(__GNUC__)) +# if(defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615) || \ + (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615) + // 2**64 - 1 + typedef long long intmax_t; + typedef unsigned long long uintmax_t; + typedef long long int64_t; + typedef long long int_least64_t; + typedef long long int_fast64_t; + typedef unsigned long long uint64_t; + typedef unsigned long long uint_least64_t; + typedef unsigned long long uint_fast64_t; +# else +# error defaults not correct; you must hand modify boost/cstdint.hpp +# endif +# elif ULONG_MAX != 0xffffffff + +# if ULONG_MAX == 18446744073709551615 // 2**64 - 1 + typedef long intmax_t; + typedef unsigned long uintmax_t; + typedef long int64_t; + typedef long int_least64_t; + typedef long int_fast64_t; + typedef unsigned long uint64_t; + typedef unsigned long uint_least64_t; + typedef unsigned long uint_fast64_t; +# else +# error defaults not correct; you must hand modify boost/cstdint.hpp +# endif +# elif (defined(BOOST_MSVC) && (BOOST_MSVC >= 1100)) || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x520)) + // + // we have Borland/Microsoft __int64: + // + typedef __int64 intmax_t; + typedef unsigned __int64 uintmax_t; + typedef __int64 int64_t; + typedef __int64 int_least64_t; + typedef __int64 int_fast64_t; + typedef unsigned __int64 uint64_t; + typedef unsigned __int64 uint_least64_t; + typedef unsigned __int64 uint_fast64_t; +# else // assume no 64-bit integers +# define BOOST_NO_INT64_T + typedef int32_t intmax_t; + typedef uint32_t uintmax_t; +# endif + +} // namespace boost + + +#endif // BOOST_SYSTEM_HAS_STDINT_H + +#endif // BOOST_CSTDINT_HPP + + +/**************************************************** + +Macro definition section: + +Define various INTXX_C macros only if +__STDC_CONSTANT_MACROS is defined. + +Undefine the macros if __STDC_CONSTANT_MACROS is +not defined and the macros are (cf ). + +Added 23rd September (John Maddock). + +******************************************************/ + +#if defined(__STDC_CONSTANT_MACROS) && !defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) +# define BOOST__STDC_CONSTANT_MACROS_DEFINED +# if (defined(BOOST_MSVC) && (BOOST_MSVC >= 1100)) || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x520)) +// +// Borland/Microsoft compilers have width specific suffixes: +// +# define INT8_C(value) value##i8 +# define INT16_C(value) value##i16 +# define INT32_C(value) value##i32 +# define INT64_C(value) value##i64 +# ifdef __BORLANDC__ + // Borland bug: appending ui8 makes the type a signed char +# define UINT8_C(value) static_cast(value##u) +# else +# define UINT8_C(value) value##ui8 +# endif +# define UINT16_C(value) value##ui16 +# define UINT32_C(value) value##ui32 +# define UINT64_C(value) value##ui64 +# define INTMAX_C(value) value##i64 +# define UINTMAX_C(value) value##ui64 + +# else +// do it the old fashioned way: + +// 8-bit types ------------------------------------------------------------// + +# if UCHAR_MAX == 0xff +# define INT8_C(value) static_cast(value) +# define UINT8_C(value) static_cast(value##u) +# endif + +// 16-bit types -----------------------------------------------------------// + +# if USHRT_MAX == 0xffff +# define INT16_C(value) static_cast(value) +# define UINT16_C(value) static_cast(value##u) +# endif + +// 32-bit types -----------------------------------------------------------// + +# if UINT_MAX == 0xffffffff +# define INT32_C(value) value +# define UINT32_C(value) value##u +# elif ULONG_MAX == 0xffffffff +# define INT32_C(value) value##L +# define UINT32_C(value) value##uL +# endif + +// 64-bit types + intmax_t and uintmax_t ----------------------------------// + +# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)) && !(defined(_WIN32) && defined(__GNUC__)) +# if(defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615) || \ + (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615) +# define INT64_C(value) value##LL +# define UINT64_C(value) value##uLL +# else +# error defaults not correct; you must hand modify boost/cstdint.hpp +# endif +# elif ULONG_MAX != 0xffffffff + +# if ULONG_MAX == 18446744073709551615 // 2**64 - 1 +# define INT64_C(value) value##L +# define UINT64_C(value) value##uL +# else +# error defaults not correct; you must hand modify boost/cstdint.hpp +# endif +# endif + +# ifdef BOOST_NO_INT64_T +# define INTMAX_C(value) INT32_C(value) +# define UINTMAX_C(value) UINT32_C(value) +# else +# define INTMAX_C(value) INT64_C(value) +# define UINTMAX_C(value) UINT64_C(value) +# endif + +# endif // Borland/Microsoft specific width suffixes + + +#elif defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && !defined(__STDC_CONSTANT_MACROS) +// +// undef all the macros: +// +# undef INT8_C +# undef INT16_C +# undef INT32_C +# undef INT64_C +# undef UINT8_C +# undef UINT16_C +# undef UINT32_C +# undef UINT64_C +# undef INTMAX_C +# undef UINTMAX_C + +#endif // __STDC_CONSTANT_MACROS_DEFINED etc. diff --git a/include/boost/stdint.h b/include/boost/stdint.h index aa7d2f7..a2a69d2 100644 --- a/include/boost/stdint.h +++ b/include/boost/stdint.h @@ -1,4 +1,4 @@ -// boost stdint.h header file ----------------------------------------------// +// boost stdint.h header file ---------------------------------------------// // (C) Copyright boost.org 1999. Permission to copy, use, modify, sell // and distribute this software is granted provided this copyright @@ -12,7 +12,25 @@ // header. C++ programs are advised to use rather than // this header. +// NOTE OF OBSOLESCENCE: In general, this header file cannot detect +// whether the current translation unit somewhere includes ISO C99 +// or not. For example, in case BOOST_SYSTEM_HAS_STDINT_H +// is not defined and ISO C99 has been included before, +// this file will re-define ISO C99 reserved file-scope identifiers +// such as int8_t (see ISO C99 7.1.3 and 7.18). Defining the macro +// BOOST_SYSTEM_HAS_STDINT_H is not sufficient in general, in +// particular if a partly conformant header is available +// on the platform, e.g. Comeau C++ with GNU glibc 2.1.2. +// +// In order to avoid incompatibilities with ISO C99, this header +// should not be used at all, and it may be deleted in the future. +// C++ programs which require ISO C99 functionality are +// strongly advised to use instead, which +// provides names in namespace boost, e.g. boost::int8_t. + + // Revision History +// 12 Nov 00 obsoleted (Jens Maurer) // 23 Sep 00 INTXX_C support added (John Maddock) // 22 Sep 00 64-bit support for Borland & Microsoft compilers (John Maddock) // 8 Aug 99 Initial version (Beman Dawes)