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 = [&](const char* s) {
        if (s == nullptr) {
            s = "(null)";
        }
        while (*s) {
            put_char(*s++);
        }
    };
 
    auto put_uint = [&](uint32_t val, int base, bool uppercase) {
        char digits[12];  // Enough for 32-bit
        int len = 0;
        const char* hex_chars = uppercase ? "0123456789ABCDEF" : "0123456789abcdef";
 
        if (val == 0) {
            put_char('0');
            return;
        }
 
        while (val > 0) {
            digits[len++] = hex_chars[val % base];
            val /= base;
        }
 
        while (len > 0) {
            put_char(digits[--len]);
        }
    };
 
    auto put_int = [&](int32_t val) {
        if (val < 0) {
            put_char('-');
            val = -val;
        }
        put_uint(static_cast<uint32_t>(val), 10, false);
    };
 
    auto put_float = [&](double val, int precision) {
        // Handle negative
        if (val < 0) {
            put_char('-');
            val = -val;
        }
 
        // Integer part
        uint32_t int_part = static_cast<uint32_t>(val);
        put_uint(int_part, 10, false);
 
        // Decimal point
        put_char('.');
 
        // Fractional part
        double frac = val - int_part;
        for (int i = 0; i < precision; i++) {
            frac *= 10;
            int digit = static_cast<int>(frac);
            put_char('0' + digit);
            frac -= digit;
        }
    };
 
    while (*fmt) {
        if (*fmt != '%') {
            put_char(*fmt++);
            continue;
        }
 
        fmt++;  // Skip '%'
 
        // Handle width (simple: just skip digits for now)
        while (*fmt >= '0' && *fmt <= '9') {
            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(static_cast<int32_t>(va_arg(args, long)));
                } else {
                    put_int(va_arg(args, int));
                }
                break;
 
            case 'u':
                if (is_long) {
                    put_uint(static_cast<uint32_t>(va_arg(args, unsigned long)), 10, false);
                } else {
                    put_uint(va_arg(args, unsigned int), 10, false);
                }
                break;
 
            case 'x':
                if (is_long) {
                    put_uint(static_cast<uint32_t>(va_arg(args, unsigned long)), 16, false);
                } else {
                    put_uint(va_arg(args, unsigned int), 16, false);
                }
                break;
 
            case 'X':
                if (is_long) {
                    put_uint(static_cast<uint32_t>(va_arg(args, unsigned long)), 16, true);
                } else {
                    put_uint(va_arg(args, unsigned int), 16, true);
                }
                break;
 
            case 's':
                put_string(va_arg(args, const char*));
                break;
 
            case 'c':
                put_char(static_cast<char>(va_arg(args, int)));
                break;
 
            case 'f':
                put_float(va_arg(args, double), precision);
                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_