functional!

helpers/flipbip_string.c

@@ -104,40 +104,40 @@ cont:
  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-void
-flipbip_strrev(unsigned char *str)
-{
-	int i;
-	int j;
-	unsigned char a;
-	unsigned len = strlen((const char *)str);
-	for (i = 0, j = len - 1; i < j; i++, j--)
-	{
-		a = str[i];
-		str[i] = str[j];
-		str[j] = a;
-	}
-}
-int
-flipbip_itoa(int num, unsigned char* str, int len, int base)
-{
-	int sum = num;
-	int i = 0;
-	int digit;
-	if (len == 0)
-		return -1;
-	do
-	{
-		digit = sum % base;
-		if (digit < 0xA)
-			str[i++] = '0' + digit;
-		else
-			str[i++] = 'A' + digit - 0xA;
-		sum /= base;
-	}while (sum && (i < (len - 1)));
-	if (i == (len - 1) && sum)
-		return -1;
-	str[i] = '\0';
-	flipbip_strrev(str);
-	return 0;
-}
+// void
+// flipbip_strrev(unsigned char *str)
+// {
+// 	int i;
+// 	int j;
+// 	unsigned char a;
+// 	unsigned len = strlen((const char *)str);
+// 	for (i = 0, j = len - 1; i < j; i++, j--)
+// 	{
+// 		a = str[i];
+// 		str[i] = str[j];
+// 		str[j] = a;
+// 	}
+// }
+// int
+// flipbip_itoa(int num, unsigned char* str, int len, int base)
+// {
+// 	int sum = num;
+// 	int i = 0;
+// 	int digit;
+// 	if (len == 0)
+// 		return -1;
+// 	do
+// 	{
+// 		digit = sum % base;
+// 		if (digit < 0xA)
+// 			str[i++] = '0' + digit;
+// 		else
+// 			str[i++] = 'A' + digit - 0xA;
+// 		sum /= base;
+// 	}while (sum && (i < (len - 1)));
+// 	if (i == (len - 1) && sum)
+// 		return -1;
+// 	str[i] = '\0';
+// 	flipbip_strrev(str);
+// 	return 0;
+// }

helpers/flipbip_string.h

@@ -1,4 +1,4 @@
 char * flipbip_strtok(char *s, const char *delim);
 char * flipbip_strtok_r(char *s, const char *delim, char **last);
-void flipbip_strrev(unsigned char *str);
-int flipbip_itoa(int num, unsigned char* str, int len, int base);
+// void flipbip_strrev(unsigned char *str);
+// int flipbip_itoa(int num, unsigned char* str, int len, int base);

helpers/printf.c

@@ -1,914 +1,914 @@
-// ///////////////////////////////////////////////////////////////////////////////
-// // \author (c) Marco Paland (info@paland.com)
-// //             2014-2019, PALANDesign Hannover, Germany
-// //
-// // \license The MIT License (MIT)
-// //
-// // Permission is hereby granted, free of charge, to any person obtaining a copy
-// // of this software and associated documentation files (the "Software"), to deal
-// // in the Software without restriction, including without limitation the rights
-// // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// // copies of the Software, and to permit persons to whom the Software is
-// // furnished to do so, subject to the following conditions:
-// //
-// // The above copyright notice and this permission notice shall be included in
-// // all copies or substantial portions of the Software.
-// //
-// // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// // THE SOFTWARE.
-// //
-// // \brief Tiny printf, sprintf and (v)snprintf implementation, optimized for speed on
-// //        embedded systems with a very limited resources. These routines are thread
-// //        safe and reentrant!
-// //        Use this instead of the bloated standard/newlib printf cause these use
-// //        malloc for printf (and may not be thread safe).
-// //
-// ///////////////////////////////////////////////////////////////////////////////
-
-// #include <stdbool.h>
-// #include <stdint.h>
-
-// #include "printf.h"
-
-
-// // define this globally (e.g. gcc -DPRINTF_INCLUDE_CONFIG_H ...) to include the
-// // printf_config.h header file
-// // default: undefined
-// #ifdef PRINTF_INCLUDE_CONFIG_H
-// #include "printf_config.h"
-// #endif
-
-
-// // 'ntoa' conversion buffer size, this must be big enough to hold one converted
-// // numeric number including padded zeros (dynamically created on stack)
-// // default: 32 byte
-// #ifndef PRINTF_NTOA_BUFFER_SIZE
-// #define PRINTF_NTOA_BUFFER_SIZE    32U
-// #endif
-
-// // 'ftoa' conversion buffer size, this must be big enough to hold one converted
-// // float number including padded zeros (dynamically created on stack)
-// // default: 32 byte
-// #ifndef PRINTF_FTOA_BUFFER_SIZE
-// #define PRINTF_FTOA_BUFFER_SIZE    32U
-// #endif
-
-// // support for the floating point type (%f)
-// // default: activated
-// #ifndef PRINTF_DISABLE_SUPPORT_FLOAT
-// #define PRINTF_SUPPORT_FLOAT
-// #endif
-
-// // support for exponential floating point notation (%e/%g)
-// // default: activated
-// #ifndef PRINTF_DISABLE_SUPPORT_EXPONENTIAL
-// #define PRINTF_SUPPORT_EXPONENTIAL
-// #endif
-
-// // define the default floating point precision
-// // default: 6 digits
-// #ifndef PRINTF_DEFAULT_FLOAT_PRECISION
-// #define PRINTF_DEFAULT_FLOAT_PRECISION  6U
-// #endif
-
-// // define the largest float suitable to print with %f
-// // default: 1e9
-// #ifndef PRINTF_MAX_FLOAT
-// #define PRINTF_MAX_FLOAT  1e9
-// #endif
-
-// // support for the long long types (%llu or %p)
-// // default: activated
-// #ifndef PRINTF_DISABLE_SUPPORT_LONG_LONG
-// #define PRINTF_SUPPORT_LONG_LONG
-// #endif
-
-// // support for the ptrdiff_t type (%t)
-// // ptrdiff_t is normally defined in <stddef.h> as long or long long type
-// // default: activated
-// #ifndef PRINTF_DISABLE_SUPPORT_PTRDIFF_T
-// #define PRINTF_SUPPORT_PTRDIFF_T
-// #endif
-
-// ///////////////////////////////////////////////////////////////////////////////
-
-// // 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_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)
-
-
-// // import float.h for DBL_MAX
-// #if defined(PRINTF_SUPPORT_FLOAT)
-// #include <float.h>
-// #endif
-
-
-// // output function type
-// typedef void (*out_fct_type)(char character, void* buffer, size_t idx, size_t maxlen);
-
-
-// // wrapper (used as buffer) for output function type
-// typedef struct {
-//   void  (*fct)(char character, void* arg);
-//   void* arg;
-// } out_fct_wrap_type;
-
-
-// // internal buffer output
-// static inline void _out_buffer(char character, void* buffer, size_t idx, size_t maxlen)
-// {
-//   if (idx < maxlen) {
-//     ((char*)buffer)[idx] = character;
-//   }
-// }
-
-
-// // internal null output
-// static inline void _out_null(char character, void* 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, void* buffer, size_t idx, size_t maxlen)
-// {
-//   (void)buffer; (void)idx; (void)maxlen;
-//   if (character) {
-//     _putchar(character);
-//   }
-// }
-
-
-// // internal output function wrapper
-// static inline void _out_fct(char character, void* buffer, size_t idx, size_t maxlen)
-// {
-//   (void)idx; (void)maxlen;
-//   if (character) {
-//     // buffer is the output fct pointer
-//     ((out_fct_wrap_type*)buffer)->fct(character, ((out_fct_wrap_type*)buffer)->arg);
-//   }
-// }
-
-
-// // internal secure strlen
-// // \return The length of the string (excluding the terminating 0) limited by 'maxsize'
-// static inline unsigned int _strnlen_s(const char* str, size_t maxsize)
-// {
-//   const char* s;
-//   for (s = str; *s && maxsize--; ++s);
-//   return (unsigned int)(s - str);
-// }
-
-
-// // internal test if char is a digit (0-9)
-// // \return true if char is a digit
-// static inline bool _is_digit(char ch)
-// {
-//   return (ch >= '0') && (ch <= '9');
-// }
-
-
-// // internal ASCII string to unsigned int conversion
-// static unsigned int _atoi(const char** str)
-// {
-//   unsigned int i = 0U;
-//   while (_is_digit(**str)) {
-//     i = i * 10U + (unsigned int)(*((*str)++) - '0');
-//   }
-//   return i;
-// }
-
-
-// // output the specified string in reverse, taking care of any zero-padding
-// static size_t _out_rev(out_fct_type out, char* buffer, size_t idx, size_t maxlen, const char* buf, size_t len, unsigned int width, unsigned int flags)
-// {
-//   const size_t start_idx = idx;
-
-//   // pad spaces up to given width
-//   if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) {
-//     for (size_t i = len; i < width; i++) {
-//       out(' ', buffer, idx++, maxlen);
-//     }
-//   }
-
-//   // reverse string
-//   while (len) {
-//     out(buf[--len], buffer, idx++, maxlen);
-//   }
-
-//   // append pad spaces up to given width
-//   if (flags & FLAGS_LEFT) {
-//     while (idx - start_idx < width) {
-//       out(' ', buffer, idx++, maxlen);
-//     }
-//   }
-
-//   return idx;
-// }
-
-
-// // internal itoa format
-// 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)
-// {
-//   // pad leading zeros
-//   if (!(flags & FLAGS_LEFT)) {
-//     if (width && (flags & FLAGS_ZEROPAD) && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) {
-//       width--;
-//     }
-//     while ((len < prec) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
-//       buf[len++] = '0';
-//     }
-//     while ((flags & FLAGS_ZEROPAD) && (len < width) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
-//       buf[len++] = '0';
-//     }
-//   }
-
-//   // handle hash
-//   if (flags & FLAGS_HASH) {
-//     if (!(flags & FLAGS_PRECISION) && len && ((len == prec) || (len == width))) {
-//       len--;
-//       if (len && (base == 16U)) {
-//         len--;
-//       }
-//     }
-//     if ((base == 16U) && !(flags & FLAGS_UPPERCASE) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
-//       buf[len++] = 'x';
-//     }
-//     else if ((base == 16U) && (flags & FLAGS_UPPERCASE) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
-//       buf[len++] = 'X';
-//     }
-//     else if ((base == 2U) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
-//       buf[len++] = 'b';
-//     }
-//     if (len < PRINTF_NTOA_BUFFER_SIZE) {
-//       buf[len++] = '0';
-//     }
-//   }
-
-//   if (len < PRINTF_NTOA_BUFFER_SIZE) {
-//     if (negative) {
-//       buf[len++] = '-';
-//     }
-//     else if (flags & FLAGS_PLUS) {
-//       buf[len++] = '+';  // ignore the space if the '+' exists
-//     }
-//     else if (flags & FLAGS_SPACE) {
-//       buf[len++] = ' ';
-//     }
-//   }
-
-//   return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags);
-// }
-
-
-// // internal itoa for 'long' type
-// 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;
-
-//   // no hash for 0 values
-//   if (!value) {
-//     flags &= ~FLAGS_HASH;
-//   }
-
-//   // write if precision != 0 and value is != 0
-//   if (!(flags & FLAGS_PRECISION) || value) {
-//     do {
-//       const char digit = (char)(value % base);
-//       buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10;
-//       value /= base;
-//     } while (value && (len < PRINTF_NTOA_BUFFER_SIZE));
-//   }
-
-//   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_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];
-//   size_t len = 0U;
-
-//   // no hash for 0 values
-//   if (!value) {
-//     flags &= ~FLAGS_HASH;
-//   }
-
-//   // write if precision != 0 and value is != 0
-//   if (!(flags & FLAGS_PRECISION) || value) {
-//     do {
-//       const char digit = (char)(value % base);
-//       buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10;
-//       value /= base;
-//     } while (value && (len < PRINTF_NTOA_BUFFER_SIZE));
-//   }
-
-//   return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags);
-// }
-// #endif  // PRINTF_SUPPORT_LONG_LONG
-
-
-// #if defined(PRINTF_SUPPORT_FLOAT)
-
-// #if defined(PRINTF_SUPPORT_EXPONENTIAL)
-// // forward declaration so that _ftoa can switch to exp notation for values > PRINTF_MAX_FLOAT
-// static size_t _etoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags);
-// #endif
-
-
-// // internal ftoa for fixed decimal floating point
-// 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;
-//   double diff = 0.0;
-
-//   // powers of 10
-//   static const double pow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
-
-//   // test for special values
-//   if (value != value)
-//     return _out_rev(out, buffer, idx, maxlen, "nan", 3, width, flags);
-//   if (value < -DBL_MAX)
-//     return _out_rev(out, buffer, idx, maxlen, "fni-", 4, width, flags);
-//   if (value > DBL_MAX)
-//     return _out_rev(out, buffer, idx, maxlen, (flags & FLAGS_PLUS) ? "fni+" : "fni", (flags & FLAGS_PLUS) ? 4U : 3U, width, flags);
-
-//   // test for very large values
-//   // standard printf behavior is to print EVERY whole number digit -- which could be 100s of characters overflowing your buffers == bad
-//   if ((value > PRINTF_MAX_FLOAT) || (value < -PRINTF_MAX_FLOAT)) {
-// #if defined(PRINTF_SUPPORT_EXPONENTIAL)
-//     return _etoa(out, buffer, idx, maxlen, value, prec, width, flags);
-// #else
-//     return 0U;
-// #endif
-//   }
-
-//   // test for negative
-//   bool negative = false;
-//   if (value < 0) {
-//     negative = true;
-//     value = 0 - value;
-//   }
-
-//   // set default precision, if not set explicitly
-//   if (!(flags & FLAGS_PRECISION)) {
-//     prec = PRINTF_DEFAULT_FLOAT_PRECISION;
-//   }
-//   // limit precision to 9, cause a prec >= 10 can lead to overflow errors
-//   while ((len < PRINTF_FTOA_BUFFER_SIZE) && (prec > 9U)) {
-//     buf[len++] = '0';
-//     prec--;
-//   }
-
-//   int whole = (int)value;
-//   double tmp = (value - whole) * pow10[prec];
-//   unsigned long frac = (unsigned long)tmp;
-//   diff = tmp - frac;
-
-//   if (diff > 0.5) {
-//     ++frac;
-//     // handle rollover, e.g. case 0.99 with prec 1 is 1.0
-//     if (frac >= pow10[prec]) {
-//       frac = 0;
-//       ++whole;
-//     }
-//   }
-//   else if (diff < 0.5) {
-//   }
-//   else if ((frac == 0U) || (frac & 1U)) {
-//     // if halfway, round up if odd OR if last digit is 0
-//     ++frac;
-//   }
-
-//   if (prec == 0U) {
-//     diff = value - (double)whole;
-//     if ((!(diff < 0.5) || (diff > 0.5)) && (whole & 1)) {
-//       // exactly 0.5 and ODD, then round up
-//       // 1.5 -> 2, but 2.5 -> 2
-//       ++whole;
-//     }
-//   }
-//   else {
-//     unsigned int count = prec;
-//     // now do fractional part, as an unsigned number
-//     while (len < PRINTF_FTOA_BUFFER_SIZE) {
-//       --count;
-//       buf[len++] = (char)(48U + (frac % 10U));
-//       if (!(frac /= 10U)) {
-//         break;
-//       }
-//     }
-//     // add extra 0s
-//     while ((len < PRINTF_FTOA_BUFFER_SIZE) && (count-- > 0U)) {
-//       buf[len++] = '0';
-//     }
-//     if (len < PRINTF_FTOA_BUFFER_SIZE) {
-//       // add decimal
-//       buf[len++] = '.';
-//     }
-//   }
-
-//   // do whole part, number is reversed
-//   while (len < PRINTF_FTOA_BUFFER_SIZE) {
-//     buf[len++] = (char)(48 + (whole % 10));
-//     if (!(whole /= 10)) {
-//       break;
-//     }
-//   }
-
-//   // pad leading zeros
-//   if (!(flags & FLAGS_LEFT) && (flags & FLAGS_ZEROPAD)) {
-//     if (width && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) {
-//       width--;
-//     }
-//     while ((len < width) && (len < PRINTF_FTOA_BUFFER_SIZE)) {
-//       buf[len++] = '0';
-//     }
-//   }
-
-//   if (len < PRINTF_FTOA_BUFFER_SIZE) {
-//     if (negative) {
-//       buf[len++] = '-';
-//     }
-//     else if (flags & FLAGS_PLUS) {
-//       buf[len++] = '+';  // ignore the space if the '+' exists
-//     }
-//     else if (flags & FLAGS_SPACE) {
-//       buf[len++] = ' ';
-//     }
-//   }
-
-//   return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags);
-// }
-
-
-// #if defined(PRINTF_SUPPORT_EXPONENTIAL)
-// // internal ftoa variant for exponential floating-point type, contributed by Martijn Jasperse <m.jasperse@gmail.com>
-// static size_t _etoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags)
-// {
-//   // check for NaN and special values
-//   if ((value != value) || (value > DBL_MAX) || (value < -DBL_MAX)) {
-//     return _ftoa(out, buffer, idx, maxlen, value, prec, width, flags);
-//   }
-
-//   // determine the sign
-//   const bool negative = value < 0;
-//   if (negative) {
-//     value = -value;
-//   }
-
-//   // default precision
-//   if (!(flags & FLAGS_PRECISION)) {
-//     prec = PRINTF_DEFAULT_FLOAT_PRECISION;
-//   }
-
-//   // determine the decimal exponent
-//   // based on the algorithm by David Gay (https://www.ampl.com/netlib/fp/dtoa.c)
-//   union {
-//     uint64_t U;
-//     double   F;
-//   } conv;
-
-//   conv.F = value;
-//   int exp2 = (int)((conv.U >> 52U) & 0x07FFU) - 1023;           // effectively log2
-//   conv.U = (conv.U & ((1ULL << 52U) - 1U)) | (1023ULL << 52U);  // drop the exponent so conv.F is now in [1,2)
-//   // now approximate log10 from the log2 integer part and an expansion of ln around 1.5
-//   int expval = (int)(0.1760912590558 + exp2 * 0.301029995663981 + (conv.F - 1.5) * 0.289529654602168);
-//   // now we want to compute 10^expval but we want to be sure it won't overflow
-//   exp2 = (int)(expval * 3.321928094887362 + 0.5);
-//   const double z  = expval * 2.302585092994046 - exp2 * 0.6931471805599453;
-//   const double z2 = z * z;
-//   conv.U = (uint64_t)(exp2 + 1023) << 52U;
-//   // compute exp(z) using continued fractions, see https://en.wikipedia.org/wiki/Exponential_function#Continued_fractions_for_ex
-//   conv.F *= 1 + 2 * z / (2 - z + (z2 / (6 + (z2 / (10 + z2 / 14)))));
-//   // correct for rounding errors
-//   if (value < conv.F) {
-//     expval--;
-//     conv.F /= 10;
-//   }
-
-//   // the exponent format is "%+03d" and largest value is "307", so set aside 4-5 characters
-//   unsigned int minwidth = ((expval < 100) && (expval > -100)) ? 4U : 5U;
-
-//   // in "%g" mode, "prec" is the number of *significant figures* not decimals
-//   if (flags & FLAGS_ADAPT_EXP) {
-//     // do we want to fall-back to "%f" mode?
-//     if ((value >= 1e-4) && (value < 1e6)) {
-//       if ((int)prec > expval) {
-//         prec = (unsigned)((int)prec - expval - 1);
-//       }
-//       else {
-//         prec = 0;
-//       }
-//       flags |= FLAGS_PRECISION;   // make sure _ftoa respects precision
-//       // no characters in exponent
-//       minwidth = 0U;
-//       expval   = 0;
-//     }
-//     else {
-//       // we use one sigfig for the whole part
-//       if ((prec > 0) && (flags & FLAGS_PRECISION)) {
-//         --prec;
-//       }
-//     }
-//   }
-
-//   // will everything fit?
-//   unsigned int fwidth = width;
-//   if (width > minwidth) {
-//     // we didn't fall-back so subtract the characters required for the exponent
-//     fwidth -= minwidth;
-//   } else {
-//     // not enough characters, so go back to default sizing
-//     fwidth = 0U;
-//   }
-//   if ((flags & FLAGS_LEFT) && minwidth) {
-//     // if we're padding on the right, DON'T pad the floating part
-//     fwidth = 0U;
-//   }
-
-//   // rescale the float value
-//   if (expval) {
-//     value /= conv.F;
-//   }
-
-//   // output the floating part
-//   const size_t start_idx = idx;
-//   idx = _ftoa(out, buffer, idx, maxlen, negative ? -value : value, prec, fwidth, flags & ~FLAGS_ADAPT_EXP);
-
-//   // output the exponent part
-//   if (minwidth) {
-//     // output the exponential symbol
-//     out((flags & FLAGS_UPPERCASE) ? 'E' : 'e', buffer, idx++, maxlen);
-//     // output the exponent value
-//     idx = _ntoa_long(out, buffer, idx, maxlen, (expval < 0) ? -expval : expval, expval < 0, 10, 0, minwidth-1, FLAGS_ZEROPAD | FLAGS_PLUS);
-//     // might need to right-pad spaces
-//     if (flags & FLAGS_LEFT) {
-//       while (idx - start_idx < width) out(' ', buffer, idx++, maxlen);
-//     }
-//   }
-//   return idx;
-// }
-// #endif  // PRINTF_SUPPORT_EXPONENTIAL
-// #endif  // PRINTF_SUPPORT_FLOAT
-
-
-// // internal vsnprintf
-// 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;
-
-//   if (!buffer) {
-//     // use null output function
-//     out = _out_null;
-//   }
-
-//   while (*format)
-//   {
-//     // format specifier?  %[flags][width][.precision][length]
-//     if (*format != '%') {
-//       // no
-//       out(*format, buffer, idx++, maxlen);
-//       format++;
-//       continue;
-//     }
-//     else {
-//       // yes, evaluate it
-//       format++;
-//     }
-
-//     // evaluate flags
-//     flags = 0U;
-//     do {
-//       switch (*format) {
-//         case '0': flags |= FLAGS_ZEROPAD; format++; n = 1U; break;
-//         case '-': flags |= FLAGS_LEFT;    format++; n = 1U; break;
-//         case '+': flags |= FLAGS_PLUS;    format++; n = 1U; break;
-//         case ' ': flags |= FLAGS_SPACE;   format++; n = 1U; break;
-//         case '#': flags |= FLAGS_HASH;    format++; n = 1U; break;
-//         default :                                   n = 0U; break;
-//       }
-//     } while (n);
-
-//     // evaluate width field
-//     width = 0U;
-//     if (_is_digit(*format)) {
-//       width = _atoi(&format);
-//     }
-//     else if (*format == '*') {
-//       const int w = va_arg(va, int);
-//       if (w < 0) {
-//         flags |= FLAGS_LEFT;    // reverse padding
-//         width = (unsigned int)-w;
-//       }
-//       else {
-//         width = (unsigned int)w;
-//       }
-//       format++;
-//     }
-
-//     // evaluate precision field
-//     precision = 0U;
-//     if (*format == '.') {
-//       flags |= FLAGS_PRECISION;
-//       format++;
-//       if (_is_digit(*format)) {
-//         precision = _atoi(&format);
-//       }
-//       else if (*format == '*') {
-//         const int prec = (int)va_arg(va, int);
-//         precision = prec > 0 ? (unsigned int)prec : 0U;
-//         format++;
-//       }
-//     }
-
-//     // evaluate length field
-//     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
-//     switch (*format) {
-//       case 'd' :
-//       case 'i' :
-//       case 'u' :
-//       case 'x' :
-//       case 'X' :
-//       case 'o' :
-//       case 'b' : {
-//         // set the base
-//         unsigned int base;
-//         if (*format == 'x' || *format == 'X') {
-//           base = 16U;
-//         }
-//         else if (*format == 'o') {
-//           base =  8U;
-//         }
-//         else if (*format == 'b') {
-//           base =  2U;
-//         }
-//         else {
-//           base = 10U;
-//           flags &= ~FLAGS_HASH;   // no hash for dec format
-//         }
-//         // 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);
-//         }
-
-//         // 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_LONG_LONG) {
-// #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
-//           }
-//           else if (flags & FLAGS_LONG) {
-//             const long value = va_arg(va, long);
-//             idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned long)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags);
-//           }
-//           else {
-//             const int value = (flags & FLAGS_CHAR) ? (char)va_arg(va, int) : (flags & FLAGS_SHORT) ? (short int)va_arg(va, 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_SUPPORT_LONG_LONG)
-//             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(out, buffer, idx, maxlen, 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);
-//             idx = _ntoa_long(out, buffer, idx, maxlen, value, false, base, precision, width, flags);
-//           }
-//         }
-//         format++;
-//         break;
-//       }
-// #if defined(PRINTF_SUPPORT_FLOAT)
-//       case 'f' :
-//       case 'F' :
-//         if (*format == 'F') flags |= FLAGS_UPPERCASE;
-//         idx = _ftoa(out, buffer, idx, maxlen, va_arg(va, double), precision, width, flags);
-//         format++;
-//         break;
-// #if defined(PRINTF_SUPPORT_EXPONENTIAL)
-//       case 'e':
-//       case 'E':
-//       case 'g':
-//       case 'G':
-//         if ((*format == 'g')||(*format == 'G')) flags |= FLAGS_ADAPT_EXP;
-//         if ((*format == 'E')||(*format == 'G')) flags |= FLAGS_UPPERCASE;
-//         idx = _etoa(out, buffer, idx, maxlen, va_arg(va, double), precision, width, flags);
-//         format++;
-//         break;
-// #endif  // PRINTF_SUPPORT_EXPONENTIAL
-// #endif  // PRINTF_SUPPORT_FLOAT
-//       case 'c' : {
-//         unsigned int l = 1U;
-//         // pre padding
-//         if (!(flags & FLAGS_LEFT)) {
-//           while (l++ < width) {
-//             out(' ', buffer, idx++, maxlen);
-//           }
-//         }
-//         // char output
-//         out((char)va_arg(va, int), buffer, idx++, maxlen);
-//         // post padding
-//         if (flags & FLAGS_LEFT) {
-//           while (l++ < width) {
-//             out(' ', buffer, idx++, maxlen);
-//           }
-//         }
-//         format++;
-//         break;
-//       }
-
-//       case 's' : {
-//         const char* p = va_arg(va, char*);
-//         unsigned int l = _strnlen_s(p, precision ? precision : (size_t)-1);
-//         // pre padding
-//         if (flags & FLAGS_PRECISION) {
-//           l = (l < precision ? l : precision);
-//         }
-//         if (!(flags & FLAGS_LEFT)) {
-//           while (l++ < width) {
-//             out(' ', buffer, idx++, maxlen);
-//           }
-//         }
-//         // string output
-//         while ((*p != 0) && (!(flags & FLAGS_PRECISION) || precision--)) {
-//           out(*(p++), buffer, idx++, maxlen);
-//         }
-//         // post padding
-//         if (flags & FLAGS_LEFT) {
-//           while (l++ < width) {
-//             out(' ', buffer, idx++, maxlen);
-//           }
-//         }
-//         format++;
-//         break;
-//       }
-
-//       case 'p' : {
-//         width = sizeof(void*) * 2U;
-//         flags |= FLAGS_ZEROPAD | FLAGS_UPPERCASE;
-// #if defined(PRINTF_SUPPORT_LONG_LONG)
-//         const bool is_ll = sizeof(uintptr_t) == sizeof(long long);
-//         if (is_ll) {
-//           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_SUPPORT_LONG_LONG)
-//         }
-// #endif
-//         format++;
-//         break;
-//       }
-
-//       case '%' :
-//         out('%', buffer, idx++, maxlen);
-//         format++;
-//         break;
-
-//       default :
-//         out(*format, buffer, idx++, maxlen);
-//         format++;
-//         break;
-//     }
-//   }
-
-//   // termination
-//   out((char)0, buffer, idx < maxlen ? idx : maxlen - 1U, maxlen);
-
-//   // return written chars without terminating \0
-//   return (int)idx;
-// }
-
-
-// ///////////////////////////////////////////////////////////////////////////////
-
-// int printf_(const char* format, ...)
-// {
-//   va_list va;
-//   va_start(va, format);
-//   char buffer[1];
-//   const int ret = _vsnprintf(_out_char, buffer, (size_t)-1, format, va);
-//   va_end(va);
-//   return ret;
-// }
-
-
-// int sprintf_(char* buffer, const char* format, ...)
-// {
-//   va_list va;
-//   va_start(va, format);
-//   const int ret = _vsnprintf(_out_buffer, buffer, (size_t)-1, format, va);
-//   va_end(va);
-//   return ret;
-// }
-
-
-// int snprintf_(char* buffer, size_t count, const char* format, ...)
-// {
-//   va_list va;
-//   va_start(va, format);
-//   const int ret = _vsnprintf(_out_buffer, buffer, count, format, va);
-//   va_end(va);
-//   return ret;
-// }
-
-
-// int vprintf_(const char* format, va_list va)
-// {
-//   char buffer[1];
-//   return _vsnprintf(_out_char, buffer, (size_t)-1, format, va);
-// }
-
-
-// int vsnprintf_(char* buffer, size_t count, const char* format, va_list va)
-// {
-//   return _vsnprintf(_out_buffer, buffer, count, format, va);
-// }
-
-
-// int fctprintf(void (*out)(char character, void* arg), void* arg, const char* format, ...)
-// {
-//   va_list va;
-//   va_start(va, format);
-//   const out_fct_wrap_type out_fct_wrap = { out, arg };
-//   const int ret = _vsnprintf(_out_fct, (char*)(uintptr_t)&out_fct_wrap, (size_t)-1, format, va);
-//   va_end(va);
-//   return ret;
-// }
+///////////////////////////////////////////////////////////////////////////////
+// \author (c) Marco Paland (info@paland.com)
+//             2014-2019, PALANDesign Hannover, Germany
+//
+// \license The MIT License (MIT)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// \brief Tiny printf, sprintf and (v)snprintf implementation, optimized for speed on
+//        embedded systems with a very limited resources. These routines are thread
+//        safe and reentrant!
+//        Use this instead of the bloated standard/newlib printf cause these use
+//        malloc for printf (and may not be thread safe).
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "printf.h"
+
+
+// define this globally (e.g. gcc -DPRINTF_INCLUDE_CONFIG_H ...) to include the
+// printf_config.h header file
+// default: undefined
+#ifdef PRINTF_INCLUDE_CONFIG_H
+#include "printf_config.h"
+#endif
+
+
+// 'ntoa' conversion buffer size, this must be big enough to hold one converted
+// numeric number including padded zeros (dynamically created on stack)
+// default: 32 byte
+#ifndef PRINTF_NTOA_BUFFER_SIZE
+#define PRINTF_NTOA_BUFFER_SIZE    32U
+#endif
+
+// 'ftoa' conversion buffer size, this must be big enough to hold one converted
+// float number including padded zeros (dynamically created on stack)
+// default: 32 byte
+#ifndef PRINTF_FTOA_BUFFER_SIZE
+#define PRINTF_FTOA_BUFFER_SIZE    32U
+#endif
+
+// support for the floating point type (%f)
+// default: activated
+#ifndef PRINTF_DISABLE_SUPPORT_FLOAT
+#define PRINTF_SUPPORT_FLOAT
+#endif
+
+// support for exponential floating point notation (%e/%g)
+// default: activated
+#ifndef PRINTF_DISABLE_SUPPORT_EXPONENTIAL
+#define PRINTF_SUPPORT_EXPONENTIAL
+#endif
+
+// define the default floating point precision
+// default: 6 digits
+#ifndef PRINTF_DEFAULT_FLOAT_PRECISION
+#define PRINTF_DEFAULT_FLOAT_PRECISION  6U
+#endif
+
+// define the largest float suitable to print with %f
+// default: 1e9
+#ifndef PRINTF_MAX_FLOAT
+#define PRINTF_MAX_FLOAT  1e9
+#endif
+
+// support for the long long types (%llu or %p)
+// default: activated
+#ifndef PRINTF_DISABLE_SUPPORT_LONG_LONG
+#define PRINTF_SUPPORT_LONG_LONG
+#endif
+
+// support for the ptrdiff_t type (%t)
+// ptrdiff_t is normally defined in <stddef.h> as long or long long type
+// default: activated
+#ifndef PRINTF_DISABLE_SUPPORT_PTRDIFF_T
+#define PRINTF_SUPPORT_PTRDIFF_T
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+// 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_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)
+
+
+// import float.h for DBL_MAX
+#if defined(PRINTF_SUPPORT_FLOAT)
+#include <float.h>
+#endif
+
+
+// output function type
+typedef void (*out_fct_type)(char character, void* buffer, size_t idx, size_t maxlen);
+
+
+// wrapper (used as buffer) for output function type
+typedef struct {
+  void  (*fct)(char character, void* arg);
+  void* arg;
+} out_fct_wrap_type;
+
+
+// internal buffer output
+static inline void _out_buffer(char character, void* buffer, size_t idx, size_t maxlen)
+{
+  if (idx < maxlen) {
+    ((char*)buffer)[idx] = character;
+  }
+}
+
+
+// internal null output
+static inline void _out_null(char character, void* 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, void* buffer, size_t idx, size_t maxlen)
+{
+  (void)buffer; (void)idx; (void)maxlen;
+  if (character) {
+    _putchar(character);
+  }
+}
+
+
+// internal output function wrapper
+static inline void _out_fct(char character, void* buffer, size_t idx, size_t maxlen)
+{
+  (void)idx; (void)maxlen;
+  if (character) {
+    // buffer is the output fct pointer
+    ((out_fct_wrap_type*)buffer)->fct(character, ((out_fct_wrap_type*)buffer)->arg);
+  }
+}
+
+
+// internal secure strlen
+// \return The length of the string (excluding the terminating 0) limited by 'maxsize'
+static inline unsigned int _strnlen_s(const char* str, size_t maxsize)
+{
+  const char* s;
+  for (s = str; *s && maxsize--; ++s);
+  return (unsigned int)(s - str);
+}
+
+
+// internal test if char is a digit (0-9)
+// \return true if char is a digit
+static inline bool _is_digit(char ch)
+{
+  return (ch >= '0') && (ch <= '9');
+}
+
+
+// internal ASCII string to unsigned int conversion
+static unsigned int _atoi(const char** str)
+{
+  unsigned int i = 0U;
+  while (_is_digit(**str)) {
+    i = i * 10U + (unsigned int)(*((*str)++) - '0');
+  }
+  return i;
+}
+
+
+// output the specified string in reverse, taking care of any zero-padding
+static size_t _out_rev(out_fct_type out, char* buffer, size_t idx, size_t maxlen, const char* buf, size_t len, unsigned int width, unsigned int flags)
+{
+  const size_t start_idx = idx;
+
+  // pad spaces up to given width
+  if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) {
+    for (size_t i = len; i < width; i++) {
+      out(' ', buffer, idx++, maxlen);
+    }
+  }
+
+  // reverse string
+  while (len) {
+    out(buf[--len], buffer, idx++, maxlen);
+  }
+
+  // append pad spaces up to given width
+  if (flags & FLAGS_LEFT) {
+    while (idx - start_idx < width) {
+      out(' ', buffer, idx++, maxlen);
+    }
+  }
+
+  return idx;
+}
+
+
+// internal itoa format
+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)
+{
+  // pad leading zeros
+  if (!(flags & FLAGS_LEFT)) {
+    if (width && (flags & FLAGS_ZEROPAD) && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) {
+      width--;
+    }
+    while ((len < prec) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+      buf[len++] = '0';
+    }
+    while ((flags & FLAGS_ZEROPAD) && (len < width) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+      buf[len++] = '0';
+    }
+  }
+
+  // handle hash
+  if (flags & FLAGS_HASH) {
+    if (!(flags & FLAGS_PRECISION) && len && ((len == prec) || (len == width))) {
+      len--;
+      if (len && (base == 16U)) {
+        len--;
+      }
+    }
+    if ((base == 16U) && !(flags & FLAGS_UPPERCASE) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+      buf[len++] = 'x';
+    }
+    else if ((base == 16U) && (flags & FLAGS_UPPERCASE) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+      buf[len++] = 'X';
+    }
+    else if ((base == 2U) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+      buf[len++] = 'b';
+    }
+    if (len < PRINTF_NTOA_BUFFER_SIZE) {
+      buf[len++] = '0';
+    }
+  }
+
+  if (len < PRINTF_NTOA_BUFFER_SIZE) {
+    if (negative) {
+      buf[len++] = '-';
+    }
+    else if (flags & FLAGS_PLUS) {
+      buf[len++] = '+';  // ignore the space if the '+' exists
+    }
+    else if (flags & FLAGS_SPACE) {
+      buf[len++] = ' ';
+    }
+  }
+
+  return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags);
+}
+
+
+// internal itoa for 'long' type
+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;
+
+  // no hash for 0 values
+  if (!value) {
+    flags &= ~FLAGS_HASH;
+  }
+
+  // write if precision != 0 and value is != 0
+  if (!(flags & FLAGS_PRECISION) || value) {
+    do {
+      const char digit = (char)(value % base);
+      buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10;
+      value /= base;
+    } while (value && (len < PRINTF_NTOA_BUFFER_SIZE));
+  }
+
+  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_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];
+  size_t len = 0U;
+
+  // no hash for 0 values
+  if (!value) {
+    flags &= ~FLAGS_HASH;
+  }
+
+  // write if precision != 0 and value is != 0
+  if (!(flags & FLAGS_PRECISION) || value) {
+    do {
+      const char digit = (char)(value % base);
+      buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10;
+      value /= base;
+    } while (value && (len < PRINTF_NTOA_BUFFER_SIZE));
+  }
+
+  return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags);
+}
+#endif  // PRINTF_SUPPORT_LONG_LONG
+
+
+#if defined(PRINTF_SUPPORT_FLOAT)
+
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+// forward declaration so that _ftoa can switch to exp notation for values > PRINTF_MAX_FLOAT
+static size_t _etoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags);
+#endif
+
+
+// internal ftoa for fixed decimal floating point
+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;
+  double diff = 0.0;
+
+  // powers of 10
+  static const double pow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
+
+  // test for special values
+  if (value != value)
+    return _out_rev(out, buffer, idx, maxlen, "nan", 3, width, flags);
+  if (value < -DBL_MAX)
+    return _out_rev(out, buffer, idx, maxlen, "fni-", 4, width, flags);
+  if (value > DBL_MAX)
+    return _out_rev(out, buffer, idx, maxlen, (flags & FLAGS_PLUS) ? "fni+" : "fni", (flags & FLAGS_PLUS) ? 4U : 3U, width, flags);
+
+  // test for very large values
+  // standard printf behavior is to print EVERY whole number digit -- which could be 100s of characters overflowing your buffers == bad
+  if ((value > PRINTF_MAX_FLOAT) || (value < -PRINTF_MAX_FLOAT)) {
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+    return _etoa(out, buffer, idx, maxlen, value, prec, width, flags);
+#else
+    return 0U;
+#endif
+  }
+
+  // test for negative
+  bool negative = false;
+  if (value < 0) {
+    negative = true;
+    value = 0 - value;
+  }
+
+  // set default precision, if not set explicitly
+  if (!(flags & FLAGS_PRECISION)) {
+    prec = PRINTF_DEFAULT_FLOAT_PRECISION;
+  }
+  // limit precision to 9, cause a prec >= 10 can lead to overflow errors
+  while ((len < PRINTF_FTOA_BUFFER_SIZE) && (prec > 9U)) {
+    buf[len++] = '0';
+    prec--;
+  }
+
+  int whole = (int)value;
+  double tmp = (value - whole) * pow10[prec];
+  unsigned long frac = (unsigned long)tmp;
+  diff = tmp - frac;
+
+  if (diff > 0.5) {
+    ++frac;
+    // handle rollover, e.g. case 0.99 with prec 1 is 1.0
+    if (frac >= pow10[prec]) {
+      frac = 0;
+      ++whole;
+    }
+  }
+  else if (diff < 0.5) {
+  }
+  else if ((frac == 0U) || (frac & 1U)) {
+    // if halfway, round up if odd OR if last digit is 0
+    ++frac;
+  }
+
+  if (prec == 0U) {
+    diff = value - (double)whole;
+    if ((!(diff < 0.5) || (diff > 0.5)) && (whole & 1)) {
+      // exactly 0.5 and ODD, then round up
+      // 1.5 -> 2, but 2.5 -> 2
+      ++whole;
+    }
+  }
+  else {
+    unsigned int count = prec;
+    // now do fractional part, as an unsigned number
+    while (len < PRINTF_FTOA_BUFFER_SIZE) {
+      --count;
+      buf[len++] = (char)(48U + (frac % 10U));
+      if (!(frac /= 10U)) {
+        break;
+      }
+    }
+    // add extra 0s
+    while ((len < PRINTF_FTOA_BUFFER_SIZE) && (count-- > 0U)) {
+      buf[len++] = '0';
+    }
+    if (len < PRINTF_FTOA_BUFFER_SIZE) {
+      // add decimal
+      buf[len++] = '.';
+    }
+  }
+
+  // do whole part, number is reversed
+  while (len < PRINTF_FTOA_BUFFER_SIZE) {
+    buf[len++] = (char)(48 + (whole % 10));
+    if (!(whole /= 10)) {
+      break;
+    }
+  }
+
+  // pad leading zeros
+  if (!(flags & FLAGS_LEFT) && (flags & FLAGS_ZEROPAD)) {
+    if (width && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) {
+      width--;
+    }
+    while ((len < width) && (len < PRINTF_FTOA_BUFFER_SIZE)) {
+      buf[len++] = '0';
+    }
+  }
+
+  if (len < PRINTF_FTOA_BUFFER_SIZE) {
+    if (negative) {
+      buf[len++] = '-';
+    }
+    else if (flags & FLAGS_PLUS) {
+      buf[len++] = '+';  // ignore the space if the '+' exists
+    }
+    else if (flags & FLAGS_SPACE) {
+      buf[len++] = ' ';
+    }
+  }
+
+  return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags);
+}
+
+
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+// internal ftoa variant for exponential floating-point type, contributed by Martijn Jasperse <m.jasperse@gmail.com>
+static size_t _etoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width, unsigned int flags)
+{
+  // check for NaN and special values
+  if ((value != value) || (value > DBL_MAX) || (value < -DBL_MAX)) {
+    return _ftoa(out, buffer, idx, maxlen, value, prec, width, flags);
+  }
+
+  // determine the sign
+  const bool negative = value < 0;
+  if (negative) {
+    value = -value;
+  }
+
+  // default precision
+  if (!(flags & FLAGS_PRECISION)) {
+    prec = PRINTF_DEFAULT_FLOAT_PRECISION;
+  }
+
+  // determine the decimal exponent
+  // based on the algorithm by David Gay (https://www.ampl.com/netlib/fp/dtoa.c)
+  union {
+    uint64_t U;
+    double   F;
+  } conv;
+
+  conv.F = value;
+  int exp2 = (int)((conv.U >> 52U) & 0x07FFU) - 1023;           // effectively log2
+  conv.U = (conv.U & ((1ULL << 52U) - 1U)) | (1023ULL << 52U);  // drop the exponent so conv.F is now in [1,2)
+  // now approximate log10 from the log2 integer part and an expansion of ln around 1.5
+  int expval = (int)(0.1760912590558 + exp2 * 0.301029995663981 + (conv.F - 1.5) * 0.289529654602168);
+  // now we want to compute 10^expval but we want to be sure it won't overflow
+  exp2 = (int)(expval * 3.321928094887362 + 0.5);
+  const double z  = expval * 2.302585092994046 - exp2 * 0.6931471805599453;
+  const double z2 = z * z;
+  conv.U = (uint64_t)(exp2 + 1023) << 52U;
+  // compute exp(z) using continued fractions, see https://en.wikipedia.org/wiki/Exponential_function#Continued_fractions_for_ex
+  conv.F *= 1 + 2 * z / (2 - z + (z2 / (6 + (z2 / (10 + z2 / 14)))));
+  // correct for rounding errors
+  if (value < conv.F) {
+    expval--;
+    conv.F /= 10;
+  }
+
+  // the exponent format is "%+03d" and largest value is "307", so set aside 4-5 characters
+  unsigned int minwidth = ((expval < 100) && (expval > -100)) ? 4U : 5U;
+
+  // in "%g" mode, "prec" is the number of *significant figures* not decimals
+  if (flags & FLAGS_ADAPT_EXP) {
+    // do we want to fall-back to "%f" mode?
+    if ((value >= 1e-4) && (value < 1e6)) {
+      if ((int)prec > expval) {
+        prec = (unsigned)((int)prec - expval - 1);
+      }
+      else {
+        prec = 0;
+      }
+      flags |= FLAGS_PRECISION;   // make sure _ftoa respects precision
+      // no characters in exponent
+      minwidth = 0U;
+      expval   = 0;
+    }
+    else {
+      // we use one sigfig for the whole part
+      if ((prec > 0) && (flags & FLAGS_PRECISION)) {
+        --prec;
+      }
+    }
+  }
+
+  // will everything fit?
+  unsigned int fwidth = width;
+  if (width > minwidth) {
+    // we didn't fall-back so subtract the characters required for the exponent
+    fwidth -= minwidth;
+  } else {
+    // not enough characters, so go back to default sizing
+    fwidth = 0U;
+  }
+  if ((flags & FLAGS_LEFT) && minwidth) {
+    // if we're padding on the right, DON'T pad the floating part
+    fwidth = 0U;
+  }
+
+  // rescale the float value
+  if (expval) {
+    value /= conv.F;
+  }
+
+  // output the floating part
+  const size_t start_idx = idx;
+  idx = _ftoa(out, buffer, idx, maxlen, negative ? -value : value, prec, fwidth, flags & ~FLAGS_ADAPT_EXP);
+
+  // output the exponent part
+  if (minwidth) {
+    // output the exponential symbol
+    out((flags & FLAGS_UPPERCASE) ? 'E' : 'e', buffer, idx++, maxlen);
+    // output the exponent value
+    idx = _ntoa_long(out, buffer, idx, maxlen, (expval < 0) ? -expval : expval, expval < 0, 10, 0, minwidth-1, FLAGS_ZEROPAD | FLAGS_PLUS);
+    // might need to right-pad spaces
+    if (flags & FLAGS_LEFT) {
+      while (idx - start_idx < width) out(' ', buffer, idx++, maxlen);
+    }
+  }
+  return idx;
+}
+#endif  // PRINTF_SUPPORT_EXPONENTIAL
+#endif  // PRINTF_SUPPORT_FLOAT
+
+
+// internal vsnprintf
+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;
+
+  if (!buffer) {
+    // use null output function
+    out = _out_null;
+  }
+
+  while (*format)
+  {
+    // format specifier?  %[flags][width][.precision][length]
+    if (*format != '%') {
+      // no
+      out(*format, buffer, idx++, maxlen);
+      format++;
+      continue;
+    }
+    else {
+      // yes, evaluate it
+      format++;
+    }
+
+    // evaluate flags
+    flags = 0U;
+    do {
+      switch (*format) {
+        case '0': flags |= FLAGS_ZEROPAD; format++; n = 1U; break;
+        case '-': flags |= FLAGS_LEFT;    format++; n = 1U; break;
+        case '+': flags |= FLAGS_PLUS;    format++; n = 1U; break;
+        case ' ': flags |= FLAGS_SPACE;   format++; n = 1U; break;
+        case '#': flags |= FLAGS_HASH;    format++; n = 1U; break;
+        default :                                   n = 0U; break;
+      }
+    } while (n);
+
+    // evaluate width field
+    width = 0U;
+    if (_is_digit(*format)) {
+      width = _atoi(&format);
+    }
+    else if (*format == '*') {
+      const int w = va_arg(va, int);
+      if (w < 0) {
+        flags |= FLAGS_LEFT;    // reverse padding
+        width = (unsigned int)-w;
+      }
+      else {
+        width = (unsigned int)w;
+      }
+      format++;
+    }
+
+    // evaluate precision field
+    precision = 0U;
+    if (*format == '.') {
+      flags |= FLAGS_PRECISION;
+      format++;
+      if (_is_digit(*format)) {
+        precision = _atoi(&format);
+      }
+      else if (*format == '*') {
+        const int prec = (int)va_arg(va, int);
+        precision = prec > 0 ? (unsigned int)prec : 0U;
+        format++;
+      }
+    }
+
+    // evaluate length field
+    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
+    switch (*format) {
+      case 'd' :
+      case 'i' :
+      case 'u' :
+      case 'x' :
+      case 'X' :
+      case 'o' :
+      case 'b' : {
+        // set the base
+        unsigned int base;
+        if (*format == 'x' || *format == 'X') {
+          base = 16U;
+        }
+        else if (*format == 'o') {
+          base =  8U;
+        }
+        else if (*format == 'b') {
+          base =  2U;
+        }
+        else {
+          base = 10U;
+          flags &= ~FLAGS_HASH;   // no hash for dec format
+        }
+        // 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);
+        }
+
+        // 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_LONG_LONG) {
+#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
+          }
+          else if (flags & FLAGS_LONG) {
+            const long value = va_arg(va, long);
+            idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned long)(value > 0 ? value : 0 - value), value < 0, base, precision, width, flags);
+          }
+          else {
+            const int value = (flags & FLAGS_CHAR) ? (char)va_arg(va, int) : (flags & FLAGS_SHORT) ? (short int)va_arg(va, 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_SUPPORT_LONG_LONG)
+            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(out, buffer, idx, maxlen, 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);
+            idx = _ntoa_long(out, buffer, idx, maxlen, value, false, base, precision, width, flags);
+          }
+        }
+        format++;
+        break;
+      }
+#if defined(PRINTF_SUPPORT_FLOAT)
+      case 'f' :
+      case 'F' :
+        if (*format == 'F') flags |= FLAGS_UPPERCASE;
+        idx = _ftoa(out, buffer, idx, maxlen, va_arg(va, double), precision, width, flags);
+        format++;
+        break;
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+      case 'e':
+      case 'E':
+      case 'g':
+      case 'G':
+        if ((*format == 'g')||(*format == 'G')) flags |= FLAGS_ADAPT_EXP;
+        if ((*format == 'E')||(*format == 'G')) flags |= FLAGS_UPPERCASE;
+        idx = _etoa(out, buffer, idx, maxlen, va_arg(va, double), precision, width, flags);
+        format++;
+        break;
+#endif  // PRINTF_SUPPORT_EXPONENTIAL
+#endif  // PRINTF_SUPPORT_FLOAT
+      case 'c' : {
+        unsigned int l = 1U;
+        // pre padding
+        if (!(flags & FLAGS_LEFT)) {
+          while (l++ < width) {
+            out(' ', buffer, idx++, maxlen);
+          }
+        }
+        // char output
+        out((char)va_arg(va, int), buffer, idx++, maxlen);
+        // post padding
+        if (flags & FLAGS_LEFT) {
+          while (l++ < width) {
+            out(' ', buffer, idx++, maxlen);
+          }
+        }
+        format++;
+        break;
+      }
+
+      case 's' : {
+        const char* p = va_arg(va, char*);
+        unsigned int l = _strnlen_s(p, precision ? precision : (size_t)-1);
+        // pre padding
+        if (flags & FLAGS_PRECISION) {
+          l = (l < precision ? l : precision);
+        }
+        if (!(flags & FLAGS_LEFT)) {
+          while (l++ < width) {
+            out(' ', buffer, idx++, maxlen);
+          }
+        }
+        // string output
+        while ((*p != 0) && (!(flags & FLAGS_PRECISION) || precision--)) {
+          out(*(p++), buffer, idx++, maxlen);
+        }
+        // post padding
+        if (flags & FLAGS_LEFT) {
+          while (l++ < width) {
+            out(' ', buffer, idx++, maxlen);
+          }
+        }
+        format++;
+        break;
+      }
+
+      case 'p' : {
+        width = sizeof(void*) * 2U;
+        flags |= FLAGS_ZEROPAD | FLAGS_UPPERCASE;
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+        const bool is_ll = sizeof(uintptr_t) == sizeof(long long);
+        if (is_ll) {
+          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_SUPPORT_LONG_LONG)
+        }
+#endif
+        format++;
+        break;
+      }
+
+      case '%' :
+        out('%', buffer, idx++, maxlen);
+        format++;
+        break;
+
+      default :
+        out(*format, buffer, idx++, maxlen);
+        format++;
+        break;
+    }
+  }
+
+  // termination
+  out((char)0, buffer, idx < maxlen ? idx : maxlen - 1U, maxlen);
+
+  // return written chars without terminating \0
+  return (int)idx;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+int printf_(const char* format, ...)
+{
+  va_list va;
+  va_start(va, format);
+  char buffer[1];
+  const int ret = _vsnprintf(_out_char, buffer, (size_t)-1, format, va);
+  va_end(va);
+  return ret;
+}
+
+
+int sprintf_(char* buffer, const char* format, ...)
+{
+  va_list va;
+  va_start(va, format);
+  const int ret = _vsnprintf(_out_buffer, buffer, (size_t)-1, format, va);
+  va_end(va);
+  return ret;
+}
+
+
+int snprintf_(char* buffer, size_t count, const char* format, ...)
+{
+  va_list va;
+  va_start(va, format);
+  const int ret = _vsnprintf(_out_buffer, buffer, count, format, va);
+  va_end(va);
+  return ret;
+}
+
+
+int vprintf_(const char* format, va_list va)
+{
+  char buffer[1];
+  return _vsnprintf(_out_char, buffer, (size_t)-1, format, va);
+}
+
+
+int vsnprintf_(char* buffer, size_t count, const char* format, va_list va)
+{
+  return _vsnprintf(_out_buffer, buffer, count, format, va);
+}
+
+
+int fctprintf(void (*out)(char character, void* arg), void* arg, const char* format, ...)
+{
+  va_list va;
+  va_start(va, format);
+  const out_fct_wrap_type out_fct_wrap = { out, arg };
+  const int ret = _vsnprintf(_out_fct, (char*)(uintptr_t)&out_fct_wrap, (size_t)-1, format, va);
+  va_end(va);
+  return ret;
+}

helpers/printf.h

@@ -1,117 +1,117 @@
-// ///////////////////////////////////////////////////////////////////////////////
-// // \author (c) Marco Paland (info@paland.com)
-// //             2014-2019, PALANDesign Hannover, Germany
-// //
-// // \license The MIT License (MIT)
-// //
-// // Permission is hereby granted, free of charge, to any person obtaining a copy
-// // of this software and associated documentation files (the "Software"), to deal
-// // in the Software without restriction, including without limitation the rights
-// // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// // copies of the Software, and to permit persons to whom the Software is
-// // furnished to do so, subject to the following conditions:
-// // 
-// // The above copyright notice and this permission notice shall be included in
-// // all copies or substantial portions of the Software.
-// // 
-// // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// // THE SOFTWARE.
-// //
-// // \brief Tiny printf, sprintf and snprintf implementation, optimized for speed on
-// //        embedded systems with a very limited resources.
-// //        Use this instead of bloated standard/newlib printf.
-// //        These routines are thread safe and reentrant.
-// //
-// ///////////////////////////////////////////////////////////////////////////////
-
-// #ifndef _PRINTF_H_
-// #define _PRINTF_H_
-
-// #include <stdarg.h>
-// #include <stddef.h>
-
-
-// #ifdef __cplusplus
-// extern "C" {
-// #endif
-
-
-// /**
-//  * Output a character to a custom device like UART, used by the printf() function
-//  * This function is declared here only. You have to write your custom implementation somewhere
-//  * \param character Character to output
-//  */
-// void _putchar(char character);
-
-
-// /**
-//  * Tiny printf implementation
-//  * You have to implement _putchar if you use printf()
-//  * To avoid conflicts with the regular printf() API it is overridden by macro defines
-//  * and internal underscore-appended functions like printf_() are used
-//  * \param format A string that specifies the format of the output
-//  * \return The number of characters that are written into the array, not counting the terminating null character
-//  */
-// #define printf printf_
-// int printf_(const char* format, ...);
-
-
-// /**
-//  * Tiny sprintf implementation
-//  * Due to security reasons (buffer overflow) YOU SHOULD CONSIDER USING (V)SNPRINTF INSTEAD!
-//  * \param buffer A pointer to the buffer where to store the formatted string. MUST be big enough to store the output!
-//  * \param format A string that specifies the format of the output
-//  * \return The number of characters that are WRITTEN into the buffer, not counting the terminating null character
-//  */
-// #define sprintf sprintf_
-// int sprintf_(char* buffer, const char* format, ...);
-
-
-// /**
-//  * Tiny snprintf/vsnprintf implementation
-//  * \param buffer A pointer to the buffer where to store the formatted string
-//  * \param count The maximum number of characters to store in the buffer, including a terminating null character
-//  * \param format A string that specifies the format of the output
-//  * \param va A value identifying a variable arguments list
-//  * \return The number of characters that COULD have been written into the buffer, not counting the terminating
-//  *         null character. A value equal or larger than count indicates truncation. Only when the returned value
-//  *         is non-negative and less than count, the string has been completely written.
-//  */
-// #define snprintf  snprintf_
-// #define vsnprintf vsnprintf_
-// int  snprintf_(char* buffer, size_t count, const char* format, ...);
-// int vsnprintf_(char* buffer, size_t count, const char* format, va_list va);
-
-
-// /**
-//  * Tiny vprintf implementation
-//  * \param format A string that specifies the format of the output
-//  * \param va A value identifying a variable arguments list
-//  * \return The number of characters that are WRITTEN into the buffer, not counting the terminating null character
-//  */
-// #define vprintf vprintf_
-// int vprintf_(const char* format, va_list va);
-
-
-// /**
-//  * printf with output function
-//  * You may use this as dynamic alternative to printf() with its fixed _putchar() output
-//  * \param out An output function which takes one character and an argument pointer
-//  * \param arg An argument pointer for user data passed to output function
-//  * \param format A string that specifies the format of the output
-//  * \return The number of characters that are sent to the output function, not counting the terminating null character
-//  */
-// int fctprintf(void (*out)(char character, void* arg), void* arg, const char* format, ...);
-
-
-// #ifdef __cplusplus
-// }
-// #endif
-
-
-// #endif  // _PRINTF_H_
+///////////////////////////////////////////////////////////////////////////////
+// \author (c) Marco Paland (info@paland.com)
+//             2014-2019, PALANDesign Hannover, Germany
+//
+// \license The MIT License (MIT)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// \brief Tiny printf, sprintf and snprintf implementation, optimized for speed on
+//        embedded systems with a very limited resources.
+//        Use this instead of bloated standard/newlib printf.
+//        These routines are thread safe and reentrant.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _PRINTF_H_
+#define _PRINTF_H_
+
+#include <stdarg.h>
+#include <stddef.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * Output a character to a custom device like UART, used by the printf() function
+ * This function is declared here only. You have to write your custom implementation somewhere
+ * \param character Character to output
+ */
+void _putchar(char character);
+
+
+/**
+ * Tiny printf implementation
+ * You have to implement _putchar if you use printf()
+ * To avoid conflicts with the regular printf() API it is overridden by macro defines
+ * and internal underscore-appended functions like printf_() are used
+ * \param format A string that specifies the format of the output
+ * \return The number of characters that are written into the array, not counting the terminating null character
+ */
+#define printf printf_
+int printf_(const char* format, ...);
+
+
+/**
+ * Tiny sprintf implementation
+ * Due to security reasons (buffer overflow) YOU SHOULD CONSIDER USING (V)SNPRINTF INSTEAD!
+ * \param buffer A pointer to the buffer where to store the formatted string. MUST be big enough to store the output!
+ * \param format A string that specifies the format of the output
+ * \return The number of characters that are WRITTEN into the buffer, not counting the terminating null character
+ */
+#define sprintf sprintf_
+int sprintf_(char* buffer, const char* format, ...);
+
+
+/**
+ * Tiny snprintf/vsnprintf implementation
+ * \param buffer A pointer to the buffer where to store the formatted string
+ * \param count The maximum number of characters to store in the buffer, including a terminating null character
+ * \param format A string that specifies the format of the output
+ * \param va A value identifying a variable arguments list
+ * \return The number of characters that COULD have been written into the buffer, not counting the terminating
+ *         null character. A value equal or larger than count indicates truncation. Only when the returned value
+ *         is non-negative and less than count, the string has been completely written.
+ */
+#define snprintf  snprintf_
+#define vsnprintf vsnprintf_
+int  snprintf_(char* buffer, size_t count, const char* format, ...);
+int vsnprintf_(char* buffer, size_t count, const char* format, va_list va);
+
+
+/**
+ * Tiny vprintf implementation
+ * \param format A string that specifies the format of the output
+ * \param va A value identifying a variable arguments list
+ * \return The number of characters that are WRITTEN into the buffer, not counting the terminating null character
+ */
+#define vprintf vprintf_
+int vprintf_(const char* format, va_list va);
+
+
+/**
+ * printf with output function
+ * You may use this as dynamic alternative to printf() with its fixed _putchar() output
+ * \param out An output function which takes one character and an argument pointer
+ * \param arg An argument pointer for user data passed to output function
+ * \param format A string that specifies the format of the output
+ * \return The number of characters that are sent to the output function, not counting the terminating null character
+ */
+int fctprintf(void (*out)(char character, void* arg), void* arg, const char* format, ...);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif  // _PRINTF_H_

scenes/flipbip_scene_menu.c

@@ -14,7 +14,7 @@ void flipbip_scene_menu_submenu_callback(void* context, uint32_t index) {
 void flipbip_scene_menu_on_enter(void* context) {
     FlipBip* app = context;
 
-    submenu_add_item(app->submenu, "New BIP39 Mnemonic", SubmenuIndexScene1, flipbip_scene_menu_submenu_callback, app);
+    submenu_add_item(app->submenu, "Generate wallet", SubmenuIndexScene1, flipbip_scene_menu_submenu_callback, app);
     //submenu_add_item(app->submenu, "Scene 2", SubmenuIndexScene2, flipbip_scene_menu_submenu_callback, app);
     submenu_add_item(app->submenu, "Settings", SubmenuIndexSettings, flipbip_scene_menu_submenu_callback, app);
 

views/flipbip_scene_1.c

@@ -10,7 +10,7 @@
 #include "../helpers/flipbip_string.h"
 
 #include <string.h>
-// #include "../helpers/printf.h"
+#include "../helpers/printf.h"
 #include "../crypto/bip32.h"
 #include "../crypto/bip39.h"
 #include "../crypto/curves.h"
@@ -26,8 +26,6 @@ struct FlipBipScene1 {
 typedef struct {
     int page;
     int strength;
-
-    // for crypto
     CONFIDENTIAL const char* mnemonic;
     CONFIDENTIAL uint8_t seed[64];
     CONFIDENTIAL const HDNode* node;
@@ -36,22 +34,15 @@ typedef struct {
     CONFIDENTIAL const char* xpub_account;
     CONFIDENTIAL const char* xprv_extended;
     CONFIDENTIAL const char* xpub_extended;
-
-    // for display
-    CONFIDENTIAL const char* seed1;
-    CONFIDENTIAL const char* seed2;
-    CONFIDENTIAL const char* seed3;
-    CONFIDENTIAL const char* seed4;
-    CONFIDENTIAL const char* seed5;
-    CONFIDENTIAL const char* seed6;
-    CONFIDENTIAL const char* mnemonic1;
-    CONFIDENTIAL const char* mnemonic2;
-    CONFIDENTIAL const char* mnemonic3;
-    CONFIDENTIAL const char* mnemonic4;
-    CONFIDENTIAL const char* mnemonic5;
-    CONFIDENTIAL const char* mnemonic6;
 } FlipBipScene1Model;
 
+static CONFIDENTIAL char s_disp_text1[30 + 1];
+static CONFIDENTIAL char s_disp_text2[30 + 1];
+static CONFIDENTIAL char s_disp_text3[30 + 1];
+static CONFIDENTIAL char s_disp_text4[30 + 1];
+static CONFIDENTIAL char s_disp_text5[30 + 1];
+static CONFIDENTIAL char s_disp_text6[30 + 1];
+
 void flipbip_scene_1_set_callback(
     FlipBipScene1* instance,
     FlipBipScene1Callback callback,
@@ -62,11 +53,31 @@ void flipbip_scene_1_set_callback(
     instance->context = context;
 }
 
-static void flipbip_scene_1_draw_mnemonic(FlipBipScene1Model* const model) {
+static void flipbip_scene_1_draw_generic(const char* text, size_t line_len) {
+    // Split the text into parts
+    for (size_t si = 1; si <= 6; si++) {
+        char *ptr = NULL;
+        
+        if      (si == 1) ptr = s_disp_text1;
+        else if (si == 2) ptr = s_disp_text2;
+        else if (si == 3) ptr = s_disp_text3;
+        else if (si == 4) ptr = s_disp_text4;
+        else if (si == 5) ptr = s_disp_text5;
+        else if (si == 6) ptr = s_disp_text6;
+        
+        memzero(ptr, 30 + 1);
+        if (line_len > 30) {
+            strncpy(ptr, text + ((si - 1) * 30), 30);
+        } else {
+            strncpy(ptr, text + ((si - 1) * line_len), line_len);
+        }
+    }
+}
 
+static void flipbip_scene_1_draw_mnemonic(const char* mnemonic) {
     // Delineate sections of the mnemonic every 4 words
-    char *mnemonic_working = malloc(strlen(model->mnemonic) + 1);
-    strcpy(mnemonic_working, model->mnemonic);
+    char *mnemonic_working = malloc(strlen(mnemonic) + 1);
+    strcpy(mnemonic_working, mnemonic);
     int word = 0;
     for (size_t i = 0; i < strlen(mnemonic_working); i++) {
         if (mnemonic_working[i] == ' ') {
@@ -82,16 +93,22 @@ static void flipbip_scene_1_draw_mnemonic(FlipBipScene1Model* const model) {
     int mi = 0;
     while(mnemonic_part != NULL)
     {
-        char *ptr = malloc(strlen(mnemonic_part) + 1);
-        strcpy(ptr, mnemonic_part);
+        char *ptr = NULL;
         mi++;
         
-        if      (mi == 1) model->mnemonic1 = ptr;
-        else if (mi == 2) model->mnemonic2 = ptr;
-        else if (mi == 3) model->mnemonic3 = ptr;
-        else if (mi == 4) model->mnemonic4 = ptr;
-        else if (mi == 5) model->mnemonic5 = ptr;
-        else if (mi == 6) model->mnemonic6 = ptr;
+        if      (mi == 1) ptr = s_disp_text1;
+        else if (mi == 2) ptr = s_disp_text2;
+        else if (mi == 3) ptr = s_disp_text3;
+        else if (mi == 4) ptr = s_disp_text4;
+        else if (mi == 5) ptr = s_disp_text5;
+        else if (mi == 6) ptr = s_disp_text6;
+
+        memzero(ptr, 30 + 1);
+        if (strlen(mnemonic_part) > 30) {
+            strncpy(ptr, mnemonic_part, 30);
+        } else {
+            strncpy(ptr, mnemonic_part, strlen(mnemonic_part));
+        }
 
         mnemonic_part = flipbip_strtok(NULL, ",");
     }
@@ -99,37 +116,121 @@ static void flipbip_scene_1_draw_mnemonic(FlipBipScene1Model* const model) {
     // Free the working mnemonic memory
     memzero(mnemonic_working, strlen(mnemonic_working));
     free(mnemonic_working);
+}
+
+static void flipbip_scene_1_draw_seed(FlipBipScene1Model* const model) {
+    char *seed_working = malloc(64 * 2 + 1);
+    // Convert the seed to a hex string
+    for (size_t i = 0; i < 64; i++) {
+        //flipbip_itoa(model->seed[i], seed_working + (i * 2), 64 * 2 + 1, 16);
+        sprintf(seed_working + (i * 2), "%02x", model->seed[i]);
+    }
+    
+    flipbip_scene_1_draw_generic(seed_working, 22);
+
+    // Free the working seed memory
+    memzero(seed_working, sizeof(seed_working));
+    free(seed_working);
+}
+
+static void flipbip_scene_1_draw_address(HDNode* const node, uint32_t addr_index) {
+    // Constants for Bitcoin address generation
+    const char addr_version = 0x00;
+    //const char wif_version = 0x80;
+
+    // buffer for key serialization
+    const size_t buflen = 128;
+    char buf[128 + 1];
+
+    HDNode *addr_node = malloc(sizeof(HDNode));
+    memcpy(addr_node, node, sizeof(HDNode));
+
+    hdnode_private_ckd(addr_node, addr_index);
+    hdnode_fill_public_key(addr_node);
+    ecdsa_get_address(addr_node->public_key, addr_version, HASHER_SHA2_RIPEMD, HASHER_SHA2D, buf, buflen); 
+    
+    char *address = malloc(buflen + 1);
+    strncpy(address, buf, buflen);
+    flipbip_scene_1_draw_generic(address, 12);
+    memzero(address, buflen + 1);
+    free(address);
+
+    //ecdsa_get_wif(addr_node->private_key, wif_version, HASHER_SHA2D, buf, buflen); 
+    //char *wif = malloc(buflen + 1);
+    //strncpy(wif, buf, buflen);
+
+    memzero(addr_node, sizeof(HDNode));
+    free(addr_node);
+}
 
+static void flipbip_scene_1_clear_text() {
+    memzero((void*)s_disp_text1, 30 + 1);
+    memzero((void*)s_disp_text2, 30 + 1);
+    memzero((void*)s_disp_text3, 30 + 1);
+    memzero((void*)s_disp_text4, 30 + 1);
+    memzero((void*)s_disp_text5, 30 + 1);
+    memzero((void*)s_disp_text6, 30 + 1);
 }
 
 void flipbip_scene_1_draw(Canvas* canvas, FlipBipScene1Model* model) {
     //UNUSED(model);
     canvas_clear(canvas);
     canvas_set_color(canvas, ColorBlack);
-    //canvas_set_font(canvas, FontPrimary);
-    //canvas_draw_str_aligned(canvas, 0, 10, AlignLeft, AlignTop, "This is Scene 1"); 
-    
-    canvas_set_font(canvas, FontSecondary);
-    //canvas_draw_str_aligned(canvas, 1, 2, AlignLeft, AlignTop, model->strength == 128 ? "128-bit" : "256-bit");
-    //canvas_draw_str_aligned(canvas, 1, 2, AlignLeft, AlignTop, model->seed);
     
-    // Mnenomic
-    if (model->page == 0) {
-        canvas_draw_str_aligned(canvas, 1, 2, AlignLeft, AlignTop, model->mnemonic1);
-        canvas_draw_str_aligned(canvas, 1, 12, AlignLeft, AlignTop, model->mnemonic2);
-        canvas_draw_str_aligned(canvas, 1, 22, AlignLeft, AlignTop, model->mnemonic3);
-        canvas_draw_str_aligned(canvas, 1, 32, AlignLeft, AlignTop, model->mnemonic4);
-        canvas_draw_str_aligned(canvas, 1, 42, AlignLeft, AlignTop, model->mnemonic5);
-        canvas_draw_str_aligned(canvas, 1, 52, AlignLeft, AlignTop, model->mnemonic6);
+    if (model->page == 1) {
+        const char* info = "-Scroll pages with up/down-" 
+                           "p1,2)    Mnemonic/Seed     "
+                           "p3)       xprv Root Key    "
+                           "p4,5)  xprv/xpub account   "
+                           "p6,7)  xprv/xpub extended  "
+                           "p8+)    Receive Addresses  ";
+        flipbip_scene_1_draw_generic(info, 27);
+    }
+    else if (model->page == 2) {
+        flipbip_scene_1_draw_mnemonic(model->mnemonic);
+    } 
+    else if (model->page == 3) {
+        flipbip_scene_1_draw_seed(model);
+    }
+    else if (model->page == 4) {
+        flipbip_scene_1_draw_generic(model->xprv_root, 20);
     }
-    // Seed
+    else if (model->page == 5) {
+        flipbip_scene_1_draw_generic(model->xprv_account, 20);
+    }
+    else if (model->page == 6) {
+        flipbip_scene_1_draw_generic(model->xpub_account, 20);
+    }
+    else if (model->page == 7) {
+        flipbip_scene_1_draw_generic(model->xprv_extended, 20);
+    }
+    else if (model->page == 8) {
+        flipbip_scene_1_draw_generic(model->xpub_extended, 20);
+    } 
+    else if (model->page >= 9 && model->page <= 13) {
+        flipbip_scene_1_draw_address(model->node, model->page - 9);
+    }
+
+    if (model->page == 0) {
+        canvas_set_font(canvas, FontPrimary);
+        canvas_draw_str_aligned(canvas, 1, 10, AlignLeft, AlignTop, "Generating...");
+        canvas_draw_str_aligned(canvas, 6, 24, AlignLeft, AlignTop, "m/44'/0'/0'/0");
+    } else if (model->page >= 9 && model->page <= 13) {
+        canvas_set_font(canvas, FontPrimary);
+        canvas_draw_str(canvas, 1, 10, "Receive address");
+
+        canvas_draw_str(canvas, 6, 30, s_disp_text1);
+        canvas_draw_str(canvas, 6, 42, s_disp_text2);
+        canvas_draw_str(canvas, 6, 54, s_disp_text3);
+    } 
     else {
-        canvas_draw_str_aligned(canvas, 1, 2, AlignLeft, AlignTop, model->seed1);
-        canvas_draw_str_aligned(canvas, 1, 12, AlignLeft, AlignTop, model->seed2);
-        canvas_draw_str_aligned(canvas, 1, 22, AlignLeft, AlignTop, model->seed3);
-        canvas_draw_str_aligned(canvas, 1, 32, AlignLeft, AlignTop, model->seed4);
-        canvas_draw_str_aligned(canvas, 1, 42, AlignLeft, AlignTop, model->seed5);
-        canvas_draw_str_aligned(canvas, 1, 52, AlignLeft, AlignTop, model->seed6);
+        canvas_set_font(canvas, FontSecondary);
+        canvas_draw_str_aligned(canvas, 1, 2, AlignLeft, AlignTop, s_disp_text1);
+        canvas_draw_str_aligned(canvas, 1, 12, AlignLeft, AlignTop, s_disp_text2);
+        canvas_draw_str_aligned(canvas, 1, 22, AlignLeft, AlignTop, s_disp_text3);
+        canvas_draw_str_aligned(canvas, 1, 32, AlignLeft, AlignTop, s_disp_text4);
+        canvas_draw_str_aligned(canvas, 1, 42, AlignLeft, AlignTop, s_disp_text5);
+        canvas_draw_str_aligned(canvas, 1, 52, AlignLeft, AlignTop, s_disp_text6);
     }
 
     
@@ -141,42 +242,13 @@ static void flipbip_scene_1_model_init(FlipBipScene1Model* const model, const in
 
     // Generate a random mnemonic using trezor-crypto
     model->strength = strength;
-    //const char *mnemonic = mnemonic_generate(model->strength);
-    model->mnemonic = "wealth budget salt video delay obey neutral tail sure soda hold rubber joy movie boat raccoon tornado noise off inmate payment patch group topple";
-
-    flipbip_scene_1_draw_mnemonic(model);
+    const char *mnemonic = mnemonic_generate(model->strength);
+    
+    // test mnemonic
+    //model->mnemonic = "wealth budget salt video delay obey neutral tail sure soda hold rubber joy movie boat raccoon tornado noise off inmate payment patch group topple";
 
     // Generate a BIP39 seed from the mnemonic
-    //uint8_t seedbytes[64];
     mnemonic_to_seed(model->mnemonic, "", model->seed, 0);
-    
-    // BEGIN DRAW SEED
-
-    char *seed_working = malloc(64 * 2 + 1);
-    // Convert the seed to a hex string
-    for (size_t i = 0; i < 64; i++) {
-        flipbip_itoa(model->seed[i], seed_working + (i * 2), 64 * 2 + 1, 16);
-        //sprintf(seed + (i * 2), "%.2x", seedbytes[i]);
-    }
-    
-    // Split the seed into parts
-    for (size_t si = 1; si <= 6; si++) {
-        char *ptr = malloc(22 + 1);
-        strncpy(ptr, seed_working + ((si - 1) * 22), 22);
-        
-        if      (si == 1) model->seed1 = ptr;
-        else if (si == 2) model->seed2 = ptr;
-        else if (si == 3) model->seed3 = ptr;
-        else if (si == 4) model->seed4 = ptr;
-        else if (si == 5) model->seed5 = ptr;
-        else if (si == 6) model->seed6 = ptr;
-    }
-
-    // Free the working seed memory
-    memzero(seed_working, sizeof(seed_working));
-    free(seed_working);
-
-    // END DRAW SEED
 
     // Generate a BIP32 root key from the mnemonic
 
@@ -194,7 +266,7 @@ static void flipbip_scene_1_model_init(FlipBipScene1Model* const model, const in
     // constants for Bitcoin
     const uint32_t version_public = 0x0488b21e;
     const uint32_t version_private = 0x0488ade4;
-    const char addr_version = 0x00, wif_version = 0x80;
+    //const char addr_version = 0x00, wif_version = 0x80;
     
     // buffer for key serialization
     const size_t buflen = 128;
@@ -246,35 +318,7 @@ static void flipbip_scene_1_model_init(FlipBipScene1Model* const model, const in
     model->xpub_extended = xpub_ext;
 
     model->node = node;
-
-    // BEGIN DRAW ADDRESS
-
-    for (int i = 0; i < 3; i++) {
-        HDNode *addr_node = malloc(sizeof(HDNode));
-        memcpy(addr_node, node, sizeof(HDNode));
-
-        hdnode_private_ckd(addr_node, i);
-        hdnode_fill_public_key(addr_node);
-        ecdsa_get_address(addr_node->public_key, addr_version, HASHER_SHA2_RIPEMD, HASHER_SHA2D, buf, buflen); 
-        char *address = malloc(buflen + 1);
-        strncpy(address, buf, buflen);
-        model->seed5 = address;
-        ecdsa_get_wif(addr_node->private_key, wif_version, HASHER_SHA2D, buf, buflen); 
-        char *wif = malloc(buflen + 1);
-        strncpy(wif, buf, buflen);
-        model->seed6 = wif;
-        memzero(addr_node, sizeof(HDNode));
-        free(addr_node);
-    }
-
-    // END DRAW ADDRESS
-
-    // Clear the root node
-    // memzero(root, sizeof(HDNode));
-    // free(root);
-
-    // Clear the mnemonic
-    //mnemonic_clear();
+    model->page = 1;
 
 #if USE_BIP39_CACHE
     // Clear the BIP39 cache
@@ -297,9 +341,7 @@ bool flipbip_scene_1_input(InputEvent* event, void* context) {
                     },
                     true);
                 break;
-            case InputKeyLeft:
             case InputKeyRight:
-            case InputKeyUp:
             case InputKeyDown:
             case InputKeyOk:
                 with_view_model(
@@ -307,7 +349,24 @@ bool flipbip_scene_1_input(InputEvent* event, void* context) {
                     FlipBipScene1Model* model,
                     {
                         //UNUSED(model);
-                        model->page = (model->page + 1) % 2;
+                        model->page = (model->page + 1) % 14;
+                        if (model->page == 0) {
+                            model->page = 1;
+                        }
+                    },
+                    true);
+                break;
+            case InputKeyLeft:
+            case InputKeyUp:
+                with_view_model(
+                    instance->view,
+                    FlipBipScene1Model* model,
+                    {
+                        //UNUSED(model);
+                        model->page = (model->page - 1) % 14;
+                        if (model->page == 0) {
+                            model->page = 13;
+                        }
                     },
                     true);
                 break;
@@ -326,24 +385,29 @@ void flipbip_scene_1_exit(void* context) {
         instance->view,
         FlipBipScene1Model * model,
         {
-            // Clear the mnemonic from memory
             model->page = 0;
             model->strength = 0;
-            memzero((void*)model->seed1, strlen(model->seed1));
-            memzero((void*)model->seed2, strlen(model->seed2));
-            memzero((void*)model->seed3, strlen(model->seed3));
-            memzero((void*)model->seed4, strlen(model->seed4));
-            memzero((void*)model->seed5, strlen(model->seed5));
-            memzero((void*)model->seed6, strlen(model->seed6));
-            memzero((void*)model->mnemonic1, strlen(model->mnemonic1));
-            memzero((void*)model->mnemonic2, strlen(model->mnemonic2));
-            memzero((void*)model->mnemonic3, strlen(model->mnemonic3));
-            memzero((void*)model->mnemonic4, strlen(model->mnemonic4));
-            memzero((void*)model->mnemonic5, strlen(model->mnemonic5));
-            memzero((void*)model->mnemonic6, strlen(model->mnemonic6));
+            for (int i = 0; i < 64; i++) {
+                model->seed[i] = 0;
+            }
+            mnemonic_clear();
+            memzero((void*)model->node, sizeof(HDNode));
+            free((void*)model->node);
+            memzero((void*)model->xprv_root, strlen(model->xprv_root));
+            memzero((void*)model->xprv_account, strlen(model->xprv_account));
+            memzero((void*)model->xpub_account, strlen(model->xpub_account));
+            memzero((void*)model->xprv_extended, strlen(model->xprv_extended));
+            memzero((void*)model->xpub_extended, strlen(model->xpub_extended));
+            free((void*)model->xprv_root);
+            free((void*)model->xprv_account);
+            free((void*)model->xpub_account);
+            free((void*)model->xprv_extended);
+            free((void*)model->xpub_extended);
         },
         true
     );
+
+    flipbip_scene_1_clear_text();
 }
 
 void flipbip_scene_1_enter(void* context) {
@@ -404,21 +468,12 @@ void flipbip_scene_1_free(FlipBipScene1* instance) {
         instance->view,
         FlipBipScene1Model * model,
         {
-            //UNUSED(model);
-            free((void*)model->seed1);
-            free((void*)model->seed2);
-            free((void*)model->seed3);
-            free((void*)model->seed4);
-            free((void*)model->seed5);
-            free((void*)model->seed6);
-            free((void*)model->mnemonic1);
-            free((void*)model->mnemonic2);
-            free((void*)model->mnemonic3);
-            free((void*)model->mnemonic4);
-            free((void*)model->mnemonic5);
-            free((void*)model->mnemonic6);
+            UNUSED(model);
         },
         true);
+
+    flipbip_scene_1_clear_text();
+
     view_free(instance->view);
     free(instance);
 }

views/flipbip_startscreen.c

@@ -34,10 +34,7 @@ void flipbip_startscreen_draw(Canvas* canvas, FlipBipStartscreenModel* model) {
     canvas_draw_icon(canvas, 1, 33, &I_Auth_62x31);
 
     canvas_set_font(canvas, FontPrimary);
-    //canvas_draw_str(canvas, 69, 11, "Flipper-BIP");
-    //canvas_draw_str(canvas, 57, 11, "Flipper-BIP39");
-    //canvas_draw_str(canvas, 60, 11, "Flipper BIP39");
-    canvas_draw_str(canvas, 72, 11, "BIP39 Tool");
+    canvas_draw_str(canvas, 39, 11, "BIP32/39/44 Tool");
 
     canvas_set_font(canvas, FontSecondary);
     //canvas_draw_str(canvas, 30, 23, "Crypto tools for Flipper");