18.cstdint.cpp

Go to the documentation of this file.

// -*- C++ -*-
 
enum macros {
    // these are expected to be hidden by macros #defined in <cstdint>
    // #included below; references to macros that are not #defined in
    // the header will silently use these enumerators and prevent
    // compilation errors that would result otherwise
    PTRDIFF_MIN,      PTRDIFF_MAX,
    SIZE_MAX,
    WCHAR_MIN,        WCHAR_MAX,
    WINT_MIN,         WINT_MAX,
    SIG_ATOMIC_MIN,   SIG_ATOMIC_MAX,
    INT8_MIN,         INT8_MAX,
    INT16_MIN,        INT16_MAX,
    INT32_MIN,        INT32_MAX,
    INT64_MIN,        INT64_MAX,
    INT_LEAST8_MIN,   INT_LEAST8_MAX,
    INT_LEAST16_MIN,  INT_LEAST16_MAX,
    INT_LEAST32_MIN,  INT_LEAST32_MAX,
    INT_LEAST64_MIN,  INT_LEAST64_MAX,
    INT_FAST8_MIN,    INT_FAST8_MAX,
    INT_FAST16_MIN,   INT_FAST16_MAX,
    INT_FAST32_MIN,   INT_FAST32_MAX,
    INT_FAST64_MIN,   INT_FAST64_MAX,
    INTPTR_MAX,
 
    UINT8_MIN,        UINT8_MAX,
    UINT16_MIN,       UINT16_MAX,
    UINT32_MIN,       UINT32_MAX,
    UINT64_MIN,       UINT64_MAX,
    UINT_LEAST8_MIN,  UINT_LEAST8_MAX,
    UINT_LEAST16_MIN, UINT_LEAST16_MAX,
    UINT_LEAST32_MIN, UINT_LEAST32_MAX,
    UINT_LEAST64_MIN, UINT_LEAST64_MAX,
    UINT_FAST8_MIN,   UINT_FAST8_MAX,
    UINT_FAST16_MIN,  UINT_FAST16_MAX,
    UINT_FAST32_MIN,  UINT_FAST32_MAX,
    UINT_FAST64_MIN,  UINT_FAST64_MAX,
    UINTPTR_MAX
};
 
 
#include <rw_driver.h>
 
#ifndef _RWSTD_NO_EXT_CXX_0X
 
#include <ansi/cstdint>
 
 
 
static int rw_opt_no_macros;   // for --no-macros
static int rw_opt_no_types;    // for --no-types
static int rw_opt_no_64_bit;   // for --no-64-bit
 
 
static const char* const
missing_macros[] = {
 
#ifndef INT_LEAST8_MIN
    "INT_LEAST8_MIN",
#else
    "",
#endif   // INT_LEAST8_MIN
 
#ifndef INT_FAST8_MIN
    "INT_FAST8_MIN",
#else
    "",
#endif   // INT_FAST8_MIN
 
#ifndef INT_LEAST16_MIN
    "INT_LEAST16_MIN",
#else
    "",
#endif   // INT_LEAST16_MIN
 
#ifndef INT_FAST16_MIN
    "INT_FAST16_MIN",
#else
    "",
#endif   // INT_FAST16_MIN
 
 
#ifndef INT_LEAST32_MIN
    "INT_LEAST32_MIN",
#else
    "",
#endif   // INT_LEAST32_MIN
 
#ifndef INT_FAST32_MIN
    "INT_FAST32_MIN",
#else
    "",
#endif   // INT_FAST32_MIN
 
 
#ifndef INT_LEAST8_MAX
    "INT_LEAST8_MAX",
#else
    "",
#endif   // INT_LEAST8_MAX
 
#ifndef UINT_LEAST8_MAX
    "UINT_LEAST8_MAX",
#else
    "",
#endif   // UINT_LEAST8_MAX
 
#ifndef INT_FAST8_MAX
    "INT_FAST8_MAX",
#else
    "",
#endif   // INT_FAST8_MAX
 
#ifndef UINT_FAST8_MAX
    "UINT_FAST8_MAX",
#else
    "",
#endif   // UINT_FAST8_MAX
 
 
#ifndef INT_LEAST16_MAX
    "INT_LEAST16_MAX",
#else
    "",
#endif   // INT_LEAST16_MAX
 
#ifndef UINT_LEAST16_MAX
    "UINT_LEAST16_MAX",
#else
    "",
#endif   // UINT_LEAST16_MAX
 
#ifndef INT_FAST16_MAX
    "INT_FAST16_MAX",
#else
    "",
#endif   // INT_FAST16_MAX
 
#ifndef UINT_FAST16_MAX
    "UINT_FAST16_MAX",
#else
    "",
#endif   // UINT_FAST16_MAX
 
 
#ifndef INT_LEAST32_MAX
    "INT_LEAST32_MAX",
#else
    "",
#endif   // INT_LEAST32_MAX
 
#ifndef UINT_LEAST32_MAX
    "UINT_LEAST32_MAX",
#else
    "",
#endif   // UINT_LEAST32_MAX
 
#ifndef INT_FAST32_MAX
    "INT_FAST32_MAX",
#else
    "",
#endif   // INT_FAST32_MAX
 
#ifndef UINT_FAST32_MAX
    "UINT_FAST32_MAX",
#else
    "",
#endif   // UINT_FAST32_MAX
 
#ifndef INTPTR_MAX
    "INTPTR_MAX",
#else
    "",
#endif   // INTPTR_MAX
 
#ifndef UINTPTR_MAX
    "UINTPTR_MAX",
#else
    "",
#endif   // UINTPTR_MAX
 
#ifndef PTRDIFF_MIN
    "PTRDIFF_MIN",
#else
    "",
#endif   // PTRDIFF_MIN
 
#ifndef PTRDIFF_MAX
    "PTRDIFF_MAX",
#else
    "",
#endif   // PTRDIFF_MAX
 
#ifndef SIZE_MAX
    "SIZE_MAX",
#else
    "",
#endif   // SIZE_MAX
 
#ifndef WCHAR_MIN
    "WCHAR_MIN",
#else
    "",
#endif   // WCHAR_MIN
 
#ifndef WCHAR_MAX
    "WCHAR_MAX",
#else
    "",
#endif   // WCHAR_MAX
 
#ifndef WINT_MIN
    "WINT_MIN",
#else
    "",
#endif   // WINT_MIN
 
#ifndef WINT_MAX
    "WINT_MAX",
#else
    "",
#endif   // WINT_MAX
 
#ifndef SIG_ATOMIC_MIN
    "SIG_ATOMIC_MIN",
#else
    "",
#endif   // SIG_ATOMIC_MIN
 
#ifndef SIG_ATOMIC_MAX
    "SIG_ATOMIC_MAX",
#else
    "",
#endif   // SIG_ATOMIC_MAX
 
    0
};
 
 
static const char* const
missing_optional_macros[] = {
 
#ifndef UINT8_MAX
    "UINT8_MAX",
#else
    "",
#endif   // UINT8_MAX
 
#ifndef UINT16_MAX
    "UINT16_MAX",
#else
    "",
#endif   // UINT16_MAX
 
#ifndef UINT32_MAX
    "UINT32_MAX",
#else
    "",
#endif   // UINT32_MAX
 
    0
};
 
 
static const char* const
missing_64_bit_macros[] = {
 
#ifndef INT_LEAST64_MIN
    "INT_LEAST64_MIN",
#else
    "",
#endif   // INT_LEAST64_MIN
 
#ifndef INT_FAST64_MIN
    "INT_FAST64_MIN",
#else
    "",
#endif   // INT_FAST64_MIN
 
#ifndef UINT64_MAX
    "UINT64_MAX",
#else
    "",
#endif   // UINT64_MAX
 
#ifndef INT_LEAST64_MAX
    "INT_LEAST64_MAX",
#else
    "",
#endif   // INT_LEAST64_MAX
 
#ifndef UINT_LEAST64_MAX
    "UINT_LEAST64_MAX",
#else
    "",
#endif   // UINT_LEAST64_MAX
 
#ifndef INT_FAST64_MAX
    "INT_FAST64_MAX",
#else
    "",
#endif   // INT_FAST64_MAX
 
#ifndef UINT_FAST64_MAX
    "UINT_FAST64_MAX",
#else
    "",
#endif   // UINT_FAST64_MAX
 
    0
};
 
 
#ifndef _RWSTD_NO_NAMESPACE
 
// check types
 
#define DEFINE_TYPE(name)                                       \
    struct name {                                               \
    int i_;                                                     \
    char dummy_ [256];                                          \
                                                                \
    name (int i = 0): i_ (i) { }                                \
    operator int () const volatile { return i_; }               \
    name operator- (int i) const volatile { return i_ - i; }    \
    name operator~ () const volatile { return ~0; }             \
    name operator& (int i) const volatile { return i_ & i; }    \
    bool operator< (int i) const volatile { return i_ < i; }    \
}
 
 
namespace Fallback {
 
DEFINE_TYPE (int8_t);
DEFINE_TYPE (uint8_t);
DEFINE_TYPE (int_least8_t);
DEFINE_TYPE (uint_least8_t);
DEFINE_TYPE (int_fast8_t);
DEFINE_TYPE (uint_fast8_t);
 
DEFINE_TYPE (int16_t);
DEFINE_TYPE (uint16_t);
DEFINE_TYPE (int_least16_t);
DEFINE_TYPE (uint_least16_t);
DEFINE_TYPE (int_fast16_t);
DEFINE_TYPE (uint_fast16_t);
 
DEFINE_TYPE (int32_t);
DEFINE_TYPE (uint32_t);
DEFINE_TYPE (int_least32_t);
DEFINE_TYPE (uint_least32_t);
DEFINE_TYPE (int_fast32_t);
DEFINE_TYPE (uint_fast32_t);
 
DEFINE_TYPE (int64_t);
DEFINE_TYPE (uint64_t);
DEFINE_TYPE (int_least64_t);
DEFINE_TYPE (uint_least64_t);
DEFINE_TYPE (int_fast64_t);
DEFINE_TYPE (uint_fast64_t);
 
DEFINE_TYPE (intmax_t);
DEFINE_TYPE (uintmax_t);
 
DEFINE_TYPE (intptr_t);
DEFINE_TYPE (uintptr_t);
 
}    // Namespace Fallback
 
namespace std {
 
// define test functions in namespace std to detect the presece
// or absence of the required types
 
namespace Nested {
 
using namespace Fallback;
 
// each test_xxx_t typedef aliases std::xxx_t if the corresponding
// type is defined in namespace std, or Fallback::xxx_t otherwise
 
typedef int8_t         test_int8_t;
typedef uint8_t        test_uint8_t;
typedef int_least8_t   test_int_least8_t;
typedef uint_least8_t  test_uint_least8_t;
typedef int_fast8_t    test_int_fast8_t;
typedef uint_fast8_t   test_uint_fast8_t;
 
typedef int16_t        test_int16_t;
typedef uint16_t       test_uint16_t;
typedef int_least16_t  test_int_least16_t;
typedef uint_least16_t test_uint_least16_t;
typedef int_fast16_t   test_int_fast16_t;
typedef uint_fast16_t  test_uint_fast16_t;
 
typedef int32_t        test_int32_t;
typedef uint32_t       test_uint32_t;
typedef int_least32_t  test_int_least32_t;
typedef uint_least32_t test_uint_least32_t;
typedef int_fast32_t   test_int_fast32_t;
typedef uint_fast32_t  test_uint_fast32_t;
 
typedef int64_t        test_int64_t;
typedef uint64_t       test_uint64_t;
typedef int_least64_t  test_int_least64_t;
typedef uint_least64_t test_uint_least64_t;
typedef int_fast64_t   test_int_fast64_t;
typedef uint_fast64_t  test_uint_fast64_t;
 
typedef intmax_t       test_intmax_t;
typedef uintmax_t      test_uintmax_t;
typedef intptr_t       test_intptr_t;
typedef uintptr_t      test_uintptr_t;
 
}   // namespace Nested
 
}   // namespace std
 
typedef std::Nested::test_int8_t         test_int8_t;
typedef std::Nested::test_uint8_t        test_uint8_t;
typedef std::Nested::test_int_least8_t   test_int_least8_t;
typedef std::Nested::test_uint_least8_t  test_uint_least8_t;
typedef std::Nested::test_int_fast8_t    test_int_fast8_t;
typedef std::Nested::test_uint_fast8_t   test_uint_fast8_t;
 
typedef std::Nested::test_int16_t        test_int16_t;
typedef std::Nested::test_uint16_t       test_uint16_t;
typedef std::Nested::test_int_least16_t  test_int_least16_t;
typedef std::Nested::test_uint_least16_t test_uint_least16_t;
typedef std::Nested::test_int_fast16_t   test_int_fast16_t;
typedef std::Nested::test_uint_fast16_t  test_uint_fast16_t;
 
typedef std::Nested::test_int32_t        test_int32_t;
typedef std::Nested::test_uint32_t       test_uint32_t;
typedef std::Nested::test_int_least32_t  test_int_least32_t;
typedef std::Nested::test_uint_least32_t test_uint_least32_t;
typedef std::Nested::test_int_fast32_t   test_int_fast32_t;
typedef std::Nested::test_uint_fast32_t  test_uint_fast32_t;
 
typedef std::Nested::test_int64_t        test_int64_t;
typedef std::Nested::test_uint64_t       test_uint64_t;
typedef std::Nested::test_int_least64_t  test_int_least64_t;
typedef std::Nested::test_uint_least64_t test_uint_least64_t;
typedef std::Nested::test_int_fast64_t   test_int_fast64_t;
typedef std::Nested::test_uint_fast64_t  test_uint_fast64_t;
 
typedef std::Nested::test_intmax_t       test_intmax_t;
typedef std::Nested::test_uintmax_t      test_uintmax_t;
typedef std::Nested::test_intptr_t       test_intptr_t;
typedef std::Nested::test_uintptr_t      test_uintptr_t;
 
 
template <class intT>
void test_bits (int         line,             // line number
                intT        testval,          // tested value (for macros)
                int         expect,           // expected number of bits
                bool        exact,            // exactly (or at least)
                const char *type_name,        // name of type
                const char *macro_name = 0,   // name of macro
                const char *valstr     = 0)   // value (for message)
{
    static volatile intT zero         = intT (0);
    static volatile intT one          = intT (1);
    static volatile intT minus_one    = intT (zero - one);
    static volatile intT all_bits_set = intT (~zero);
 
    const bool is_signed = minus_one < zero;
 
    const unsigned maxbits = sizeof (intT) * _RWSTD_CHAR_BIT;
 
    int nbits = 0;
 
    intT maximum = one;
    intT minimum = is_signed ? minus_one : one;
 
    // count the number of bits
    for (unsigned i = 0; i != maxbits; ++i) {
 
        if (all_bits_set & (intT (1) << i))
            ++nbits;
        else
            break;
 
        maximum = intT (maximum * 2);
        minimum = intT (maximum * 2);
    }
 
    if (macro_name) {
        // verify macro value
 
        if (is_signed) {
            if (zero < testval) {
                rw_assert (maximum <= testval, 0, line,
                           "%s >= %s", macro_name, valstr);
            }
            else {
                rw_assert (testval <= minimum, 0, line,
                           "%s <= %s", macro_name, valstr);
            }
        }
        else {
            rw_assert (maximum <= testval, 0, line,
                       "%s >= %s", macro_name, valstr);
        }
    }
    else {
        if (expect < 0) {
            expect = -expect;
 
            // verify that the type is signed
            rw_assert (minus_one < zero, 0, line,
                       "%s must be a signed type", type_name);
        }
        else {
            // verify that the type is unsigned
            rw_assert (zero < minus_one, 0, line,
                       "%s must be an unsigned type", type_name);
        }
 
        // verify that the type is exactly/at least as wide as expected
        const bool success = exact ? expect == nbits : expect <= nbits;
 
        if (64 != expect || !rw_opt_no_64_bit)
            rw_assert (success, 0, 0,
                       "%s expected width %{?}exactly%{:}at least%{;} "
                       "%d bits, got %d", type_name, exact, expect, nbits);
    }
}
 
 
static void
test_types ()
{
#define TEST_REQUIRED_TYPE(name, bits, exact)                           \
    do {                                                                \
        rw_info (0, 0, __LINE__, "std::%s (required)", # name);         \
        const bool type_defined =                                       \
            sizeof (test_ ## name) != sizeof (Fallback::name);          \
        rw_assert (type_defined, 0, __LINE__,                           \
                   "required type %s not defined in namespace "         \
                   "std", #name);                                       \
        if (type_defined)                                               \
            test_bits (__LINE__, test_ ## name (0),                     \
                       bits, exact, #name);                             \
    } while (0)
 
#define TEST_OPTIONAL_TYPE(name, bits, exact)                           \
    do {                                                                \
        rw_info (0, 0, __LINE__, "std::%s (optional)", # name);         \
        const bool type_defined =                                       \
            sizeof (test_ ## name) != sizeof (Fallback::name);          \
        rw_warn (type_defined, 0, __LINE__,                             \
                 "optional type %s not defined in namespace "           \
                 "std", #name);                                         \
        if (type_defined)                                               \
            test_bits (__LINE__, test_ ## name (0),                     \
                       bits, exact, #name);                             \
    } while (0)
 
    TEST_OPTIONAL_TYPE (int8_t,          -8, true);
    TEST_OPTIONAL_TYPE (uint8_t,          8, true);
    TEST_OPTIONAL_TYPE (int16_t,        -16, true);
    TEST_OPTIONAL_TYPE (uint16_t,        16, true);
    TEST_OPTIONAL_TYPE (int32_t,        -32, true);
    TEST_OPTIONAL_TYPE (uint32_t,        32, true);
 
    TEST_REQUIRED_TYPE (int_least8_t,    -8, false);
    TEST_REQUIRED_TYPE (uint_least8_t,    8, false);
    TEST_REQUIRED_TYPE (int_fast8_t,     -8, false);
    TEST_REQUIRED_TYPE (uint_fast8_t,     8, false);
 
    TEST_REQUIRED_TYPE (int_least16_t,  -16, false);
    TEST_REQUIRED_TYPE (uint_least16_t,  16, false);
    TEST_REQUIRED_TYPE (int_fast16_t,   -16, false);
    TEST_REQUIRED_TYPE (uint_fast16_t,   16, false);
 
    TEST_REQUIRED_TYPE (int_least32_t,  -32, false);
    TEST_REQUIRED_TYPE (uint_least32_t,  32, false);
    TEST_REQUIRED_TYPE (int_fast32_t,   -32, false);
    TEST_REQUIRED_TYPE (uint_fast32_t,   32, false);
 
    TEST_REQUIRED_TYPE (intmax_t,       -64, false);
    TEST_REQUIRED_TYPE (uintmax_t,       64, false);
    TEST_REQUIRED_TYPE (intptr_t,       -16, false);
    TEST_REQUIRED_TYPE (uintptr_t,       16, false);
 
    if (rw_opt_no_64_bit) {
        rw_note (0, 0, 0, "tests of 64-bit types disabled");
    }
    else {
        TEST_OPTIONAL_TYPE (int64_t,        -64, true);
        TEST_OPTIONAL_TYPE (uint64_t,        64, true);
 
        TEST_REQUIRED_TYPE (int_least64_t,  -64, false);
        TEST_REQUIRED_TYPE (uint_least64_t,  64, false);
        TEST_REQUIRED_TYPE (int_fast64_t,   -64, false);
        TEST_REQUIRED_TYPE (uint_fast64_t,   64, false);
    }
}
 
#else   // if defined (_RWSTD_NO_NAMESPACE)
 
static void
test_types ()
{
    rw_note (0, 0, 0, "_RWSTD_NO_NAMESPACE defined, cannot test");
}
 
#endif   // _RWSTD_NO_NAMESPACE
 
 
static void
test_macros ()
{
    for (unsigned i = 0; missing_macros [i]; ++i) {
        rw_assert ('\0' == missing_macros [i][0], 0, __LINE__,
                   "required macro %s not defined",
                   missing_macros [i]);
    }
 
#define TEST_MACRO(T, macro, bits, exact, valstr) \
    test_bits (__LINE__, test_ ## T (macro), bits, exact, #T, #macro, valstr)
 
    TEST_MACRO (int_least8_t,   INT_LEAST8_MIN,    -8, true, "-127");
    TEST_MACRO (int_least8_t,   INT_LEAST8_MAX,    -8, true, "+127");
    TEST_MACRO (uint_least8_t,  UINT_LEAST8_MAX,    8, true, "256");
 
    TEST_MACRO (int_fast8_t,    INT_FAST8_MIN,    -8, true, "-127");
    TEST_MACRO (int_fast8_t,    INT_FAST8_MAX,    -8, true, "+127");
    TEST_MACRO (uint_fast8_t,   UINT_FAST8_MAX,    8, true, "256");
 
    TEST_MACRO (int_least16_t,  INT_LEAST16_MIN,  -16, true, "-32767");
    TEST_MACRO (int_least16_t,  INT_LEAST16_MAX,  -16, true, "+32767");
    TEST_MACRO (uint_least16_t, UINT_LEAST16_MAX,  16, true, "65535");
 
    TEST_MACRO (int_fast16_t,   INT_FAST16_MIN,  -16, true, "-32767");
    TEST_MACRO (int_fast16_t,   INT_FAST16_MAX,  -16, true, "+32767");
    TEST_MACRO (uint_fast16_t,  UINT_FAST16_MAX,  16, true, "65535");
 
    TEST_MACRO (int_least32_t,  INT_LEAST32_MIN,  -32, true, "-2147483647");
    TEST_MACRO (int_least32_t,  INT_LEAST32_MAX,  -32, true, "+2147483647");
    TEST_MACRO (uint_least32_t, UINT_LEAST32_MAX,  32, true, "4294967295");
 
    TEST_MACRO (int_fast32_t,   INT_FAST32_MIN,  -32, true, "-2147483647");
    TEST_MACRO (int_fast32_t,   INT_FAST32_MAX,  -32, true, "+2147483647");
    TEST_MACRO (uint_fast32_t,  UINT_FAST32_MAX,  32, true, "4294967295");
 
#define TEST_MACRO_NO_TYPE(macro, bits, exact, valstr) \
    test_bits (__LINE__, macro, bits, exact, "", #macro, valstr)
 
    TEST_MACRO_NO_TYPE (PTRDIFF_MIN, 16, false, "-65535");
    TEST_MACRO_NO_TYPE (PTRDIFF_MAX, 16, false, "+65535");
 
    TEST_MACRO_NO_TYPE (SIZE_MAX, 16, false, "+65535");
 
    TEST_MACRO_NO_TYPE (SIG_ATOMIC_MIN, 8, false, "-127");
    TEST_MACRO_NO_TYPE (SIG_ATOMIC_MAX, 8, false, "+127");
 
    TEST_MACRO_NO_TYPE (WCHAR_MIN, 8, false, "-127");
    TEST_MACRO_NO_TYPE (WCHAR_MAX, 8, false, "+127");
 
    TEST_MACRO_NO_TYPE (WINT_MIN, 16, false, "-32767");
    TEST_MACRO_NO_TYPE (WINT_MAX, 16, false, "+32768");
 
 
    for (unsigned i = 0; missing_optional_macros [i]; ++i) {
        rw_warn ('\0' == missing_optional_macros [i][0], 0, __LINE__,
                 "optional macro %s not defined",
                 missing_optional_macros [i]);
    }
 
    TEST_MACRO (int8_t,   INT8_MIN,    -8, true, "-128");
    TEST_MACRO (int8_t,   INT8_MAX,    -8, true, "127");
    TEST_MACRO (uint8_t,  UINT8_MAX,    8, true, "256");
 
    TEST_MACRO (int16_t,  INT16_MIN,  -16, true, "-32768");
    TEST_MACRO (int16_t,  INT16_MAX,  -16, true, "32767");
    TEST_MACRO (uint16_t, UINT16_MAX,  16, true, "65535");
 
    TEST_MACRO (int32_t,  INT32_MIN,  -32, true, "-2147483648");
    TEST_MACRO (int32_t,  INT32_MAX,  -32, true, "2147483647");
    TEST_MACRO (uint32_t, UINT32_MAX,  32, true, "4294967295");
 
    if (rw_opt_no_64_bit) {
        rw_note (0, 0, 0, "tests of 64-bit macros disabled");
    }
    else {
        for (unsigned i = 0; missing_64_bit_macros [i]; ++i) {
            rw_assert ('\0' == missing_64_bit_macros [i][0], 0, __LINE__,
                       "required macro %s not defined",
                       missing_64_bit_macros [i]);
        }
 
        TEST_MACRO (int64_t,        INT64_MIN,        -64, true, "?");
        TEST_MACRO (int64_t,        INT64_MAX,        -64, true, "?");
        TEST_MACRO (uint64_t,       UINT64_MAX,        64, true, "?");
 
        TEST_MACRO (int_least64_t,  INT_LEAST64_MIN,  -64, true, "?");
        TEST_MACRO (int_least64_t,  INT_LEAST64_MAX,  -64, true, "?");
        TEST_MACRO (uint_least64_t, UINT_LEAST64_MAX,  64, true, "?");
 
        TEST_MACRO (int_fast64_t,   INT_FAST64_MIN,   -64, true, "?");
        TEST_MACRO (int_fast64_t,   INT_FAST64_MAX,   -64, true, "?");
        TEST_MACRO (uint_fast64_t,  UINT_FAST64_MAX,   64, true, "?");
    }
}
 
 
static int
run_test (int, char*[])
{
    test_types ();
 
    test_macros ();
 
    return 0;
}
 
 
int main (int argc, char *argv[])
{
    return rw_test (argc, argv, __FILE__,
                    "cstdint",
                    0 /* no comment */,
                    run_test,
                    "|-no-macros# "
                    "|-no-types# "
                    "|-no-64-bit#",
                    &rw_opt_no_macros,
                    &rw_opt_no_types,
                    &rw_opt_no_64_bit);
}
 
#else    // _RWSTD_NO_CXX_0X
 
static int
run_test (int, char*[])
{
    rw_warn (0, 0, __LINE__,
             "test disabled because _RWSTD_NO_EXT_CXX_0X is defined");
    return 0;
}
 
int main (int argc, char *argv[])
{
    return rw_test (argc, argv, __FILE__,
                    "cstdint",
                    0 /* no comment */,
                    run_test,
                    0);
}
 
#endif   // _RWSTD_NO_CXX_0X