format.hpp

Go to the documentation of this file.

/**
 * @file format.hpp
 * @brief Minimal safe string formatting for embedded systems
 *
 * Provides basic printf-style formatting optimized for embedded use:
 * - %d, %i: signed integer
 * - %u: unsigned integer
 * - %x, %X: hex (lower/upper)
 * - %s: string
 * - %c: character
 * - %f: float (fixed precision, no scientific notation)
 * - %%: literal percent
 *
 * No dynamic allocation. Fixed buffer output.
 */
 
#ifndef SBL_LOG_FORMAT_HPP_
#define SBL_LOG_FORMAT_HPP_
 
#include <cstdint>
#include <cstddef>
#include <cstdarg>
 
namespace sbl::log {
 
/**
 * @brief Format a string into a buffer (vsnprintf-style)
 *
 * @param buf Output buffer
 * @param size Buffer size
 * @param fmt Format string
 * @param args Variadic argument list
 * @return Number of characters that would have been written (excluding null)
 */
inline int vformat(char* buf, size_t size, const char* fmt, va_list args) {
    if (size == 0 || buf == nullptr || fmt == nullptr) {
        return 0;
    }
 
    size_t pos = 0;
    const size_t max_pos = size - 1;  // Reserve space for null terminator
 
    auto put_char = [&](char c) {
        if (pos < max_pos) {
            buf[pos] = c;
        }
        pos++;
    };
 
    auto put_string_padded = [&](const char* s, int width) {
        if (s == nullptr) {
            s = "(null)";
        }
        // Measure length for padding
        int slen = 0;
        const char* p = s;
        while (*p++) slen++;
 
        // Right-justify: emit leading spaces
        for (int i = slen; i < width; ++i) put_char(' ');
        p = s;
        while (*p) put_char(*p++);
    };
 
    // Render unsigned integer into tmp buffer, return length
    auto render_uint = [](char* tmp, uint32_t val, int base, bool uppercase) -> int {
        const char* hex_chars = uppercase ? "0123456789ABCDEF" : "0123456789abcdef";
        int len = 0;
        if (val == 0) {
            tmp[len++] = '0';
        } else {
            char rev[12];
            int rlen = 0;
            while (val > 0) {
                rev[rlen++] = hex_chars[val % base];
                val /= base;
            }
            while (rlen > 0) tmp[len++] = rev[--rlen];
        }
        return len;
    };
 
    auto put_padded = [&](const char* digits, int len, int width, char fill, bool negative) {
        int content_len = len + (negative ? 1 : 0);
        if (fill == '0' && negative) {
            put_char('-');
        }
        for (int i = content_len; i < width; ++i) put_char(fill);
        if (fill != '0' && negative) {
            put_char('-');
        }
        for (int i = 0; i < len; ++i) put_char(digits[i]);
    };
 
    auto put_uint_padded = [&](uint32_t val, int base, bool uppercase, int width, char fill) {
        char tmp[12];
        int len = render_uint(tmp, val, base, uppercase);
        put_padded(tmp, len, width, fill, false);
    };
 
    auto put_int_padded = [&](int32_t val, int width, char fill) {
        bool neg = val < 0;
        uint32_t uval = neg ? static_cast<uint32_t>(-val) : static_cast<uint32_t>(val);
        char tmp[12];
        int len = render_uint(tmp, uval, 10, false);
        put_padded(tmp, len, width, fill, neg);
    };
 
    auto put_float = [&](double val, int precision, int width, char fill) {
        // Render to temporary buffer, then pad
        char tmp[24];
        int tpos = 0;
        bool neg = false;
 
        if (val < 0) {
            neg = true;
            val = -val;
        }
 
        // Integer part
        uint32_t int_part = static_cast<uint32_t>(val);
        tpos += render_uint(tmp + tpos, int_part, 10, false);
 
        // Decimal point + fractional
        tmp[tpos++] = '.';
        double frac = val - int_part;
        for (int i = 0; i < precision; i++) {
            frac *= 10;
            int digit = static_cast<int>(frac);
            tmp[tpos++] = static_cast<char>('0' + digit);
            frac -= digit;
        }
 
        put_padded(tmp, tpos, width, fill, neg);
    };
 
    while (*fmt) {
        if (*fmt != '%') {
            put_char(*fmt++);
            continue;
        }
 
        fmt++;  // Skip '%'
 
        // Parse flags
        char fill = ' ';
        if (*fmt == '0') {
            fill = '0';
            fmt++;
        }
 
        // Parse width
        int width = 0;
        while (*fmt >= '0' && *fmt <= '9') {
            width = width * 10 + (*fmt - '0');
            fmt++;
        }
 
        // Handle precision for floats
        int precision = 2;  // Default precision
        if (*fmt == '.') {
            fmt++;
            precision = 0;
            while (*fmt >= '0' && *fmt <= '9') {
                precision = precision * 10 + (*fmt - '0');
                fmt++;
            }
        }
 
        // Handle length modifiers (l, ll, h, hh)
        bool is_long = false;
        if (*fmt == 'l') {
            is_long = true;
            fmt++;
            if (*fmt == 'l') {
                fmt++;  // Skip second 'l' (treat ll same as l for 32-bit)
            }
        } else if (*fmt == 'h') {
            fmt++;
            if (*fmt == 'h') {
                fmt++;
            }
        }
 
        switch (*fmt) {
            case 'd':
            case 'i':
                if (is_long) {
                    put_int_padded(static_cast<int32_t>(va_arg(args, long)), width, fill);
                } else {
                    put_int_padded(va_arg(args, int), width, fill);
                }
                break;
 
            case 'u':
                if (is_long) {
                    put_uint_padded(static_cast<uint32_t>(va_arg(args, unsigned long)), 10, false, width, fill);
                } else {
                    put_uint_padded(va_arg(args, unsigned int), 10, false, width, fill);
                }
                break;
 
            case 'x':
                if (is_long) {
                    put_uint_padded(static_cast<uint32_t>(va_arg(args, unsigned long)), 16, false, width, fill);
                } else {
                    put_uint_padded(va_arg(args, unsigned int), 16, false, width, fill);
                }
                break;
 
            case 'X':
                if (is_long) {
                    put_uint_padded(static_cast<uint32_t>(va_arg(args, unsigned long)), 16, true, width, fill);
                } else {
                    put_uint_padded(va_arg(args, unsigned int), 16, true, width, fill);
                }
                break;
 
            case 's':
                put_string_padded(va_arg(args, const char*), width);
                break;
 
            case 'c':
                put_char(static_cast<char>(va_arg(args, int)));
                break;
 
            case 'f':
                put_float(va_arg(args, double), precision, width, fill);
                break;
 
            case '%':
                put_char('%');
                break;
 
            case '\0':
                // End of string after %
                goto done;
 
            default:
                // Unknown specifier, output as-is
                put_char('%');
                put_char(*fmt);
                break;
        }
 
        fmt++;
    }
 
done:
    // Null terminate
    buf[pos < size ? pos : max_pos] = '\0';
 
    return static_cast<int>(pos);
}
 
/**
 * @brief Format a string into a buffer (snprintf-style)
 *
 * @param buf Output buffer
 * @param size Buffer size
 * @param fmt Format string
 * @param ... Arguments
 * @return Number of characters that would have been written (excluding null)
 */
inline int format(char* buf, size_t size, const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
    int result = vformat(buf, size, fmt, args);
    va_end(args);
    return result;
}
 
} // namespace sbl::log
 
#endif // SBL_LOG_FORMAT_HPP_