From 33f10559d63605caedcc3491bb6398354371b09c Mon Sep 17 00:00:00 2001 From: Marco Paland Date: Tue, 8 May 2018 10:15:23 +0200 Subject: refactor(printf): usage of (buffer) output routine, fixes return value Buffer for printf is no longer needed, chars are directly written now. Return value is specification conform now. Fixes #11 --- README.md | 22 ++++---- printf.c | 158 ++++++++++++++++++++++++++-------------------------- test/test_suite.cpp | 22 +++++--- 3 files changed, 103 insertions(+), 99 deletions(-) diff --git a/README.md b/README.md index de9df96..f415329 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,7 @@ Therefore I decided to write an own, final implementation which meets the follow - NO dependencies, no libs, just one module file - Support of all important flags, width and precision sub-specifiers (see below) - Support of decimal/floating number representation (with an own fast itoa/ftoa) - - Reentrant and thread-safe, malloc free + - Reentrant and thread-safe, malloc free, no static vars/buffers - LINT and compiler L4 warning free, mature, coverity clean, automotive ready - Extensive test suite (> 310 test cases) passing - Simply the best *printf* around the net @@ -119,24 +119,22 @@ The length sub-specifier modifies the length of the data type. ### Return value -Upon successful return, all functions return the number of characters _written_, _excluding_ the null byte used to end the string. -Functions `snprintf()` and `vsnprintf()` don't write more than `count` bytes, _including_ the terminating null byte ('\0'). If the output was truncated -due to this limit, the return value is `count`, which indicates any truncation. -If an output error (invalid buffer etc.) is encountered, `-1` is returned. - -## Caveats -Currently `snprintf()` and `vsnprintf()` don't support `(v)snprintf(nullptr, 0, "Some text")` to get the length of the formatted string only. An error value of `-1` is returned. +Upon successful return, all functions return the number of characters written, _excluding_ the terminating null character used to end the string. +Functions `snprintf()` and `vsnprintf()` don't write more than `count` bytes, _including_ the terminating null byte ('\0'). +Anyway, if the output was truncated due to this limit, the return value is the number of characters that _could_ have been written. +Notice that a value equal or larger than `count` indicates a truncation. Only when the returned value is non-negative and less than `count`, +the string has been completely written. +If any error is encountered, `-1` is returned. ## Compiler switches/defines | Name | Default value | Description | |------|---------------|-------------| -| PRINTF_BUFFER_SIZE | 128 | The buffer size used for the printf() function (not for sprintf/snprintf). Set to 0 if the printf() function is unused (just using sprintf/snprintf) | -| 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 | -| 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 | -| PRINTF_FLOAT_SUPPORT | undefined | Define this to enable floating point (%f) support | +| 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 | diff --git a/printf.c b/printf.c index 3bed79c..d373781 100644 --- a/printf.c +++ b/printf.c @@ -35,15 +35,12 @@ #include "printf.h" -// buffer size used omly for printf (created on stack) -#define PRINTF_BUFFER_SIZE 128U - // ntoa conversion buffer size, this must be big enough to hold -// one converted numeric number including padded zeros (created on stack) +// one converted numeric number including padded zeros (dyn created on stack) #define PRINTF_NTOA_BUFFER_SIZE 32U // ftoa conversion buffer size, this must be big enough to hold -// one converted float number including padded zeros (created on stack) +// one converted float number including padded zeros (dyn created on stack) #define PRINTF_FTOA_BUFFER_SIZE 32U // define this to support floating point (%f) @@ -66,6 +63,26 @@ #define FLAGS_PRECISION (1U << 8U) #define FLAGS_WIDTH (1U << 9U) +// output function type +typedef void (*out_fct_type)(char character, char* buffer, size_t idx, size_t maxlen); + + +// internal buffer output +static inline void _out_buffer(char character, char* buffer, size_t idx, size_t maxlen) +{ + if (!!buffer && (idx < maxlen)) { + buffer[idx] = character; + } +} + + +// internal _putchar wrapper +static inline void _out_char(char character, char* buffer, size_t idx, size_t maxlen) +{ + (void)buffer; (void)idx; (void)maxlen; + _putchar(character); +} + // internal strlen // \return The length of the string (excluding the terminating 0) @@ -97,15 +114,8 @@ static inline unsigned int _atoi(const char** str) // internal itoa format -static size_t _ntoa_format(char* buffer, char* buf, size_t len, bool negative, unsigned int base, size_t maxlen, unsigned int prec, unsigned int width, unsigned int flags) +static size_t _ntoa_format(out_fct_type out, char* buffer, size_t idx, size_t maxlen, char* buf, size_t len, bool negative, unsigned int base, unsigned int prec, unsigned int width, unsigned int flags) { - if (maxlen == 0U) { - return 0U; - } - if (base > 16U) { - return 0U; - } - // pad leading zeros while (!(flags & FLAGS_LEFT) && (len < prec) && (len < PRINTF_NTOA_BUFFER_SIZE)) { buf[len++] = '0'; @@ -150,22 +160,21 @@ static size_t _ntoa_format(char* buffer, char* buf, size_t len, bool negative, u } // pad spaces up to given width - size_t idx = 0U; if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) { - for (size_t i = len; (i < width) && (i < maxlen); ++i) { - buffer[idx++] = ' '; + for (size_t i = len; i < width; i++) { + out(' ', buffer, idx++, maxlen); } } // reverse string - for (size_t i = 0U; (i < len) && (i < maxlen); ++i) { - buffer[idx++] = buf[len - i - 1U]; + for (size_t i = 0U; i < len; i++) { + out(buf[len - i - 1U], buffer, idx++, maxlen); } // append pad spaces up to given width if (flags & FLAGS_LEFT) { - while ((idx < width) && (idx < maxlen)) { - buffer[idx++] = ' '; + while (idx < width) { + out(' ', buffer, idx++, maxlen); } } @@ -174,7 +183,7 @@ static size_t _ntoa_format(char* buffer, char* buf, size_t len, bool negative, u // internal itoa for 'long' type -static size_t _ntoa_long(char* buffer, unsigned long value, bool negative, unsigned long base, size_t maxlen, unsigned int prec, unsigned int width, unsigned int flags) +static size_t _ntoa_long(out_fct_type out, char* buffer, size_t idx, size_t maxlen, unsigned long value, bool negative, unsigned long base, unsigned int prec, unsigned int width, unsigned int flags) { char buf[PRINTF_NTOA_BUFFER_SIZE]; size_t len = 0U; @@ -182,19 +191,19 @@ static size_t _ntoa_long(char* buffer, unsigned long value, bool negative, unsig // write if precision != 0 and value is != 0 if (!(flags & FLAGS_PRECISION) || value) { do { - char digit = (char)(value % base); + const char digit = (char)(value % base); buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10; value /= base; - } while ((len < PRINTF_NTOA_BUFFER_SIZE) && value); + } while (value && (len < PRINTF_NTOA_BUFFER_SIZE)); } - return _ntoa_format(buffer, buf, len, negative, (unsigned int)base, maxlen, prec, width, flags); + return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags); } // internal itoa for 'long long' type #if defined(PRINTF_LONG_LONG_SUPPORT) -static size_t _ntoa_long_long(char* buffer, unsigned long long value, bool negative, unsigned long long base, size_t maxlen, unsigned int prec, unsigned int width, unsigned int flags) +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]; size_t len = 0U; @@ -202,19 +211,19 @@ static size_t _ntoa_long_long(char* buffer, unsigned long long value, bool negat // write if precision != 0 and value is != 0 if (!(flags & FLAGS_PRECISION) || value) { do { - char digit = (char)(value % base); + const char digit = (char)(value % base); buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10; value /= base; - } while ((len < PRINTF_NTOA_BUFFER_SIZE) && value); + } while (value && (len < PRINTF_NTOA_BUFFER_SIZE)); } - return _ntoa_format(buffer, buf, len, negative, (unsigned int)base, maxlen, prec, width, flags); + return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags); } #endif // PRINTF_LONG_LONG_SUPPORT #if defined(PRINTF_FLOAT_SUPPORT) -static size_t _ftoa(double value, char* buffer, size_t maxlen, unsigned int prec, unsigned int width, unsigned int flags) +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]; size_t len = 0U; @@ -325,22 +334,21 @@ static size_t _ftoa(double value, char* buffer, size_t maxlen, unsigned int prec } // pad spaces up to given width - size_t idx = 0U; if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) { - for (size_t i = len; (i < width) && (i < maxlen); ++i) { - buffer[idx++] = ' '; + for (size_t i = len; i < width; i++) { + out(' ', buffer, idx++, maxlen); } } // reverse string - for (size_t i = 0U; (i < len) && (i < maxlen); ++i) { - buffer[idx++] = buf[len - i - 1U]; + for (size_t i = 0U; i < len; i++) { + out(buf[len - i - 1U], buffer, idx++, maxlen); } // append pad spaces up to given width if (flags & FLAGS_LEFT) { - while ((idx < width) && (idx < maxlen)) { - buffer[idx++] = ' '; + while (idx < width) { + out(' ', buffer, idx++, maxlen); } } @@ -350,22 +358,17 @@ static size_t _ftoa(double value, char* buffer, size_t maxlen, unsigned int prec // internal vsnprintf -static int _vsnprintf(char* buffer, size_t buffer_len, const char* format, va_list va) +static int _vsnprintf(out_fct_type out, char* buffer, const size_t maxlen, const char* format, va_list va) { unsigned int flags, width, precision, n; size_t idx = 0U; - // check if buffer is valid - if (!buffer) { - return -1; - } - - while ((idx < buffer_len) && *format) + while (*format) { // format specifier? %[flags][width][.precision][length] if (*format != '%') { // no - buffer[idx++] = *format; + out(*format, buffer, idx++, maxlen); format++; continue; } @@ -473,30 +476,30 @@ static int _vsnprintf(char* buffer, size_t buffer_len, const char* format, va_li if (flags & FLAGS_LONG_LONG) { #if defined(PRINTF_LONG_LONG_SUPPORT) const long long value = va_arg(va, long long); - idx += _ntoa_long_long(&buffer[idx], (unsigned long long)(value > 0 ? value : 0 - value), value < 0, base, buffer_len - idx, precision, width, flags); + idx = _ntoa_long_long(out, buffer, idx, maxlen, (unsigned long long)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags); #endif } else if (flags & FLAGS_LONG) { const long value = va_arg(va, long); - idx += _ntoa_long(&buffer[idx], (unsigned long)(value > 0 ? value : 0 - value), value < 0, base, buffer_len - idx, precision, width, flags); + 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); - idx += _ntoa_long(&buffer[idx], (unsigned int)(value > 0 ? value : 0 - value), value < 0, base, buffer_len - idx, precision, width, flags); + 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) - idx += _ntoa_long_long(&buffer[idx], va_arg(va, unsigned long long), false, base, buffer_len - idx, precision, width, flags); + idx = _ntoa_long_long(out, buffer, idx, maxlen, va_arg(va, unsigned long long), false, base, precision, width, flags); #endif } else if (flags & FLAGS_LONG) { - idx += _ntoa_long(&buffer[idx], va_arg(va, unsigned long), false, base, buffer_len - idx, precision, width, flags); + idx = _ntoa_long(out, buffer, idx, maxlen, va_arg(va, unsigned long), false, base, precision, width, flags); } else { - idx += _ntoa_long(&buffer[idx], va_arg(va, unsigned int), false, base, buffer_len - idx, precision, width, flags); + idx = _ntoa_long(out, buffer, idx, maxlen, va_arg(va, unsigned int), false, base, precision, width, flags); } } format++; @@ -505,7 +508,7 @@ static int _vsnprintf(char* buffer, size_t buffer_len, const char* format, va_li #if defined(PRINTF_FLOAT_SUPPORT) case 'f' : case 'F' : - idx += _ftoa(va_arg(va, double), &buffer[idx], buffer_len - idx, precision, width, flags); + idx = _ftoa(out, buffer, idx, maxlen, va_arg(va, double), precision, width, flags); format++; break; #endif // PRINTF_FLOAT_SUPPORT @@ -513,16 +516,16 @@ static int _vsnprintf(char* buffer, size_t buffer_len, const char* format, va_li size_t l = 1U; // pre padding if (!(flags & FLAGS_LEFT)) { - while ((idx < buffer_len) && (l++ < width)) { - buffer[idx++] = ' '; + while (l++ < width) { + out(' ', buffer, idx++, maxlen); } } // char output - buffer[idx++] = (char)va_arg(va, int); + out((char)va_arg(va, int), buffer, idx++, maxlen); // post padding if (flags & FLAGS_LEFT) { - while ((idx < buffer_len) && (l++ < width)) { - buffer[idx++] = ' '; + while (l++ < width) { + out(' ', buffer, idx++, maxlen); } } format++; @@ -537,18 +540,18 @@ static int _vsnprintf(char* buffer, size_t buffer_len, const char* format, va_li l = (l < precision ? l : precision); } if (!(flags & FLAGS_LEFT)) { - while ((idx < buffer_len) && (l++ < width)) { - buffer[idx++] = ' '; + while (l++ < width) { + out(' ', buffer, idx++, maxlen); } } // string output - while ((idx < buffer_len) && (*p != 0) && (!(flags & FLAGS_PRECISION) || precision--)) { - buffer[idx++] = *(p++); + while ((*p != 0) && (!(flags & FLAGS_PRECISION) || precision--)) { + out(*(p++), buffer, idx++, maxlen); } // post padding if (flags & FLAGS_LEFT) { - while ((idx < buffer_len) && (l++ < width)) { - buffer[idx++] = ' '; + while (l++ < width) { + out(' ', buffer, idx++, maxlen); } } format++; @@ -558,34 +561,34 @@ static int _vsnprintf(char* buffer, size_t buffer_len, const char* format, va_li case 'p' : { width = sizeof(void*) * 2U; flags |= FLAGS_ZEROPAD | FLAGS_UPPERCASE; - if (sizeof(uintptr_t) == sizeof(long long)) { #if defined(PRINTF_LONG_LONG_SUPPORT) - idx += _ntoa_long_long(&buffer[idx], (uintptr_t)va_arg(va, void*), false, 16U, buffer_len - idx, precision, width, flags); -#endif + 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 { - idx += _ntoa_long(&buffer[idx], (unsigned long)((uintptr_t)va_arg(va, void*)), false, 16U, buffer_len - idx, precision, width, flags); +#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) } +#endif format++; break; } case '%' : - buffer[idx++] = '%'; + out('%', buffer, idx++, maxlen); format++; break; default : - buffer[idx++] = *format; + out(*format, buffer, idx++, maxlen); format++; break; } } // termination - if (buffer_len > 0U) { - buffer[idx == buffer_len ? buffer_len - 1U : idx] = (char)0; - } + out((char)0, buffer, idx < maxlen ? idx : maxlen - 1U, maxlen); // return written chars without terminating \0 return (int)idx; @@ -594,16 +597,13 @@ static int _vsnprintf(char* buffer, size_t buffer_len, const char* format, va_li /////////////////////////////////////////////////////////////////////////////// + int printf(const char* format, ...) { va_list va; va_start(va, format); - char buffer[PRINTF_BUFFER_SIZE]; - int ret = _vsnprintf(buffer, PRINTF_BUFFER_SIZE, format, va); + const int ret = _vsnprintf(_out_char, nullptr, (size_t)-1, format, va); va_end(va); - for (size_t i = 0U; i < ret; ++i) { - _putchar(buffer[i]); - } return ret; } @@ -612,7 +612,7 @@ int sprintf(char* buffer, const char* format, ...) { va_list va; va_start(va, format); - int ret = _vsnprintf(buffer, (size_t)-1, format, va); + const int ret = _vsnprintf(_out_buffer, buffer, (size_t)-1, format, va); va_end(va); return ret; } @@ -622,7 +622,7 @@ int snprintf(char* buffer, size_t count, const char* format, ...) { va_list va; va_start(va, format); - int ret = _vsnprintf(buffer, count, format, va); + const int ret = _vsnprintf(_out_buffer, buffer, count, format, va); va_end(va); return ret; } @@ -630,6 +630,6 @@ int snprintf(char* buffer, size_t count, const char* format, ...) inline int vsnprintf(char* buffer, size_t count, const char* format, va_list va) { - return _vsnprintf(buffer, count, format, va); + return _vsnprintf(_out_buffer, buffer, count, format, va); } diff --git a/test/test_suite.cpp b/test/test_suite.cpp index ab8f7e5..8ee90a3 100644 --- a/test/test_suite.cpp +++ b/test/test_suite.cpp @@ -1016,6 +1016,14 @@ TEST_CASE("pointer", "[]" ) { REQUIRE(!strcmp(buffer, "0000000012345678")); } + test::sprintf(buffer, "%p-%p", (void*)0x12345678U, (void*)0x7EDCBA98U); + if (sizeof(void*) == 4U) { + REQUIRE(!strcmp(buffer, "12345678-7EDCBA98")); + } + else { + REQUIRE(!strcmp(buffer, "0000000012345678-000000007EDCBA98")); + } + if (sizeof(uintptr_t) == sizeof(uint64_t)) { test::sprintf(buffer, "%p", (void*)(uintptr_t)0xFFFFFFFFU); REQUIRE(!strcmp(buffer, "00000000FFFFFFFF")); @@ -1039,17 +1047,15 @@ TEST_CASE("buffer length", "[]" ) { char buffer[100]; int ret; - // formatted length, this should return '4', - // but this feature is not implemented, returning 0 ret = test::snprintf(nullptr, 10, "%s", "Test"); - REQUIRE(ret == -1); + REQUIRE(ret == 4); ret = test::snprintf(nullptr, 0, "%s", "Test"); - REQUIRE(ret == -1); + REQUIRE(ret == 4); buffer[0] = (char)0xA5; ret = test::snprintf(buffer, 0, "%s", "Test"); REQUIRE(buffer[0] == (char)0xA5); - REQUIRE(ret == 0); + REQUIRE(ret == 4); buffer[0] = 0xCC; test::snprintf(buffer, 1, "%s", "Test"); @@ -1074,13 +1080,13 @@ TEST_CASE("ret value", "[]" ) { ret = test::snprintf(buffer, 6, "0%s", "1234567"); REQUIRE(!strcmp(buffer, "01234")); - REQUIRE(ret == 6); // '567' are truncated + REQUIRE(ret == 8); // '567' are truncated ret = test::snprintf(buffer, 10, "hello, world"); - REQUIRE(ret == 10); + REQUIRE(ret == 12); ret = test::snprintf(buffer, 3, "%d", 10000); - REQUIRE(ret == 3); // '000' are truncated + REQUIRE(ret == 5); REQUIRE(strlen(buffer) == 2U); REQUIRE(buffer[0] == '1'); REQUIRE(buffer[1] == '0'); -- cgit v1.2.3 From 824a9b35f953ab263d08dd7659aaba4efa162b4f Mon Sep 17 00:00:00 2001 From: Marco Paland Date: Tue, 8 May 2018 13:01:10 +0200 Subject: fix(printf): use null output function for nullptr buffer Improving #11 --- printf.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/printf.c b/printf.c index d373781..edc0a4e 100644 --- a/printf.c +++ b/printf.c @@ -70,12 +70,19 @@ typedef void (*out_fct_type)(char character, char* buffer, size_t idx, size_t ma // internal buffer output static inline void _out_buffer(char character, char* buffer, size_t idx, size_t maxlen) { - if (!!buffer && (idx < maxlen)) { + if (idx < maxlen) { buffer[idx] = character; } } +// internal null output +static inline void _out_null(char character, char* buffer, size_t idx, size_t maxlen) +{ + (void)character; (void)buffer; (void)idx; (void)maxlen; +} + + // internal _putchar wrapper static inline void _out_char(char character, char* buffer, size_t idx, size_t maxlen) { @@ -363,6 +370,11 @@ static int _vsnprintf(out_fct_type out, char* buffer, const size_t maxlen, const unsigned int flags, width, precision, n; size_t idx = 0U; + if (!buffer) { + // use null output function + out = _out_null; + } + while (*format) { // format specifier? %[flags][width][.precision][length] -- cgit v1.2.3