stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From se...@apache.org
Subject svn commit: r373631 - in /incubator/stdcxx/trunk: include/tr1/cstdint tests/tr1.c99/ tests/tr1.c99/8.cstdint.cpp
Date Mon, 30 Jan 2006 23:30:14 GMT
Author: sebor
Date: Mon Jan 30 15:30:07 2006
New Revision: 373631

URL: http://svn.apache.org/viewcvs?rev=373631&view=rev
Log:
2006-01-30  Martin Sebor  <sebor@roguewave.com>

	STDCXX-34
	* cstdint: Simplified.
	* 8.cstdint.cpp: New test exercising tr.c99.cstdint.

Added:
    incubator/stdcxx/trunk/tests/tr1.c99/
    incubator/stdcxx/trunk/tests/tr1.c99/8.cstdint.cpp   (with props)
Modified:
    incubator/stdcxx/trunk/include/tr1/cstdint

Modified: incubator/stdcxx/trunk/include/tr1/cstdint
URL: http://svn.apache.org/viewcvs/incubator/stdcxx/trunk/include/tr1/cstdint?rev=373631&r1=373630&r2=373631&view=diff
==============================================================================
--- incubator/stdcxx/trunk/include/tr1/cstdint (original)
+++ incubator/stdcxx/trunk/include/tr1/cstdint Mon Jan 30 15:30:07 2006
@@ -48,27 +48,19 @@
 
 #ifdef _RWSTD_INT8_T
 
+// optional exact width types
 typedef _RWSTD_INT8_T       int8_t;
 typedef _RWSTD_UINT8_T      uint8_t;
-typedef _RWSTD_INT8_T       int_least8_t;
-typedef _RWSTD_UINT8_T      uint_least8_t;
-typedef _RWSTD_INT8_T       int_fast8_t;
-typedef _RWSTD_UINT8_T      uint_lfast8_t;
 
 #  define INT8_MAX          127
 #  define UINT8_MAX         255U
-#  define INT_LEAST8_MAX    127
-#  define UINT_LEAST8_MAX   255U
-#  define INT_FAST8_MAX     127
-#  define UINT_FAST8_MAX    255U
+#  define INT_LEAST8_MAX    INT8_MAX
+#  define UINT_LEAST8_MAX   UINT8_MAX
+#  define INT_FAST8_MAX     INT8_MAX
+#  define UINT_FAST8_MAX    UINT8_MAX
 
 #elif defined (_RWSTD_INT16_T)
 
-typedef _RWSTD_INT16_T      int_least8_t;
-typedef _RWSTD_UINT16_T     uint_least8_t;
-typedef _RWSTD_INT16_T      int_fast8_t;
-typedef _RWSTD_UINT16_T     uint_fast8_t;
-
 #  define INT_LEAST8_MAX    32767
 #  define UINT_LEAST8_MAX   65535U
 #  define INT_FAST8_MAX     32767
@@ -76,23 +68,20 @@
 
 #elif defined (_RWSTD_INT32_T)
 
-typedef _RWSTD_INT32_T      int_least8_t;
-typedef _RWSTD_UINT32_T     uint_least8_t
-typedef _RWSTD_INT32_T      int_fast8_t;
-typedef _RWSTD_UINT32_T     uint_fast8_t
-
-#  define INT_LEAST8_MAX    2147483647
-#  define UINT_LEAST8_MAX   4294967295U
-#  define INT_FAST8_MAX     2147483647
-#  define UINT_FAST8_MAX    4294967295U
+#  if 4 == _RWSTD_INT_SIZE
+#    define INT_LEAST8_MAX    _RWSTD_INT_MAX
+#    define UINT_LEAST8_MAX   _RWSTD_UINT_MAX
+#    define INT_FAST8_MAX     _RWSTD_INT_MAX
+#    define UINT_FAST8_MAX    _RWSTD_UINT_MAX
+#  elif 4 == _RWSTD_LONG_SIZE
+#    define INT_LEAST8_MAX    _RWSTD_LONG_MAX
+#    define UINT_LEAST8_MAX   _RWSTD_ULONG_MAX
+#    define INT_FAST8_MAX     _RWSTD_LONG_MAX
+#    define UINT_FAST8_MAX    _RWSTD_ULONG_MAX
+#  endif
 
 #elif defined (_RWSTD_INT64_T)
 
-typedef _RWSTD_INT64_T      int_least8_t;
-typedef _RWSTD_UINT64_T     uint_least8_t
-typedef _RWSTD_INT64_T      int_fast8_t;
-typedef _RWSTD_UINT64_T     uint_fast8_t
-
 #  if 8 == _RWSTD_LONG_SIZE
 #    define INT_LEAST8_MAX    _RWSTD_LONG_MAX
 #    define UINT_LEAST8_MAX   _RWSTD_ULONG_MAX
@@ -107,11 +96,6 @@
 
 #else   // fallback on int
 
-typedef int                 int_least8_t;
-typedef unsigned            uint_least8_t
-typedef int                 int_fast8_t;
-typedef unsigned            uint_fast8_t
-
 #  define INT_LEAST8_MAX    _RWSTD_INT_MAX
 #  define UINT_LEAST8_MAX   _RWSTD_UINT_MAX
 #  define INT_FAST8_MAX     _RWSTD_INT_MAX
@@ -124,39 +108,34 @@
 
 #ifdef _RWSTD_INT16_T
 
+// optional exact width types
 typedef _RWSTD_INT16_T       int16_t;
 typedef _RWSTD_UINT16_T      uint16_t;
-typedef _RWSTD_INT16_T       int_least16_t;
-typedef _RWSTD_UINT16_T      uint_least16_t;
-typedef _RWSTD_INT16_T       int_fast16_t;
-typedef _RWSTD_UINT16_T      uint_fast16_t;
 
 #  define INT16_MAX          32767
 #  define UINT16_MAX         65535U
-#  define INT_LEAST16_MAX    32767
-#  define UINT_LEAST16_MAX   65535U
-#  define INT_FAST16_MAX     32767
-#  define UINT_FAST16_MAX    65535U
+
+#  define INT_LEAST16_MAX    INT16_MAX
+#  define UINT_LEAST16_MAX   UINT16_MAX
+#  define INT_FAST16_MAX     INT16_MAX
+#  define UINT_FAST16_MAX    UINT16_MAX
 
 #elif defined (_RWSTD_INT32_T)
 
-typedef _RWSTD_INT32_T       int_least16_t;
-typedef _RWSTD_UINT32_T      uint_least16_t
-typedef _RWSTD_INT32_T       int_fast16_t;
-typedef _RWSTD_UINT32_T      uint_fast16_t;
-
-#  define INT_LEAST16_MAX    2147483647
-#  define UINT_LEAST16_MAX   4294967295U
-#  define INT_FAST16_MAX     2147483647
-#  define UINT_FAST16_MAX    4294967295U
+#  if 4 == _RWSTD_INT_SIZE
+#    define INT_LEAST16_MAX    _RWSTD_INT_MAX
+#    define UINT_LEAST16_MAX   _RWSTD_UINT_MAX
+#    define INT_FAST16_MAX     _RWSTD_INT_MAX
+#    define UINT_FAST16_MAX    _RWSTD_UINT_MAX
+#  elif 4 == _RWSTD_LONG_SIZE
+#    define INT_LEAST16_MAX    _RWSTD_LONG_MAX
+#    define UINT_LEAST16_MAX   _RWSTD_ULONG_MAX
+#    define INT_FAST16_MAX     _RWSTD_LONG_MAX
+#    define UINT_FAST16_MAX    _RWSTD_ULONG_MAX
+#  endif
 
 #elif defined (_RWSTD_INT64_T)
 
-typedef _RWSTD_INT64_T       int_least16_t;
-typedef _RWSTD_UINT64_T      uint_least16_t
-typedef _RWSTD_INT64_T       int_fast16_t;
-typedef _RWSTD_UINT64_T      uint_fast16_t;
-
 #  if 8 == _RWSTD_LONG_SIZE
 #    define INT_LEAST16_MAX    _RWSTD_LONG_MAX
 #    define UINT_LEAST16_MAX   _RWSTD_ULONG_MAX
@@ -171,11 +150,6 @@
 
 #else   // fallback on int
 
-typedef int                  int_least16_t;
-typedef unsigned             uint_least16_t
-typedef int                  int_fast16_t;
-typedef unsigned             uint_fast16_t
-
 #  define INT_LEAST16_MAX    _RWSTD_INT_MAX
 #  define UINT_LEAST16_MAX   _RWSTD_UINT_MAX
 #  define INT_FAST16_MAX     _RWSTD_INT_MAX
@@ -188,26 +162,24 @@
 
 #ifdef _RWSTD_INT32_T
 
+// optional exact width types
 typedef _RWSTD_INT32_T       int32_t;
 typedef _RWSTD_UINT32_T      uint32_t;
-typedef _RWSTD_INT32_T       int_least32_t;
-typedef _RWSTD_UINT32_T      uint_least32_t;
-typedef _RWSTD_INT32_T       int_faast32_t;
-typedef _RWSTD_UINT32_T      uint_faast32_t;
-
-#  define INT32_MAX          2147483647
-#  define UINT32_MAX         4294967295U
-#  define INT_LEAST32_MAX    2147483647
-#  define UINT_LEAST32_MAX   4294967295U
-#  define INT_FAST32_MAX     2147483647
-#  define UINT_FAST32_MAX    4294967295U
 
-#elif defined (_RWSTD_INT64_T)
+#  if 4 == _RWSTD_INT_SIZE
+#    define INT32_MAX          _RWSTD_INT_MAX
+#    define UINT32_MAX         _RWSTD_UINT_MAX
+#  elif 4 == _RWSTD_LONG_SIZE
+#    define INT32_MAX          _RWSTD_LONG_MAX
+#    define UINT32_MAX         _RWSTD_LONG_MAX
+#  endif
 
-typedef _RWSTD_INT64_T       int_least32_t;
-typedef _RWSTD_UINT64_T      uint_least32_t
-typedef _RWSTD_INT64_T       int_fast32_t;
-typedef _RWSTD_UINT64_T      uint_fast32_t
+#  define INT_LEAST32_MAX      INT32_MAX
+#  define UINT_LEAST32_MAX     UINT32_MAX
+#  define INT_FAST32_MAX       INT32_MAX
+#  define UINT_FAST32_MAX      UINT32_MAX
+
+#elif defined (_RWSTD_INT64_T)
 
 #  if 8 == _RWSTD_LONG_SIZE
 #    define INT_LEAST32_MAX    _RWSTD_LONG_MAX
@@ -223,11 +195,6 @@
 
 #else   // fallback on int
 
-typedef int                  int_least32_t;
-typedef unsigned             uint_least32_t
-typedef int                  int_faast32_t;
-typedef unsigned             uint_faast32_t
-
 #  define INT32_MAX          _RWSTD_INT_MAX
 #  define UINT32_MAX         _RWSTD_UINT_MAX
 #  define INT_LEAST32_MAX    _RWSTD_INT_MAX
@@ -242,12 +209,9 @@
 
 #ifdef _RWSTD_INT64_T
 
+// optional exact width types
 typedef _RWSTD_INT64_T   int64_t;
 typedef _RWSTD_UINT64_T  uint64_t;
-typedef _RWSTD_INT64_T   int_least64_t;
-typedef _RWSTD_UINT64_T  uint_least64_t;
-typedef _RWSTD_INT64_T   int_fast64_t;
-typedef _RWSTD_UINT64_T  uint_fast64_t;
 
 // 7.18.2.5 of C99 requires that intmax_t be at least 64-bits wide
 typedef _RWSTD_INT64_T   intmax_t;
@@ -256,25 +220,33 @@
 #  if 8 == _RWSTD_LONG_SIZE
 #    define INT64_MAX          _RWSTD_LONG_MAX
 #    define UINT64_MAX         _RWSTD_ULONG_MAX
-#    define INT_LEAST64_MAX    _RWSTD_LONG_MAX
-#    define UINT_LEAST64_MAX   _RWSTD_ULONG_MAX
-#    define INT_FAST64_MAX     _RWSTD_LONG_MAX
-#    define UINT_FAST64_MAX    _RWSTD_ULONG_MAX
 #  elif 8 == _RWSTD_LLONG_SIZE
 #    define INT64_MAX          _RWSTD_LLONG_MAX
 #    define UINT64_MAX         _RWSTD_ULLONG_MAX
-#    define INT_LEAST64_MAX    _RWSTD_LLONG_MAX
-#    define UINT_LEAST64_MAX   _RWSTD_ULLONG_MAX
-#    define INT_FAST64_MAX     _RWSTD_LLONG_MAX
-#    define UINT_FAST64_MAX    _RWSTD_ULLONG_MAX
 #  endif
 
+#  define INT_LEAST64_MAX    INT64_MAX
+#  define UINT_LEAST64_MAX   UINT64_MAX
+#  define INT_FAST64_MAX     INT64_MAX
+#  define UINT_FAST64_MAX    UINT64_MAX
+
+#elif defined (_RWSTD_LONG_LONG)      // fallback on long long
+
+// this possibly violates 7.18.2.5 of C99 which requires that intmax_t
+// be at least 64-bits wide
+typedef _RWSTD_LONG_LONG             intmax_t;
+typedef unsigned _RWSTD_LONG_LONG    uintmax_t;
+
 #else   // fallback on long
-typedef long             intmax_t;
-typedef unsigned long    uintmax_t;
+
+// this likely violates 7.18.2.5 of C99 which requires that intmax_t
+// be at least 64-bits wide
+typedef long           intmax_t;
+typedef unsigned long  uintmax_t;
+
 #endif   // _RWSTD_INT{64,32,16}_T
 
-/*** intptr_t**************************************************************/
+/*** intptr_t *************************************************************/
 
 #if 8 == _RWSTD_PTR_SIZE
 
@@ -284,8 +256,6 @@
 #  define INTPTR_MAX      INT64_MAX
 #  define UINTPTR_MAX     UINT64_MAX
 
-#define INTPTR_MIN _
-
 #elif 4 == _RWSTD_PTR_SIZE
 
 typedef _RWSTD_INT32_T    intptr_t;
@@ -312,10 +282,45 @@
 
 #endif   // {8,16,32,64} == _RWSTD_PTR_SIZE
 
-/*** _MIN constants *******************************************************/
+/*** least and fast types *************************************************/
+
+typedef _RWSTD_INT_LEAST8_T       int_least8_t;
+typedef _RWSTD_UINT_LEAST8_T      uint_least8_t;
+typedef _RWSTD_INT_LEAST8_T       int_fast8_t;
+typedef _RWSTD_UINT_LEAST8_T      uint_fast8_t;
+
+typedef _RWSTD_INT_LEAST16_T      int_least16_t;
+typedef _RWSTD_UINT_LEAST16_T     uint_least16_t;
+typedef _RWSTD_INT_LEAST16_T      int_fast16_t;
+typedef _RWSTD_UINT_LEAST16_T     uint_fast16_t;
 
-#define PTRDIFF_MIN         _RWSTD_PTRIDFF_MIN
-#define PTRDIFF_MAX         _RWSTD_PTRIDFF_MAX
+typedef _RWSTD_INT_LEAST32_T      int_least32_t;
+typedef _RWSTD_UINT_LEAST32_T     uint_least32_t;
+typedef _RWSTD_INT_LEAST32_T      int_fast32_t;
+typedef _RWSTD_UINT_LEAST32_T     uint_fast32_t;
+
+#ifdef _RWSTD_INT_LEAST64_T
+
+typedef _RWSTD_INT_LEAST64_T      int_least64_t;
+typedef _RWSTD_UINT_LEAST64_T     uint_least64_t;
+typedef _RWSTD_INT_LEAST64_T      int_fast64_t;
+typedef _RWSTD_UINT_LEAST64_T     uint_fast64_t;
+
+#endif   // _RWSTD_INT_LEAST64_T
+
+#ifdef _RWSTD_INT_LEAST128_T
+
+typedef _RWSTD_INT_LEAST128_T     int_least128_t;
+typedef _RWSTD_UINT_LEAST128_T    uint_least128_t;
+typedef _RWSTD_INT_LEAST128_T     int_fast128_t;
+typedef _RWSTD_UINT_LEAST128_T    uint_fast128_t;
+
+#endif   // _RWSTD_INT_LEAST128_T
+
+/*** other constants ******************************************************/
+
+#define PTRDIFF_MIN         _RWSTD_PTRDIFF_MIN
+#define PTRDIFF_MAX         _RWSTD_PTRDIFF_MAX
 
 #define SIZE_MAX            _RWSTD_SIZE_MAX
 
@@ -327,6 +332,8 @@
 
 #define SIG_ATOMIC_MIN      _RWSTD_SIG_ATOMIC_MIN
 #define SIG_ATOMIC_MAX      _RWSTD_SIG_ATOMIC_MAX
+
+/*** computed _MIN constants **********************************************/
 
 #define INT8_MIN            _RWSTD_T_MIN (INT8_MAX)
 #define INT16_MIN           _RWSTD_T_MIN (INT16_MAX)

Added: incubator/stdcxx/trunk/tests/tr1.c99/8.cstdint.cpp
URL: http://svn.apache.org/viewcvs/incubator/stdcxx/trunk/tests/tr1.c99/8.cstdint.cpp?rev=373631&view=auto
==============================================================================
--- incubator/stdcxx/trunk/tests/tr1.c99/8.cstdint.cpp (added)
+++ incubator/stdcxx/trunk/tests/tr1.c99/8.cstdint.cpp Mon Jan 30 15:30:07 2006
@@ -0,0 +1,769 @@
+// -*- C++ -*-
+/***************************************************************************
+ *
+ * 8.cstdint.cpp - test exercising tr.c99.cstdint
+ *
+ * $Id$
+ *
+ ***************************************************************************
+ *
+ * Copyright 2006 The Apache Software Foundation or its licensors,
+ * as applicable.
+ *
+ * Copyright 2006 Rogue Wave Software.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ **************************************************************************/
+
+enum {
+    // 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 <tr1/cstdint>
+
+#include <driver.h>
+
+/**************************************************************************/
+
+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 tr1 {
+
+namespace Nested {
+
+using namespace Fallback;
+
+// each test_xxx_t typedef aliases std::tr1::xxx_t if the corresponding
+// type is defined in namespace std::tr1, 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 tr1
+
+}   // namespace std
+
+typedef std::tr1::Nested::test_int8_t         test_int8_t;
+typedef std::tr1::Nested::test_uint8_t        test_uint8_t;
+typedef std::tr1::Nested::test_int_least8_t   test_int_least8_t;
+typedef std::tr1::Nested::test_uint_least8_t  test_uint_least8_t;
+typedef std::tr1::Nested::test_int_fast8_t    test_int_fast8_t;
+typedef std::tr1::Nested::test_uint_fast8_t   test_uint_fast8_t;
+
+typedef std::tr1::Nested::test_int16_t        test_int16_t;
+typedef std::tr1::Nested::test_uint16_t       test_uint16_t;
+typedef std::tr1::Nested::test_int_least16_t  test_int_least16_t;
+typedef std::tr1::Nested::test_uint_least16_t test_uint_least16_t;
+typedef std::tr1::Nested::test_int_fast16_t   test_int_fast16_t;
+typedef std::tr1::Nested::test_uint_fast16_t  test_uint_fast16_t;
+
+typedef std::tr1::Nested::test_int32_t        test_int32_t;
+typedef std::tr1::Nested::test_uint32_t       test_uint32_t;
+typedef std::tr1::Nested::test_int_least32_t  test_int_least32_t;
+typedef std::tr1::Nested::test_uint_least32_t test_uint_least32_t;
+typedef std::tr1::Nested::test_int_fast32_t   test_int_fast32_t;
+typedef std::tr1::Nested::test_uint_fast32_t  test_uint_fast32_t;
+
+typedef std::tr1::Nested::test_int64_t        test_int64_t;
+typedef std::tr1::Nested::test_uint64_t       test_uint64_t;
+typedef std::tr1::Nested::test_int_least64_t  test_int_least64_t;
+typedef std::tr1::Nested::test_uint_least64_t test_uint_least64_t;
+typedef std::tr1::Nested::test_int_fast64_t   test_int_fast64_t;
+typedef std::tr1::Nested::test_uint_fast64_t  test_uint_fast64_t;
+
+typedef std::tr1::Nested::test_intmax_t       test_intmax_t;
+typedef std::tr1::Nested::test_uintmax_t      test_uintmax_t;
+typedef std::tr1::Nested::test_intptr_t       test_intptr_t;
+typedef std::tr1::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    = zero - one;
+    static volatile intT all_bits_set = ~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 = maximum * intT (2);
+        minimum = maximum * intT (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::tr1::%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::tr1", #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::tr1::%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::tr1", #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__,
+                    "tr.c99.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);
+}

Propchange: incubator/stdcxx/trunk/tests/tr1.c99/8.cstdint.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/stdcxx/trunk/tests/tr1.c99/8.cstdint.cpp
------------------------------------------------------------------------------
    svn:keywords = Id



Mime
View raw message