Additions to inttypes.h format strings

diff --git a/include/inttypes.h b/include/inttypes.h
index 0a3c0c7e8340981e7670044be15906cbedad2769..31f4ec005bbdae41053a7f3c56b87f337a4d0dfc 100644 (file)
--- a/include/inttypes.h
+++ b/include/inttypes.h
@@ -24,19 +24,33 @@
 #define PRI16          ""
 #define PRILEAST16     ""
 #define PRIFAST16      ""
-#if _WORD_SIZE == 2
-#define PRI32          "l"
-#define PRILEAST32     "l"
-#define PRIFAST32      "l"
-#else
+
+#if __SIZEOF_LONG__ > 4
 #define PRI32          ""
-#define PRILEAST32     ""
-#define PRIFAST32      ""
+#else
+#define PRI32          "l"
 #endif
-#if _WORD_SIZE > 2 && __L64
+#define PRILEAST32     PRI32
+#define PRIFAST32      PRI32
+
+#if defined(__LONG_LONG_SUPPORTED)
+#define PRI64          "ll"
+#elif _WORD_SIZE > 2 && __L64
 #define PRI64          "l"
-#define PRILEAST64     "l"
-#define PRIFAST64      "l"
+#endif
+
+#ifdef PRI64
+#define PRILEAST64     PRI64
+#define PRIFAST64      PRI64
+#define PRIMAX         PRI64
+#else
+#define PRIMAX         PRI32
+#endif
+
+#if _PTR_SIZE == _WORD_SIZE
+#define PRIPTR         ""
+#elif _PTR_SIZE == 2*_WORD_SIZE
+#define PRIPTR         "l"
 #endif
 
 /* Macros for fprintf, the ones defined by the standard. */
@@ -49,11 +63,13 @@
 #define PRId32         PRI32"d"
 #define PRIdLEAST32    PRILEAST32"d"
 #define PRIdFAST32     PRIFAST32"d"
-#if _WORD_SIZE > 2 && __L64
+#ifdef PRI64
 #define PRId64         PRI64"d"
 #define PRIdLEAST64    PRILEAST64"d"
 #define PRIdFAST64     PRIFAST64"d"
 #endif
+#define PRIdMAX                PRIMAX"d"
+#define PRIdPTR                PRIPTR"d"
 
 #define PRIi8          PRI8"i"
 #define PRIiLEAST8     PRILEAST8"i"
@@ -64,11 +80,13 @@
 #define PRIi32         PRI32"i"
 #define PRIiLEAST32    PRILEAST32"i"
 #define PRIiFAST32     PRIFAST32"i"
-#if _WORD_SIZE > 2 && __L64
+#ifdef PRI64
 #define PRIi64         PRI64"i"
 #define PRIiLEAST64    PRILEAST64"i"
 #define PRIiFAST64     PRIFAST64"i"
 #endif
+#define PRIiMAX                PRIMAX"i"
+#define PRIiPTR                PRIPTR"i"
 
 #define PRIo8          PRI8"o"
 #define PRIoLEAST8     PRILEAST8"o"
@@ -79,11 +97,13 @@
 #define PRIo32         PRI32"o"
 #define PRIoLEAST32    PRILEAST32"o"
 #define PRIoFAST32     PRIFAST32"o"
-#if _WORD_SIZE > 2 && __L64
+#ifdef PRI64
 #define PRIo64         PRI64"o"
 #define PRIoLEAST64    PRILEAST64"o"
 #define PRIoFAST64     PRIFAST64"o"
 #endif
+#define PRIoMAX                PRIMAX"o"
+#define PRIoPTR                PRIPTR"o"
 
 #define PRIu8          PRI8"u"
 #define PRIuLEAST8     PRILEAST8"u"
@@ -94,11 +114,13 @@
 #define PRIu32         PRI32"u"
 #define PRIuLEAST32    PRILEAST32"u"
 #define PRIuFAST32     PRIFAST32"u"
-#if _WORD_SIZE > 2 && __L64
+#ifdef PRI64
 #define PRIu64         PRI64"u"
 #define PRIuLEAST64    PRILEAST64"u"
 #define PRIuFAST64     PRIFAST64"u"
 #endif
+#define PRIuMAX                PRIMAX"u"
+#define PRIuPTR                PRIPTR"u"
 
 #define PRIx8          PRI8"x"
 #define PRIxLEAST8     PRILEAST8"x"
@@ -109,11 +131,13 @@
 #define PRIx32         PRI32"x"
 #define PRIxLEAST32    PRILEAST32"x"
 #define PRIxFAST32     PRIFAST32"x"
-#if _WORD_SIZE > 2 && __L64
+#ifdef PRI64
 #define PRIx64         PRI64"x"
 #define PRIxLEAST64    PRILEAST64"x"
 #define PRIxFAST64     PRIFAST64"x"
 #endif
+#define PRIxMAX                PRIMAX"x"
+#define PRIxPTR                PRIPTR"x"
 
 #define PRIX8          PRI8"X"
 #define PRIXLEAST8     PRILEAST8"X"
@@ -124,11 +148,13 @@
 #define PRIX32         PRI32"X"
 #define PRIXLEAST32    PRILEAST32"X"
 #define PRIXFAST32     PRIFAST32"X"
-#if _WORD_SIZE > 2 && __L64
+#ifdef PRI64
 #define PRIX64         PRI64"X"
 #define PRIXLEAST64    PRILEAST64"X"
 #define PRIXFAST64     PRIFAST64"X"
 #endif
+#define PRIXMAX                PRIMAX"X"
+#define PRIXPTR                PRIPTR"X"
 
 /* Macros to scan integers with fscanf(), nonstandard first group. */
 #define SCN8           "hh"
@@ -230,7 +256,12 @@
 #endif /* !__cplusplus || __STDC_FORMAT_MACROS */
 
 /* Integer conversion functions for [u]intmax_t. */
+#ifdef __LONG_LONG_SUPPORTED
+#define stroimax(nptr, endptr, base)   strtoll(nptr, endptr, base)
+#define stroumax(nptr, endptr, base)   strtoull(nptr, endptr, base)
+#else
 #define stroimax(nptr, endptr, base)   strtol(nptr, endptr, base)
 #define stroumax(nptr, endptr, base)   strtoul(nptr, endptr, base)
+#endif
 
 #endif /* _INTTYPES_H */

diff --git a/include/stdint.h b/include/stdint.h
index d696c494e0e635b9c9482a4e7142f144c6ff3902..601dacd66f018c7db65982082caa363e0e2772d4 100644 (file)
--- a/include/stdint.h
+++ b/include/stdint.h
@@ -87,8 +87,14 @@ typedef unsigned     uintptr_t;
 typedef long           intptr_t;
 typedef unsigned long  uintptr_t;
 #endif
+
+#if defined(__LONG_LONG_SUPPORTED) || (_WORD_SIZE > 2 && __L64)
+typedef int64_t                intmax_t;
+typedef uint64_t       uintmax_t;
+#else
 typedef long           intmax_t;
 typedef unsigned long  uintmax_t;
+#endif
 
 #if !__cplusplus || defined(__STDC_LIMIT_MACROS)
 #ifndef _LIMITS_H
@@ -178,9 +184,16 @@ typedef unsigned long      uintmax_t;
 #define INTPTR_MAX             LONG_MAX
 #define UINTPTR_MAX            ULONG_MAX
 #endif
+
+#if defined(__LONG_LONG_SUPPORTED) || (_WORD_SIZE > 2 && __L64)
+#define INTMAX_MIN             INT64_MIN
+#define INTMAX_MAX             INT64_MAX
+#define UINTMAX_MAX            UINT64_MAX
+#else
 #define INTMAX_MIN             LONG_MIN
 #define INTMAX_MAX             LONG_MAX
 #define UINTMAX_MAX            ULONG_MAX
+#endif
 
 #endif /* !__cplusplus || __STDC_LIMIT_MACROS */
 

diff --git a/test/Makefile b/test/Makefile
index 5b0bf2f7b84bd3bc8d2c97fcf42f52e2b269db32..50097cf6ad967e540f1988faeb1376d2e3a56e20 100644 (file)
--- a/test/Makefile
+++ b/test/Makefile
@@ -10,11 +10,11 @@ OBJ=        test1  test2  test3  test4  test5  test6  test7  test8  test9  \
               test21 test22 test23        test25 test26 test27 test28 test29 \
        test30 test31 test32        test34 test35 test36 test37 test38 \
        test39 t10a t11a t11b test40 t40a t40b t40c t40d t40e t40f test41 \
-       test42 test44 test45 test47 test48
+       test42 test44 test45 test47 test48 test49
 
 BIGOBJ=  test20 test24
 ROOTOBJ= test11 test33 test43 test46
-GCCOBJ=  test45-gcc
+GCCOBJ=  test45-gcc test49-gcc
 
 all:   $(OBJ) $(BIGOBJ) $(GCCOBJ) $(ROOTOBJ) Benchmarks
        chmod 755 *.sh run
@@ -100,4 +100,6 @@ test45-gcc: test45.c test45.h
 test46: test46.c
 test47: test47.c
 test48: test48.c
+test49: test49.c
+test49-gcc: test49.c
 

diff --git a/test/run b/test/run
index e6d97bbf1b158f1f084169a495f224161bb0d1f5..5267264f1b4d7c1bd173d71548141db661aabcd1 100755 (executable)
--- a/test/run
+++ b/test/run
@@ -13,13 +13,13 @@ badones=                    # list of tests that failed
 
 # Print test welcome message
 clr
-echo "Running POSIX compliance test suite. There are 51 tests in total."
+echo "Running POSIX compliance test suite. There are 53 tests in total."
 echo " "
 
 # Run all the tests, keeping track of who failed.
 for i in  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 \
          21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 \
-         41 42 43 44 45 45-gcc 46 47 48 sh1.sh sh2.sh
+         41 42 43 44 45 45-gcc 46 47 48 49 49-gcc sh1.sh sh2.sh
 do
    if [ -x ./test$i ]
    then

diff --git a/test/test49.c b/test/test49.c
new file mode 100755 (executable)
index 0000000..290e503
--- /dev/null
+++ b/test/test49.c
@@ -0,0 +1,212 @@
+#include <assert.h>
+#include <inttypes.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#if defined(__LONG_LONG_SUPPORTED) || (_WORD_SIZE > 2 && __L64)
+#define TEST_64_BIT
+#endif
+
+#define ERR err(__LINE__)
+
+#define MAX_ERROR 4
+static int errct;
+
+static void quit(void)
+{
+       if (errct == 0) 
+       {
+               printf("ok\n");
+               exit(0);
+       } 
+       else 
+       {
+               printf("%d errors\n", errct);
+               exit(1);
+       }
+}
+
+static void err(int line)
+{
+       printf("error at line %d\n", line);
+       if (++errct >= MAX_ERROR)
+               quit();
+}
+
+#define TEST_PRINTF(type, macro, value, result)                                \
+{                                                                      \
+       char buffer[256];                                               \
+       snprintf(buffer, sizeof(buffer), "%" macro, (type) value);      \
+       if (strcmp(buffer, result) != 0) err(__LINE__);                 \
+}
+
+int main(void)
+{
+#ifdef __LONG_LONG_SUPPORTED
+       printf("Test 49 (GCC) ");
+#else
+       printf("Test 49 (ACK) ");
+#endif
+       fflush(stdout);
+
+       /* test integer sizes */
+       if (sizeof(int8_t) != 1) ERR;
+       if (sizeof(uint8_t) != 1) ERR;
+       if (sizeof(int_fast8_t) < 1) ERR;
+       if (sizeof(uint_fast8_t) < 1) ERR;
+       if (sizeof(int_least8_t) < 1) ERR;
+       if (sizeof(uint_least8_t) < 1) ERR;
+       if (sizeof(int16_t) != 2) ERR;
+       if (sizeof(uint16_t) != 2) ERR;
+       if (sizeof(int_fast16_t) < 2) ERR;
+       if (sizeof(uint_fast16_t) < 2) ERR;
+       if (sizeof(int_least16_t) < 2) ERR;
+       if (sizeof(uint_least16_t) < 2) ERR;
+       if (sizeof(int32_t) != 4) ERR;
+       if (sizeof(uint32_t) != 4) ERR;
+       if (sizeof(int_fast32_t) < 4) ERR;
+       if (sizeof(uint_fast32_t) < 4) ERR;
+       if (sizeof(int_least32_t) < 4) ERR;
+       if (sizeof(uint_least32_t) < 4) ERR;
+#ifdef TEST_64_BIT
+       if (sizeof(int64_t) != 8) ERR;
+       if (sizeof(uint64_t) != 8) ERR;
+       if (sizeof(int_fast64_t) < 8) ERR;
+       if (sizeof(uint_fast64_t) < 8) ERR;
+       if (sizeof(int_least64_t) < 8) ERR;
+       if (sizeof(uint_least64_t) < 8) ERR;
+#endif
+       if (sizeof(intptr_t) != sizeof(void *)) ERR;
+       if (sizeof(uintptr_t) != sizeof(void *)) ERR;
+#ifdef TEST_64_BIT
+       if (sizeof(intmax_t) < 8) ERR;
+       if (sizeof(uintmax_t) < 8) ERR;
+#else
+       if (sizeof(intmax_t) < 4) ERR;
+       if (sizeof(uintmax_t) < 4) ERR;
+#endif
+
+       /* test integer signedness */
+       if ((int8_t) (-1) >= 0) ERR;
+       if ((uint8_t) (-1) <= 0) ERR;
+       if ((int_fast8_t) (-1) >= 0) ERR;
+       if ((uint_fast8_t) (-1) <= 0) ERR;
+       if ((int_least8_t) (-1) >= 0) ERR;
+       if ((uint_least8_t) (-1) <= 0) ERR;
+       if ((int16_t) (-1) >= 0) ERR;
+       if ((uint16_t) (-1) <= 0) ERR;
+       if ((int_fast16_t) (-1) >= 0) ERR;
+       if ((uint_fast16_t) (-1) <= 0) ERR;
+       if ((int_least16_t) (-1) >= 0) ERR;
+       if ((uint_least16_t) (-1) <= 0) ERR;
+       if ((int32_t) (-1) >= 0) ERR;
+       if ((uint32_t) (-1) <= 0) ERR;
+       if ((int_fast32_t) (-1) >= 0) ERR;
+       if ((uint_fast32_t) (-1) <= 0) ERR;
+       if ((int_least32_t) (-1) >= 0) ERR;
+       if ((uint_least32_t) (-1) <= 0) ERR;
+#ifdef TEST_64_BIT
+       if ((int64_t) (-1) >= 0) ERR;
+       if ((uint64_t) (-1) <= 0) ERR;
+       if ((int_fast64_t) (-1) >= 0) ERR;
+       if ((uint_fast64_t) (-1) <= 0) ERR;
+       if ((int_least64_t) (-1) >= 0) ERR;
+       if ((uint_least64_t) (-1) <= 0) ERR;
+#endif
+       if ((intptr_t) (-1) >= 0) ERR;
+       if ((uintptr_t) (-1) <= 0) ERR;
+       if ((intptr_t) (-1) >= 0) ERR;
+       if ((uintptr_t) (-1) <= 0) ERR;
+
+       /* test printf */
+       TEST_PRINTF(int32_t,  PRId32, INT32_MIN,  "-2147483648");
+       TEST_PRINTF(int32_t,  PRId32, INT32_MAX,   "2147483647");
+       TEST_PRINTF(int32_t,  PRIi32, INT32_MIN,  "-2147483648");
+       TEST_PRINTF(int32_t,  PRIi32, INT32_MAX,   "2147483647");
+       TEST_PRINTF(uint32_t, PRIu32, UINT32_MAX,  "4294967295");
+       TEST_PRINTF(uint32_t, PRIX32, UINT32_MAX,    "FFFFFFFF");
+       TEST_PRINTF(uint32_t, PRIx32, UINT32_MAX,    "ffffffff");
+       TEST_PRINTF(uint32_t, PRIo32, UINT32_MAX, "37777777777");
+
+       TEST_PRINTF(int_fast32_t,  PRIdFAST32, INT32_MIN,  "-2147483648");
+       TEST_PRINTF(int_fast32_t,  PRIdFAST32, INT32_MAX,   "2147483647");
+       TEST_PRINTF(int_fast32_t,  PRIiFAST32, INT32_MIN,  "-2147483648");
+       TEST_PRINTF(int_fast32_t,  PRIiFAST32, INT32_MAX,   "2147483647");
+       TEST_PRINTF(uint_fast32_t, PRIuFAST32, UINT32_MAX,  "4294967295");
+       TEST_PRINTF(uint_fast32_t, PRIXFAST32, UINT32_MAX,    "FFFFFFFF");
+       TEST_PRINTF(uint_fast32_t, PRIxFAST32, UINT32_MAX,    "ffffffff");
+       TEST_PRINTF(uint_fast32_t, PRIoFAST32, UINT32_MAX, "37777777777");
+
+       TEST_PRINTF(int_least32_t,  PRIdLEAST32, INT32_MIN,  "-2147483648");
+       TEST_PRINTF(int_least32_t,  PRIdLEAST32, INT32_MAX,   "2147483647");
+       TEST_PRINTF(int_least32_t,  PRIiLEAST32, INT32_MIN,  "-2147483648");
+       TEST_PRINTF(int_least32_t,  PRIiLEAST32, INT32_MAX,   "2147483647");
+       TEST_PRINTF(uint_least32_t, PRIuLEAST32, UINT32_MAX,  "4294967295");
+       TEST_PRINTF(uint_least32_t, PRIXLEAST32, UINT32_MAX,    "FFFFFFFF");
+       TEST_PRINTF(uint_least32_t, PRIxLEAST32, UINT32_MAX,    "ffffffff");
+       TEST_PRINTF(uint_least32_t, PRIoLEAST32, UINT32_MAX, "37777777777");
+
+#ifdef TEST_64_BIT
+       TEST_PRINTF(int64_t,  PRId64, INT64_MIN,    "-9223372036854775808");
+       TEST_PRINTF(int64_t,  PRId64, INT64_MAX,     "9223372036854775807");
+       TEST_PRINTF(int64_t,  PRIi64, INT64_MIN,    "-9223372036854775808");
+       TEST_PRINTF(int64_t,  PRIi64, INT64_MAX,     "9223372036854775807");
+       TEST_PRINTF(uint64_t, PRIu64, UINT64_MAX,   "18446744073709551615");
+       TEST_PRINTF(uint64_t, PRIX64, UINT64_MAX,       "FFFFFFFFFFFFFFFF");
+       TEST_PRINTF(uint64_t, PRIx64, UINT64_MAX,       "ffffffffffffffff");
+       TEST_PRINTF(uint64_t, PRIo64, UINT64_MAX, "1777777777777777777777");
+
+       TEST_PRINTF(int_fast64_t,  PRIdFAST64, INT64_MIN,    "-9223372036854775808");
+       TEST_PRINTF(int_fast64_t,  PRIdFAST64, INT64_MAX,     "9223372036854775807");
+       TEST_PRINTF(int_fast64_t,  PRIiFAST64, INT64_MIN,    "-9223372036854775808");
+       TEST_PRINTF(int_fast64_t,  PRIiFAST64, INT64_MAX,     "9223372036854775807");
+       TEST_PRINTF(uint_fast64_t, PRIuFAST64, UINT64_MAX,   "18446744073709551615");
+       TEST_PRINTF(uint_fast64_t, PRIXFAST64, UINT64_MAX,       "FFFFFFFFFFFFFFFF");
+       TEST_PRINTF(uint_fast64_t, PRIxFAST64, UINT64_MAX,       "ffffffffffffffff");
+       TEST_PRINTF(uint_fast64_t, PRIoFAST64, UINT64_MAX, "1777777777777777777777");
+
+       TEST_PRINTF(int_least64_t,  PRIdLEAST64, INT64_MIN,    "-9223372036854775808");
+       TEST_PRINTF(int_least64_t,  PRIdLEAST64, INT64_MAX,     "9223372036854775807");
+       TEST_PRINTF(int_least64_t,  PRIiLEAST64, INT64_MIN,    "-9223372036854775808");
+       TEST_PRINTF(int_least64_t,  PRIiLEAST64, INT64_MAX,     "9223372036854775807");
+       TEST_PRINTF(uint_least64_t, PRIuLEAST64, UINT64_MAX,   "18446744073709551615");
+       TEST_PRINTF(uint_least64_t, PRIXLEAST64, UINT64_MAX,       "FFFFFFFFFFFFFFFF");
+       TEST_PRINTF(uint_least64_t, PRIxLEAST64, UINT64_MAX,       "ffffffffffffffff");
+       TEST_PRINTF(uint_least64_t, PRIoLEAST64, UINT64_MAX, "1777777777777777777777");
+
+       TEST_PRINTF(intmax_t,  PRIdMAX, INT64_MIN,    "-9223372036854775808");
+       TEST_PRINTF(intmax_t,  PRIdMAX, INT64_MAX,     "9223372036854775807");
+       TEST_PRINTF(intmax_t,  PRIiMAX, INT64_MIN,    "-9223372036854775808");
+       TEST_PRINTF(intmax_t,  PRIiMAX, INT64_MAX,     "9223372036854775807");
+       TEST_PRINTF(uintmax_t, PRIuMAX, UINT64_MAX,   "18446744073709551615");
+       TEST_PRINTF(uintmax_t, PRIXMAX, UINT64_MAX,       "FFFFFFFFFFFFFFFF");
+       TEST_PRINTF(uintmax_t, PRIxMAX, UINT64_MAX,       "ffffffffffffffff");
+       TEST_PRINTF(uintmax_t, PRIoMAX, UINT64_MAX, "1777777777777777777777");
+#else
+       TEST_PRINTF(intmax_t,  PRIdMAX, INT32_MIN,  "-2147483648");
+       TEST_PRINTF(intmax_t,  PRIdMAX, INT32_MAX,   "2147483647");
+       TEST_PRINTF(intmax_t,  PRIiMAX, INT32_MIN,  "-2147483648");
+       TEST_PRINTF(intmax_t,  PRIiMAX, INT32_MAX,   "2147483647");
+       TEST_PRINTF(uintmax_t, PRIuMAX, UINT32_MAX,  "4294967295");
+       TEST_PRINTF(uintmax_t, PRIXMAX, UINT32_MAX,    "FFFFFFFF");
+       TEST_PRINTF(uintmax_t, PRIxMAX, UINT32_MAX,    "ffffffff");
+       TEST_PRINTF(uintmax_t, PRIoMAX, UINT32_MAX, "37777777777");
+#endif
+
+       TEST_PRINTF(intptr_t,  PRIdPTR, INT32_MIN,  "-2147483648");
+       TEST_PRINTF(intptr_t,  PRIdPTR, INT32_MAX,   "2147483647");
+       TEST_PRINTF(intptr_t,  PRIiPTR, INT32_MIN,  "-2147483648");
+       TEST_PRINTF(intptr_t,  PRIiPTR, INT32_MAX,   "2147483647");
+       TEST_PRINTF(uintptr_t, PRIuPTR, UINT32_MAX,  "4294967295");
+       TEST_PRINTF(uintptr_t, PRIXPTR, UINT32_MAX,    "FFFFFFFF");
+       TEST_PRINTF(uintptr_t, PRIxPTR, UINT32_MAX,    "ffffffff");
+       TEST_PRINTF(uintptr_t, PRIoPTR, UINT32_MAX, "37777777777");
+
+       /* done */
+       quit();
+       assert(0);
+       return -1;
+}