feat(printf): added support for %h, %hh, %j and %t length modifiers

- Renamed compiler switches
- Minor cleanup
Closes #12

README.md

@@ -12,7 +12,7 @@ Primarily designed for usage in embedded systems, where printf is not available
 Using the standard libc printf may pull **a lot** of unwanted library stuff and can bloat code size about 20k or is not 100% thread safe. In this cases the following implementation can be used.  
 Absolutely **NO dependencies** are required, *printf.c* brings all necessary routines, even its own fast `ftoa` (float), `ntoa` (decimal) conversion.
 
-If memory footprint is really a critical issue, floating point and 'long long' support and can be turned off via the `PRINTF_FLOAT_SUPPORT` and `PRINTF_LONG_LONG_SUPPORT` compiler switches.
+If memory footprint is really a critical issue, floating point and 'long long' support and can be turned off via the `PRINTF_SUPPORT_FLOAT` and `PRINTF_SUPPORT_LONG_LONG` compiler switches.
 When using printf (instead of sprintf/snprintf) you have to provide your own `_putchar()` low level function as console/serial output.
 
 
@@ -52,7 +52,12 @@ int snprintf(char* buffer, size_t count, const char* format, ...);
 int vsnprintf(char* buffer, size_t count, const char* format, va_list va);
 ```
 
-**Due to genaral security reasons it is highly recommended to use `snprintf` (with the max buffer size as `count` parameter) instead of `sprintf`.**  
+If `buffer` is set to `nullptr` nothing is written and just the formatted length is returned.
+```C
+int length = sprintf(nullptr, "Hello, world"); // length is set to 12
+```
+
+**Due to genaral security reasons it is highly recommended to prefer and use `snprintf` (with the max buffer size as `count` parameter) instead of `sprintf`.**  
 `sprintf` has no buffer limitation, so when needed - use it really with care!
 
 
@@ -113,9 +118,13 @@ The length sub-specifier modifies the length of the data type.
 | Length | d i  | u o x X |
 |--------|------|---------|
 | (none) | int  | unsigned int |
+| hh     | char | unsigned char |
+| h      | short int | unsigned short int |
 | l      | long int | unsigned long int |
-| ll     | long long int | unsigned long long int (if PRINTF_LONG_LONG_SUPPORT is defined) |
-| z      | size_t int | unsigned size_t int |
+| ll     | long long int | unsigned long long int (if PRINTF_SUPPORT_LONG_LONG is defined) |
+| j      | intmax_t | uintmax_t |
+| z      | size_t | size_t |
+| t      | ptrdiff_t | ptrdiff_t (if PRINTF_SUPPORT_PTRDIFF_T is defined) |
 
 
 ### Return value
@@ -134,8 +143,9 @@ If any error is encountered, `-1` is returned.
 |------|---------------|-------------|
 | PRINTF_NTOA_BUFFER_SIZE  | 32        | ntoa (integer) conversion buffer size. This must be big enough to hold one converted numeric number _including_ leading zeros, normally 32 is a sufficient value. Created on the stack |
 | PRINTF_FTOA_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_FLOAT_SUPPORT     | undefined | Define this to enable floating point (%f) support |
-| PRINTF_LONG_LONG_SUPPORT | undefined | Define this to enable long long (%ll) support |
+| PRINTF_SUPPORT_FLOAT     | defined   | Define this to enable floating point (%f) support |
+| PRINTF_SUPPORT_LONG_LONG | defined   | Define this to enable long long (%ll) support |
+| PRINTF_SUPPORT_PTRDIFF_T | defined   | Define this to enable ptrdiff_t (%t) support |
 
 
 ## Test suite

printf.c

@@ -36,32 +36,42 @@
 
 
 // ntoa conversion buffer size, this must be big enough to hold
-// one converted numeric number including padded zeros (dyn created on stack)
+// one converted numeric number including padded zeros (dynamically created on stack)
+// 32 byte is a good default
 #define PRINTF_NTOA_BUFFER_SIZE    32U
 
 // ftoa conversion buffer size, this must be big enough to hold
-// one converted float number including padded zeros (dyn created on stack)
+// one converted float number including padded zeros (dynamically created on stack)
+// 32 byte is a good default
 #define PRINTF_FTOA_BUFFER_SIZE    32U
 
 // define this to support floating point (%f)
-#define PRINTF_FLOAT_SUPPORT
+#define PRINTF_SUPPORT_FLOAT
 
 // define this to support long long types (%llu or %p)
-#define PRINTF_LONG_LONG_SUPPORT
+#define PRINTF_SUPPORT_LONG_LONG
+
+// define this to support the ptrdiff_t type (%t)
+// ptrdiff_t is normally defined in <stddef.h> as long or long long type
+#define PRINTF_SUPPORT_PTRDIFF_T
+
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // internal flag definitions
-#define FLAGS_ZEROPAD   (1U << 0U)
-#define FLAGS_LEFT      (1U << 1U)
-#define FLAGS_PLUS      (1U << 2U)
-#define FLAGS_SPACE     (1U << 3U)
-#define FLAGS_HASH      (1U << 4U)
-#define FLAGS_UPPERCASE (1U << 5U)
-#define FLAGS_LONG      (1U << 6U)
-#define FLAGS_LONG_LONG (1U << 7U)
-#define FLAGS_PRECISION (1U << 8U)
-#define FLAGS_WIDTH     (1U << 9U)
+#define FLAGS_ZEROPAD   (1U <<  0U)
+#define FLAGS_LEFT      (1U <<  1U)
+#define FLAGS_PLUS      (1U <<  2U)
+#define FLAGS_SPACE     (1U <<  3U)
+#define FLAGS_HASH      (1U <<  4U)
+#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_WIDTH     (1U << 11U)
+
 
 // output function type
 typedef void (*out_fct_type)(char character, char* buffer, size_t idx, size_t maxlen);
@@ -93,11 +103,11 @@ static inline void _out_char(char character, char* buffer, size_t idx, size_t ma
 
 // internal strlen
 // \return The length of the string (excluding the terminating 0)
-static inline size_t _strlen(const char* str)
+static inline unsigned int _strlen(const char* str)
 {
   const char* s;
   for (s = str; *s; ++s);
-  return (size_t)(s - str);
+  return (unsigned int)(s - str);
 }
 
 
@@ -209,7 +219,7 @@ static size_t _ntoa_long(out_fct_type out, char* buffer, size_t idx, size_t maxl
 
 
 // internal itoa for 'long long' type
-#if defined(PRINTF_LONG_LONG_SUPPORT)
+#if defined(PRINTF_SUPPORT_LONG_LONG)
 static size_t _ntoa_long_long(out_fct_type out, char* buffer, size_t idx, size_t maxlen, unsigned long long value, bool negative, unsigned long long base, unsigned int prec, unsigned int width, unsigned int flags)
 {
   char buf[PRINTF_NTOA_BUFFER_SIZE];
@@ -226,10 +236,10 @@ static size_t _ntoa_long_long(out_fct_type out, char* buffer, size_t idx, size_t
 
   return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags);
 }
-#endif  // PRINTF_LONG_LONG_SUPPORT
+#endif  // PRINTF_SUPPORT_LONG_LONG
 
 
-#if defined(PRINTF_FLOAT_SUPPORT)
+#if defined(PRINTF_SUPPORT_FLOAT)
 static size_t _ftoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags)
 {
   char buf[PRINTF_FTOA_BUFFER_SIZE];
@@ -271,13 +281,13 @@ static size_t _ftoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, d
       ++whole;
     }
   }
-  else if ((diff == 0.5) && ((frac == 0) || (frac & 1))) {
+  else if ((diff == 0.5) && ((frac == 0U) || (frac & 1U))) {
     // if halfway, round up if odd, OR if last digit is 0
     ++frac;
   }
 
-  // TBD: for very large numbers switch back to native sprintf for exponentials. anyone want to write code to replace this?
-  // normal printf behavior is to print EVERY whole number digit which can be 100s of characters overflowing your buffers == bad
+  // TBD: for very large numbers switch back to native sprintf for exponentials. Anyone want to write code to replace this?
+  // Normal printf behavior is to print EVERY whole number digit which can be 100s of characters overflowing your buffers == bad
   if (value > thres_max) {
     return 0U;
   }
@@ -288,7 +298,7 @@ static size_t _ftoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, d
       // greater than 0.5, round up, e.g. 1.6 -> 2
       ++whole;
     }
-    else if ((diff == 0.5) && (whole & 1)) {
+    else if ((diff == 0.5) && (whole & 1U)) {
       // exactly 0.5 and ODD, then round up
       // 1.5 -> 2, but 2.5 -> 2
       ++whole;
@@ -361,7 +371,7 @@ static size_t _ftoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, d
 
   return idx;
 }
-#endif  // PRINTF_FLOAT_SUPPORT
+#endif  // PRINTF_SUPPORT_FLOAT
 
 
 // internal vsnprintf
@@ -434,17 +444,39 @@ static int _vsnprintf(out_fct_type out, char* buffer, const size_t maxlen, const
     }
 
     // evaluate length field
-    if (*format == 'l' || *format == 'L') {
-      flags |= FLAGS_LONG;
-      format++;
-    }
-    if ((*format == 'l') && (flags & FLAGS_LONG)) {
-      flags |= FLAGS_LONG_LONG;
-      format++;
-    }
-    if (*format == 'z') {
-      flags |= (sizeof(size_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
-      format++;
+    switch (*format) {
+      case 'l' :
+        flags |= FLAGS_LONG;
+        format++;
+        if (*format == 'l') {
+          flags |= FLAGS_LONG_LONG;
+          format++;
+        }
+        break;
+      case 'h' :
+        flags |= FLAGS_SHORT;
+        format++;
+        if (*format == 'h') {
+          flags |= FLAGS_CHAR;
+          format++;
+        }
+        break;
+#if defined(PRINTF_SUPPORT_PTRDIFF_T)
+      case 't' :
+        flags |= (sizeof(ptrdiff_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
+        format++;
+        break;
+#endif
+      case 'j' :
+        flags |= (sizeof(intmax_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
+        format++;
+        break;
+      case 'z' :
+        flags |= (sizeof(size_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
+        format++;
+        break;
+      default :
+        break;
     }
 
     // evaluate specifier
@@ -486,7 +518,7 @@ static int _vsnprintf(out_fct_type out, char* buffer, const size_t maxlen, const
         if ((*format == 'i') || (*format == 'd')) {
           // signed
           if (flags & FLAGS_LONG_LONG) {
-#if defined(PRINTF_LONG_LONG_SUPPORT)
+#if defined(PRINTF_SUPPORT_LONG_LONG)
             const long long value = va_arg(va, long long);
             idx = _ntoa_long_long(out, buffer, idx, maxlen, (unsigned long long)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags);
 #endif
@@ -496,14 +528,14 @@ static int _vsnprintf(out_fct_type out, char* buffer, const size_t maxlen, const
             idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned long)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags);
           }
           else {
-            const int value = va_arg(va, int);
+            const int value = (flags & FLAGS_CHAR) ? va_arg(va, char) : (flags & FLAGS_SHORT) ? va_arg(va, short int) : va_arg(va, int);
             idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned int)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags);
           }
         }
         else {
           // unsigned
           if (flags & FLAGS_LONG_LONG) {
-#if defined(PRINTF_LONG_LONG_SUPPORT)
+#if defined(PRINTF_SUPPORT_LONG_LONG)
             idx = _ntoa_long_long(out, buffer, idx, maxlen, va_arg(va, unsigned long long), false, base, precision, width, flags);
 #endif
           }
@@ -511,21 +543,22 @@ static int _vsnprintf(out_fct_type out, char* buffer, const size_t maxlen, const
             idx = _ntoa_long(out, buffer, idx, maxlen, va_arg(va, unsigned long), false, base, precision, width, flags);
           }
           else {
-            idx = _ntoa_long(out, buffer, idx, maxlen, va_arg(va, unsigned int), false, base, precision, width, flags);
+            const unsigned int value = (flags & FLAGS_CHAR) ? va_arg(va, unsigned char) : (flags & FLAGS_SHORT) ? va_arg(va, unsigned short int) : va_arg(va, unsigned int);
+            idx = _ntoa_long(out, buffer, idx, maxlen, value, false, base, precision, width, flags);
           }
         }
         format++;
         break;
       }
-#if defined(PRINTF_FLOAT_SUPPORT)
+#if defined(PRINTF_SUPPORT_FLOAT)
       case 'f' :
       case 'F' :
         idx = _ftoa(out, buffer, idx, maxlen, va_arg(va, double), precision, width, flags);
         format++;
         break;
-#endif  // PRINTF_FLOAT_SUPPORT
+#endif  // PRINTF_SUPPORT_FLOAT
       case 'c' : {
-        size_t l = 1U;
+        unsigned int l = 1U;
         // pre padding
         if (!(flags & FLAGS_LEFT)) {
           while (l++ < width) {
@@ -546,7 +579,7 @@ static int _vsnprintf(out_fct_type out, char* buffer, const size_t maxlen, const
 
       case 's' : {
         char* p = va_arg(va, char*);
-        size_t l = _strlen(p);
+        unsigned int l = _strlen(p);
         // pre padding
         if (flags & FLAGS_PRECISION) {
           l = (l < precision ? l : precision);
@@ -573,14 +606,14 @@ static int _vsnprintf(out_fct_type out, char* buffer, const size_t maxlen, const
       case 'p' : {
         width = sizeof(void*) * 2U;
         flags |= FLAGS_ZEROPAD | FLAGS_UPPERCASE;
-#if defined(PRINTF_LONG_LONG_SUPPORT)
+#if defined(PRINTF_SUPPORT_LONG_LONG)
         if (sizeof(uintptr_t) == sizeof(long long)) {
           idx = _ntoa_long_long(out, buffer, idx, maxlen, (uintptr_t)va_arg(va, void*), false, 16U, precision, width, flags);
         }
         else {
 #endif
           idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned long)((uintptr_t)va_arg(va, void*)), false, 16U, precision, width, flags);
-#if defined(PRINTF_LONG_LONG_SUPPORT)
+#if defined(PRINTF_SUPPORT_LONG_LONG)
         }
 #endif
         format++;
@@ -644,4 +677,3 @@ inline int vsnprintf(char* buffer, size_t count, const char* format, va_list va)
 {
   return _vsnprintf(_out_buffer, buffer, count, format, va);
 }
-

test/test_suite.cpp

@@ -994,6 +994,18 @@ TEST_CASE("types", "[]" ) {
 
   test::sprintf(buffer, "%s", "A Test");
   REQUIRE(!strcmp(buffer, "A Test"));
+
+  test::sprintf(buffer, "%hhu", 0xFFFFUL);
+  REQUIRE(!strcmp(buffer, "255"));
+
+  test::sprintf(buffer, "%hu", 0x123456UL);
+  REQUIRE(!strcmp(buffer, "13398"));
+
+  test::sprintf(buffer, "%s%hhi %hu", "Test", 10000, 0xFFFFFFFF);
+  REQUIRE(!strcmp(buffer, "Test16 65535"));
+
+  test::sprintf(buffer, "%tx", &buffer[10] - &buffer[0]);
+  REQUIRE(!strcmp(buffer, "a"));
 }