Fixes mpaland#51: Now supporting MSVC-style integer specifiers: %I8, %I16, %I32, %I64.

Author: eyalroz

CMakeLists.txt

@@ -15,15 +15,17 @@ option(BUILD_STATIC_LIBRARY "Build the library as static rather than shared" OFF
 
 # Boolean options which go into config.h
 
-option(SUPPORT_DECIMAL_SPECIFIERS      "Support decimal notation floating-point conversion specifiers (%f,%F)" ON)
-option(SUPPORT_EXPONENTIAL_SPECIFIERS  "Support exponential floating point format conversion specifiers (%e,%E,%g,%G)" ON)
-option(SUPPORT_WRITEBACK_SPECIFIER     "Support the length write-back specifier (%n)" ON)
-option(SUPPORT_LONG_LONG               "Support long long integral types (allows for the ll length modifier and affects %p)" ON)
-option(ALIAS_STANDARD_FUNCTION_NAMES   "Alias the standard library function names (printf, sprintf etc.) to the library's functions" ON)
+option(SUPPORT_DECIMAL_SPECIFIERS             "Support decimal notation floating-point conversion specifiers (%f,%F)" ON)
+option(SUPPORT_EXPONENTIAL_SPECIFIERS         "Support exponential floating point format conversion specifiers (%e,%E,%g,%G)" ON)
+option(SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS  "Support the I + bit size integer specifiers (%I8, %I16, %I32, %I64) as in Microsoft Visual C++" ON)
+option(SUPPORT_WRITEBACK_SPECIFIER            "Support the length write-back specifier (%n)" ON)
+option(SUPPORT_LONG_LONG                      "Support long long integral types (allows for the ll length modifier and affects %p)" ON)
+option(ALIAS_STANDARD_FUNCTION_NAMES          "Alias the standard library function names (printf, sprintf etc.) to the library's functions" ON)
 
 foreach(opt
 	SUPPORT_DECIMAL_SPECIFIERS
 	SUPPORT_EXPONENTIAL_SPECIFIERS
+	SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS
 	SUPPORT_WRITEBACK_SPECIFIER
 	SUPPORT_LONG_LONG
 	ALIAS_STANDARD_FUNCTION_NAMES)

README.md

@@ -83,8 +83,9 @@ Options used both in CMake and in the library source code via a preprocessor def
 | PRINTF_DECIMAL_BUFFER_SIZE             | 32      |  ftoa (float) conversion buffer size. This must be big enough to hold one converted float number _including_ leading zeros, normally 32 is a sufficient value. Created on the stack. |
 | PRINTF_DEFAULT_FLOAT_PRECISION         | 6       |  Define the default floating point precision|
 | PRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL | 9       |  Maximum number of integral-part digits of a floating-point value for which printing with %f uses decimal (non-exponential) notation |
-| PRINTF_SUPPORT_DECIMAL_SPECIFIERS      | YES     |  Support decimal notation floating-point conversion specifiers (%f,%F) |
-| PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS  | YES     |  Support exponential floating point format conversion specifiers (%e,%E,%g,%G) |
+| PRINTF_SUPPORT_DECIMAL_SPECIFIERS      | YES     |  Support decimal notation floating-point conversion specifiers (%f, %F) |
+| PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS  | YES     |  Support exponential floating point format conversion specifiers (%e, %E, %g, %G) |
+| SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS  | YES     |  Support the 'I' + bit size integer specifiers (%I8, %I16, %I32, %I64) as in Microsoft Visual C++ |
 | PRINTF_SUPPORT_WRITEBACK_SPECIFIER     | YES     |  Support the length write-back specifier (%n) |
 | PRINTF_SUPPORT_LONG_LONG               | YES     |  Support long long integral types (allows for the ll length modifier and affects %p) |
 
@@ -175,6 +176,7 @@ Notes:
 * The `%a` specifier for hexadecimal floating-point notation (introduced in C99 and C++11) is _not_ currently supported.
 * If you want to print the percent sign (`%`, US-ASCII character 37), use "%%" in your format string.
 * The C standard library's `printf()`-style functions don't accept `float` arguments, only `double`'s; that is true for this library as well. `float`'s get converted to `double`'s.
+* There is no unsigned equivalent of the `I` specifier at the moment.
 
 #### Flags
 
@@ -207,22 +209,28 @@ Notes:
 
 The length sub-specifier modifies the length of the data type.
 
-| Length | With `d`, `i`             | With `u`,`o`,`x`, `X`  | Support enabled by...           |
-|--------|---------------------------|------------------------|---------------------------------|
-| (none) | int                       | unsigned int           |                                 |
-| hh     | signed char               | unsigned char          |                                 |
-| h      | short int                 | unsigned short int     |                                 |
-| l      | long int                  | unsigned long int      |                                 |
-| ll     | long long int             | unsigned long long int | PRINTF_SUPPORT_LONG_LONG        |
-| j      | intmax_t                  | uintmax_t              |                                 |
-| z      | signed version of size_t  | size_t                 |                                 |
-| t      | ptrdiff_t                 | ptrdiff_t              |                                 |
+| Length | With `d`, `i`             | With `u`,`o`,`x`, `X`  | Support enabled by...                 |
+|--------|---------------------------|------------------------|---------------------------------------|
+| (none) | int                       | unsigned int           |                                       |
+| hh     | signed char               | unsigned char          |                                       |
+| h      | short int                 | unsigned short int     |                                       |
+| l      | long int                  | unsigned long int      |                                       |
+| ll     | long long int             | unsigned long long int | PRINTF_SUPPORT_LONG_LONG              |
+| j      | intmax_t                  | uintmax_t              |                                       |
+| z      | signed version of size_t  | size_t                 |                                       |
+| t      | ptrdiff_t                 | ptrdiff_t              |                                       |
+| I8     | int8_t                    | uint8_t                | SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS |
+| I16    | int16_t                   | uint16_t               | SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS |
+| I32    | int32_t                   | uint32_t               | SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS |
+| I64    | int64_t                   | uint64_t               | SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS |
+
 
 Notes:
 
 * The `L` modifier, for `long double`, is not currently supported.
 * A `"%zd"` or `"%zi"` takes a signed integer of the same size as `size_t`. 
 * The implementation currently assumes each of `intmax_t`, signed `size_t`, and `ptrdiff_t` has the same size as `long int` or as `long long int`. If this is not the case for your platform, please open an issue.
+* The `Ixx` length modifiers are not in the C (nor C++) standard, but are somewhat popular, as it makes it easier to handle integer types of specific size. One must specify the argument size in bits immediately after the `I`. The printing is "integer-promotion-safe", i.e. the fact that an `int8_t` may actually be passed in promoted into a larger `int` will not prevent it from being printed using its origina value.
 
 ### Return Value
 

printf_config.h.in

@@ -5,6 +5,7 @@
 #define PRINTF_SUPPORT_DECIMAL_SPECIFIERS       @PRINTF_SUPPORT_DECIMAL_SPECIFIERS@
 #define PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS   @PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS@
 #define PRINTF_SUPPORT_WRITEBACK_SPECIFIER      @PRINTF_SUPPORT_WRITEBACK_SPECIFIER@
+#define PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS @PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS@
 #define PRINTF_SUPPORT_LONG_LONG                @PRINTF_SUPPORT_LONG_LONG@
 #define PRINTF_ALIAS_STANDARD_FUNCTION_NAMES    @PRINTF_ALIAS_STANDARD_FUNCTION_NAMES@
 

src/printf/printf.c

@@ -38,10 +38,16 @@
 
 #ifdef __cplusplus
 #include <cstdint>
+#ifdef PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS
+#include <climits>
+#endif
 extern "C" {
 #else
 #include <stdbool.h>
 #include <stdint.h>
+#ifdef PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS
+#include <limits.h>
+#endif
 #endif // __cplusplus
 
 // Define this globally (e.g. gcc -DPRINTF_INCLUDE_CONFIG_H ...) to include the
@@ -54,6 +60,13 @@ extern "C" {
 #include "printf_config.h"
 #endif
 
+#include <stdbool.h>
+#include <stdint.h>
+#ifdef PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS
+#include <limits.h>
+#endif
+
+
 #include <printf/printf.h>
 
 #if PRINTF_ALIAS_STANDARD_FUNCTION_NAMES
@@ -131,12 +144,61 @@ extern "C" {
 #define FLAGS_UPPERCASE (1U <<  5U)
 #define FLAGS_CHAR      (1U <<  6U)
 #define FLAGS_SHORT     (1U <<  7U)
-#define FLAGS_LONG      (1U <<  8U)
-#define FLAGS_LONG_LONG (1U <<  9U)
-#define FLAGS_PRECISION (1U << 10U)
-#define FLAGS_ADAPT_EXP (1U << 11U)
-#define FLAGS_POINTER   (1U << 12U)
-// Note: Similar, but not identical, effect as FLAGS_HASH
+#define FLAGS_INT       (1U <<  8U)
+  // Only used with PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS
+#define FLAGS_LONG      (1U <<  9U)
+#define FLAGS_LONG_LONG (1U << 10U)
+#define FLAGS_PRECISION (1U << 11U)
+#define FLAGS_ADAPT_EXP (1U << 12U)
+#define FLAGS_POINTER   (1U << 13U)
+  // Note: Similar, but not identical, effect as FLAGS_HASH
+#define FLAGS_SIGNED    (1U << 14U)
+  // Only used with PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS
+
+#ifdef PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS
+
+#define FLAGS_INT8 FLAGS_CHAR
+
+
+#if   (SHRT_MAX   == 32767LL)
+#define FLAGS_INT16       FLAGS_SHORT
+#elif (INT_MAX    == 32767LL)
+#define FLAGS_INT16       FLAGS_INT
+#elif (LONG_MAX   == 32767LL)
+#define FLAGS_INT16       FLAGS_LONG
+#elif (LLONG_MAX  == 32767LL)
+#define FLAGS_INT16       FLAGS_LONG_LONG
+#else
+#error "No basic integer type has a size of 16 bits exactly"
+#endif
+
+#if   (SHRT_MAX   == 2147483647LL)
+#define FLAGS_INT32       FLAGS_SHORT
+#elif (INT_MAX    == 2147483647LL)
+#define FLAGS_INT32       FLAGS_INT
+#elif (LONG_MAX   == 2147483647LL)
+#define FLAGS_INT32       FLAGS_LONG
+#elif (LLONG_MAX  == 2147483647LL)
+#define FLAGS_INT32       FLAGS_LONG_LONG
+#else
+#error "No basic integer type has a size of 32 bits exactly"
+#endif
+
+#if   (SHRT_MAX   == 9223372036854775807LL)
+#define FLAGS_INT64       FLAGS_SHORT
+#elif (INT_MAX    == 9223372036854775807LL)
+#define FLAGS_INT64       FLAGS_INT
+#elif (LONG_MAX   == 9223372036854775807LL)
+#define FLAGS_INT64       FLAGS_LONG
+#elif (LLONG_MAX  == 9223372036854775807LL)
+#define FLAGS_INT64       FLAGS_LONG_LONG
+#else
+#error "No basic integer type has a size of 64 bits exactly"
+#endif
+
+#endif // PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS
+
+
 typedef unsigned int printf_flags_t;
 
 #define BASE_BINARY    2
@@ -829,6 +891,7 @@ static size_t print_floating_point(out_fct_type out, char* buffer, size_t idx, s
 
 #endif  // (PRINTF_SUPPORT_DECIMAL_SPECIFIERS || PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS)
 
+
 // internal vsnprintf
 static int _vsnprintf(out_fct_type out, char* buffer, printf_size_t maxlen, const char* format, va_list va)
 {
@@ -902,6 +965,31 @@ static int _vsnprintf(out_fct_type out, char* buffer, printf_size_t maxlen, cons
 
     // evaluate length field
     switch (*format) {
+#ifdef PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS
+      case 'I' : {
+        format++;
+        // Greedily parse for size in bits: 8, 16, 32 or 64
+        switch(*format) {
+          case '8':               flags |= FLAGS_INT8;
+            format++;
+            break;
+          case '1':
+            format++;
+            if (*format == '6') { format++; flags |= FLAGS_INT16; }
+            break;
+          case '3':
+            format++;
+            if (*format == '2') { format++; flags |= FLAGS_INT32; }
+            break;
+          case '6':
+            format++;
+            if (*format == '4') { format++; flags |= FLAGS_INT64; }
+            break;
+          default: break;
+        }
+        break;
+      }
+#endif
       case 'l' :
         flags |= FLAGS_LONG;
         format++;
@@ -943,7 +1031,11 @@ static int _vsnprintf(out_fct_type out, char* buffer, printf_size_t maxlen, cons
       case 'X' :
       case 'o' :
       case 'b' : {
-        // set the base
+
+        if (*format == 'd' || *format == 'i') {
+          flags |= FLAGS_SIGNED;
+        }
+
         numeric_base_t base;
         if (*format == 'x' || *format == 'X') {
           base = BASE_HEX;
@@ -956,26 +1048,22 @@ static int _vsnprintf(out_fct_type out, char* buffer, printf_size_t maxlen, cons
         }
         else {
           base = BASE_DECIMAL;
-          flags &= ~FLAGS_HASH;   // no hash for dec format
+          flags &= ~FLAGS_HASH; // decimal integers have no alternative presentation
         }
-        // uppercase
+
         if (*format == 'X') {
           flags |= FLAGS_UPPERCASE;
         }
 
-        // no plus or space flag for u, x, X, o, b
-        if ((*format != 'i') && (*format != 'd')) {
-          flags &= ~(FLAGS_PLUS | FLAGS_SPACE);
-        }
-
+        format++;
         // ignore '0' flag when precision is given
         if (flags & FLAGS_PRECISION) {
           flags &= ~FLAGS_ZEROPAD;
         }
 
-        // convert the integer
-        if ((*format == 'i') || (*format == 'd')) {
-          // signed
+        if (flags & FLAGS_SIGNED) {
+          // A signed specifier: d, i or possibly I + bit size if enabled
+
           if (flags & FLAGS_LONG_LONG) {
 #if PRINTF_SUPPORT_LONG_LONG
             const long long value = va_arg(va, long long);
@@ -987,12 +1075,22 @@ static int _vsnprintf(out_fct_type out, char* buffer, printf_size_t maxlen, cons
             idx = print_integer(out, buffer, idx, maxlen, ABS_FOR_PRINTING(value), value < 0, base, precision, width, flags);
           }
           else {
-            const int value = (flags & FLAGS_CHAR) ? (signed char)va_arg(va, int) : (flags & FLAGS_SHORT) ? (short int)va_arg(va, int) : va_arg(va, int);
+            // We never try to interpret the argument as something potentially-smaller than int,
+            // due to integer promotion rules: Even if the user passed a short int, short unsigned
+            // etc. - these will come in after promotion, as int's (or unsigned for the case of
+            // short unsigned when it has the same size as int)
+            const int value =
+              (flags & FLAGS_CHAR) ? (signed char) va_arg(va, int) :
+              (flags & FLAGS_SHORT) ? (short int) va_arg(va, int) :
+              va_arg(va, int);
             idx = print_integer(out, buffer, idx, maxlen, ABS_FOR_PRINTING(value), value < 0, base, precision, width, flags);
           }
         }
         else {
-          // unsigned
+          // An unsigned specifier: u, x, X, o, b
+  
+          flags &= ~(FLAGS_PLUS | FLAGS_SPACE);
+  
           if (flags & FLAGS_LONG_LONG) {
 #if PRINTF_SUPPORT_LONG_LONG
             idx = print_integer(out, buffer, idx, maxlen, (printf_unsigned_value_t) va_arg(va, unsigned long long), false, base, precision, width, flags);
@@ -1002,11 +1100,13 @@ static int _vsnprintf(out_fct_type out, char* buffer, printf_size_t maxlen, cons
             idx = print_integer(out, buffer, idx, maxlen, (printf_unsigned_value_t) va_arg(va, unsigned long), false, base, precision, width, flags);
           }
           else {
-            const unsigned int value = (flags & FLAGS_CHAR) ? (unsigned char)va_arg(va, unsigned int) : (flags & FLAGS_SHORT) ? (unsigned short int)va_arg(va, unsigned int) : va_arg(va, unsigned int);
+            const unsigned int value =
+              (flags & FLAGS_CHAR) ? (unsigned char)va_arg(va, unsigned int) :
+              (flags & FLAGS_SHORT) ? (unsigned short int)va_arg(va, unsigned int) :
+              va_arg(va, unsigned int);
             idx = print_integer(out, buffer, idx, maxlen, (printf_unsigned_value_t) value, false, base, precision, width, flags);
           }
         }
-        format++;
         break;
       }
 #if PRINTF_SUPPORT_DECIMAL_SPECIFIERS