test: epoc32/include/stdapis/boost/cstdint.hpp@837f303aceeb

     1 //  boost cstdint.hpp header file  ------------------------------------------//

     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)

    10 //  See http://www.boost.org/libs/integer for documentation.

    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)

    23 #ifndef BOOST_CSTDINT_HPP

    24 #define BOOST_CSTDINT_HPP

    26 #include <boost/config.hpp>

    29 #ifdef BOOST_HAS_STDINT_H

    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>

    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

    52 # endif

    54 #ifdef __QNX__

    56 // QNX (Dinkumware stdlib) defines these as non-standard names.

    57 // Reflect to the standard names.

    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;

    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;

    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;

    74 # ifndef BOOST_NO_INT64_T

    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;

    81 # endif

    83 #endif

    85 namespace boost

    86 {

    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;

    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;

   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;

   109 # ifndef BOOST_NO_INT64_T

   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;

   118 # endif

   120   using ::intmax_t;

   121   using ::uintmax_t;

   123 } // namespace boost

   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>

   129 namespace boost {

   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;

   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;

   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;

   152 # ifndef BOOST_NO_INT64_T

   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;

   161   typedef int64_t intmax_t;

   162   typedef uint64_t uintmax_t;

   164 # else

   166   typedef int32_t intmax_t;

   167   typedef uint32_t uintmax_t;

   169 # endif

   171 } // namespace boost

   173 #else  // BOOST_HAS_STDINT_H

   175 # include <boost/limits.hpp> // implementation artifact; not part of interface

   176 # include <limits.h>         // needed for limits macros

   179 namespace boost

   180 {

   182 //  These are fairly safe guesses for some 16-bit, and most 32-bit and 64-bit

   183 //  platforms.  For other systems, they will have to be hand tailored.

   184 //

   185 //  Because the fast types are assumed to be the same as the undecorated types,

   186 //  it may be possible to hand tailor a more efficient implementation.  Such

   187 //  an optimization may be illusionary; on the Intel x86-family 386 on, for

   188 //  example, byte arithmetic and load/stores are as fast as "int" sized ones.

   190 //  8-bit types  ------------------------------------------------------------//

   192 # if UCHAR_MAX == 0xff

   193      typedef signed char     int8_t;

   194      typedef signed char     int_least8_t;

   195      typedef signed char     int_fast8_t;

   196      typedef unsigned char   uint8_t;

   197      typedef unsigned char   uint_least8_t;

   198      typedef unsigned char   uint_fast8_t;

   199 # else

   200 #    error defaults not correct; you must hand modify boost/cstdint.hpp

   201 # endif

   203 //  16-bit types  -----------------------------------------------------------//

   205 # if USHRT_MAX == 0xffff

   206 #  if defined(__crayx1)

   207      // The Cray X1 has a 16-bit short, however it is not recommend

   208      // for use in performance critical code.

   209      typedef short           int16_t;

   210      typedef short           int_least16_t;

   211      typedef int             int_fast16_t;

   212      typedef unsigned short  uint16_t;

   213      typedef unsigned short  uint_least16_t;

   214      typedef unsigned int    uint_fast16_t;

   215 #  else

   216      typedef short           int16_t;

   217      typedef short           int_least16_t;

   218      typedef short           int_fast16_t;

   219      typedef unsigned short  uint16_t;

   220      typedef unsigned short  uint_least16_t;

   221      typedef unsigned short  uint_fast16_t;

   222 #  endif

   223 # elif (USHRT_MAX == 0xffffffff) && defined(CRAY)

   224      // no 16-bit types on Cray:

   225      typedef short           int_least16_t;

   226      typedef short           int_fast16_t;

   227      typedef unsigned short  uint_least16_t;

   228      typedef unsigned short  uint_fast16_t;

   229 # else

   230 #    error defaults not correct; you must hand modify boost/cstdint.hpp

   231 # endif

   233 //  32-bit types  -----------------------------------------------------------//

   235 # if ULONG_MAX == 0xffffffff

   236      typedef long            int32_t;

   237      typedef long            int_least32_t;

   238      typedef long            int_fast32_t;

   239      typedef unsigned long   uint32_t;

   240      typedef unsigned long   uint_least32_t;

   241      typedef unsigned long   uint_fast32_t;

   242 # elif UINT_MAX == 0xffffffff

   243      typedef int             int32_t;

   244      typedef int             int_least32_t;

   245      typedef int             int_fast32_t;

   246      typedef unsigned int    uint32_t;

   247      typedef unsigned int    uint_least32_t;

   248      typedef unsigned int    uint_fast32_t;

   249 # else

   250 #    error defaults not correct; you must hand modify boost/cstdint.hpp

   251 # endif

   253 //  64-bit types + intmax_t and uintmax_t  ----------------------------------//

   255 # if defined(BOOST_HAS_LONG_LONG) && \

   256    !defined(BOOST_MSVC) && !defined(__BORLANDC__) && \

   257    (!defined(__GLIBCPP__) || defined(_GLIBCPP_USE_LONG_LONG)) && \

   258    (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))

   259 #    if defined(__hpux)

   260      // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions

   261 #    elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) || (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) || (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL)

   262                                                                  // 2**64 - 1

   263 #    else

   264 #       error defaults not correct; you must hand modify boost/cstdint.hpp

   265 #    endif

   267      typedef  ::boost::long_long_type            intmax_t;

   268      typedef  ::boost::ulong_long_type   uintmax_t;

   269      typedef  ::boost::long_long_type            int64_t;

   270      typedef  ::boost::long_long_type            int_least64_t;

   271      typedef  ::boost::long_long_type            int_fast64_t;

   272      typedef  ::boost::ulong_long_type   uint64_t;

   273      typedef  ::boost::ulong_long_type   uint_least64_t;

   274      typedef  ::boost::ulong_long_type   uint_fast64_t;

   276 # elif ULONG_MAX != 0xffffffff

   278 #    if ULONG_MAX == 18446744073709551615 // 2**64 - 1

   279      typedef long                 intmax_t;

   280      typedef unsigned long        uintmax_t;

   281      typedef long                 int64_t;

   282      typedef long                 int_least64_t;

   283      typedef long                 int_fast64_t;

   284      typedef unsigned long        uint64_t;

   285      typedef unsigned long        uint_least64_t;

   286      typedef unsigned long        uint_fast64_t;

   287 #    else

   288 #       error defaults not correct; you must hand modify boost/cstdint.hpp

   289 #    endif

   290 # elif defined(__GNUC__) && defined(BOOST_HAS_LONG_LONG)

   291      __extension__ typedef long long            intmax_t;

   292      __extension__ typedef unsigned long long   uintmax_t;

   293      __extension__ typedef long long            int64_t;

   294      __extension__ typedef long long            int_least64_t;

   295      __extension__ typedef long long            int_fast64_t;

   296      __extension__ typedef unsigned long long   uint64_t;

   297      __extension__ typedef unsigned long long   uint_least64_t;

   298      __extension__ typedef unsigned long long   uint_fast64_t;

   299 # elif defined(BOOST_HAS_MS_INT64)

   300      //

   301      // we have Borland/Intel/Microsoft __int64:

   302      //

   303      typedef __int64             intmax_t;

   304      typedef unsigned __int64    uintmax_t;

   305      typedef __int64             int64_t;

   306      typedef __int64             int_least64_t;

   307      typedef __int64             int_fast64_t;

   308      typedef unsigned __int64    uint64_t;

   309      typedef unsigned __int64    uint_least64_t;

   310      typedef unsigned __int64    uint_fast64_t;

   311 # else // assume no 64-bit integers

   312 #  define BOOST_NO_INT64_T

   313      typedef int32_t              intmax_t;

   314      typedef uint32_t             uintmax_t;

   315 # endif

   317 } // namespace boost

   320 #endif // BOOST_HAS_STDINT_H

   322 #endif // BOOST_CSTDINT_HPP

   325 /****************************************************

   327 Macro definition section:

   329 Define various INTXX_C macros only if

   330 __STDC_CONSTANT_MACROS is defined.

   332 Undefine the macros if __STDC_CONSTANT_MACROS is

   333 not defined and the macros are (cf <cassert>).

   335 Added 23rd September 2000 (John Maddock).

   336 Modified 11th September 2001 to be excluded when

   337 BOOST_HAS_STDINT_H is defined (John Maddock).

   339 ******************************************************/

   341 #if defined(__STDC_CONSTANT_MACROS) && !defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && !defined(BOOST_HAS_STDINT_H)

   342 # define BOOST__STDC_CONSTANT_MACROS_DEFINED

   343 # if defined(BOOST_HAS_MS_INT64)

   344 //

   345 // Borland/Intel/Microsoft compilers have width specific suffixes:

   346 //

   347 #  define INT8_C(value)     value##i8

   348 #  define INT16_C(value)    value##i16

   349 #  define INT32_C(value)    value##i32

   350 #  define INT64_C(value)    value##i64

   351 #  ifdef __BORLANDC__

   352     // Borland bug: appending ui8 makes the type a signed char

   353 #   define UINT8_C(value)    static_cast<unsigned char>(value##u)

   354 #  else

   355 #   define UINT8_C(value)    value##ui8

   356 #  endif

   357 #  define UINT16_C(value)   value##ui16

   358 #  define UINT32_C(value)   value##ui32

   359 #  define UINT64_C(value)   value##ui64

   360 #  define INTMAX_C(value)   value##i64

   361 #  define UINTMAX_C(value)  value##ui64

   363 # else

   364 //  do it the old fashioned way:

   366 //  8-bit types  ------------------------------------------------------------//

   368 #  if UCHAR_MAX == 0xff

   369 #   define INT8_C(value) static_cast<boost::int8_t>(value)

   370 #   define UINT8_C(value) static_cast<boost::uint8_t>(value##u)

   371 #  endif

   373 //  16-bit types  -----------------------------------------------------------//

   375 #  if USHRT_MAX == 0xffff

   376 #   define INT16_C(value) static_cast<boost::int16_t>(value)

   377 #   define UINT16_C(value) static_cast<boost::uint16_t>(value##u)

   378 #  endif

   380 //  32-bit types  -----------------------------------------------------------//

   382 #  if UINT_MAX == 0xffffffff

   383 #   define INT32_C(value) value

   384 #   define UINT32_C(value) value##u

   385 #  elif ULONG_MAX == 0xffffffff

   386 #   define INT32_C(value) value##L

   387 #   define UINT32_C(value) value##uL

   388 #  endif

   390 //  64-bit types + intmax_t and uintmax_t  ----------------------------------//

   392 #  if defined(BOOST_HAS_LONG_LONG) && \

   393     (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))

   395 #    if defined(__hpux)

   396      // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions

   397 #    elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615U) ||  \

   398         (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615U) ||  \

   399         (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615U)

   401 #    else

   402 #       error defaults not correct; you must hand modify boost/cstdint.hpp

   403 #    endif

   404 #    define INT64_C(value) value##LL

   405 #    define UINT64_C(value) value##uLL

   406 #  elif ULONG_MAX != 0xffffffff

   408 #    if ULONG_MAX == 18446744073709551615 // 2**64 - 1

   409 #       define INT64_C(value) value##L

   410 #       define UINT64_C(value) value##uL

   411 #    else

   412 #       error defaults not correct; you must hand modify boost/cstdint.hpp

   413 #    endif

   414 #  endif

   416 #  ifdef BOOST_NO_INT64_T

   417 #   define INTMAX_C(value) INT32_C(value)

   418 #   define UINTMAX_C(value) UINT32_C(value)

   419 #  else

   420 #   define INTMAX_C(value) INT64_C(value)

   421 #   define UINTMAX_C(value) UINT64_C(value)

   422 #  endif

   424 # endif // Borland/Microsoft specific width suffixes

   427 #elif defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && !defined(__STDC_CONSTANT_MACROS) && !defined(BOOST_HAS_STDINT_H)

   428 //

   429 // undef all the macros:

   430 //

   431 # undef INT8_C

   432 # undef INT16_C

   433 # undef INT32_C

   434 # undef INT64_C

   435 # undef UINT8_C

   436 # undef UINT16_C

   437 # undef UINT32_C

   438 # undef UINT64_C

   439 # undef INTMAX_C

   440 # undef UINTMAX_C

   442 #endif // __STDC_CONSTANT_MACROS_DEFINED etc.

author	William Roberts <williamr@symbian.org>
	Wed, 31 Mar 2010 12:33:34 +0100
branch	Symbian3
changeset 4	837f303aceeb
permissions	-rw-r--r--