embedded_printf.hpp

Go to the documentation of this file.

#ifndef SBL_CORE_UTIL_EMBEDDED_PRINTF_HPP_
#define SBL_CORE_UTIL_EMBEDDED_PRINTF_HPP_
 
/**
 * @file embedded_printf.hpp
 * @brief Lightweight printf implementation for ARM Cortex-M systems
 * @ingroup util
 * 
 * Minimal printf supporting only essential format specifiers:
 * - %s - strings
 * - %c - characters  
 * - %d - signed integers
 * - %u - unsigned integers
 * - %x - hex (lowercase)
 * - %X - hex (uppercase)
 * - %% - literal %
 * 
 * Features:
 * - ~200-300 bytes instead of 962 bytes for full vfprintf
 * - No floating point support (can be added for Cortex-M4F with FPU)
 * - No width/precision/flags (keeps it simple)
 * - Fixed buffer size (no dynamic allocation)
 * - ISR-safe (no global state)
 * 
 * Usage:
 * This is used automatically by the logging system when SBL_USE_EMBEDDED_PRINTF
 * is defined. Otherwise, it falls back to system printf.
 */
 
#include <cstdint>
#include <cstdarg>
#include <cstddef>
#include <sbl/common/defaults.hpp>
 
namespace sbl {
namespace core {
namespace util {
 
/**
 * @brief Lightweight printf implementation for ARM Cortex-M systems
 * 
 * Supports only essential format specifiers to minimize code size.
 * Perfect for embedded logging where full printf is overkill.
 */
class EmbeddedPrintf {
public:
    /**
     * @brief Format string with arguments into buffer
     * 
     * @param buffer Output buffer
     * @param size Buffer size
     * @param format Format string
     * @param args Variable arguments
     * @return Number of characters written (excluding null terminator)
     */
    static int vsnprintf(char* buffer, std::size_t size, const char* format, va_list args) {
        if (!buffer || size == 0) return 0;
        
        char* buf = buffer;
        char* const buf_end = buffer + size - 1; // Reserve space for null terminator
        const char* fmt = format;
        
        while (*fmt && buf < buf_end) {
            if (*fmt != '%') {
                *buf++ = *fmt++;
                continue;
            }
            
            fmt++; // Skip '%'
            
            if (*fmt == '%') {
                // Literal %
                *buf++ = '%';
                fmt++;
                continue;
            }
            
            // Parse width specifier (simplified - just skip digits and flags)
            while (*fmt && (*fmt >= '0' && *fmt <= '9')) {
                fmt++; // Skip width digits
            }
            
            // Parse format specifier
            switch (*fmt) {
                case 'c': {
                    // Character
                    int c = va_arg(args, int);
                    *buf++ = static_cast<char>(c);
                    break;
                }
                
                case 's': {
                    // String
                    const char* str = va_arg(args, const char*);
                    if (!str) str = "(null)";
                    
                    while (*str && buf < buf_end) {
                        *buf++ = *str++;
                    }
                    break;
                }
                
                case 'd': {
                    // Signed integer
                    int32_t value = va_arg(args, int32_t);
                    buf += formatInteger(buf, buf_end - buf, value, 10, false);
                    break;
                }
                
                case 'u': {
                    // Unsigned integer
                    uint32_t value = va_arg(args, uint32_t);
                    buf += formatUnsigned(buf, buf_end - buf, value, 10, false);
                    break;
                }
                
                case 'x': {
                    // Hex lowercase
                    uint32_t value = va_arg(args, uint32_t);
                    buf += formatUnsigned(buf, buf_end - buf, value, 16, false);
                    break;
                }
                
                case 'X': {
                    // Hex uppercase
                    uint32_t value = va_arg(args, uint32_t);
                    buf += formatUnsigned(buf, buf_end - buf, value, 16, true);
                    break;
                }
                
                default:
                    // Unknown format specifier - just output it
                    if (buf < buf_end) *buf++ = '%';
                    if (buf < buf_end) *buf++ = *fmt;
                    break;
            }
            
            fmt++;
        }
        
        *buf = '\0'; // Null terminate
        return static_cast<int>(buf - buffer);
    }
    
    /**
     * @brief Format string with arguments into buffer
     * 
     * @param buffer Output buffer
     * @param size Buffer size
     * @param format Format string
     * @param ... Variable arguments
     * @return Number of characters written (excluding null terminator)
     */
    static int snprintf(char* buffer, std::size_t size, const char* format, ...) {
        va_list args;
        va_start(args, format);
        int result = vsnprintf(buffer, size, format, args);
        va_end(args);
        return result;
    }
    
private:
    /**
     * @brief Format signed integer
     * 
     * @param buffer Output buffer
     * @param size Buffer size
     * @param value Integer value
     * @param base Number base (10, 16, etc.)
     * @param uppercase Use uppercase letters for hex
     * @return Number of characters written
     */
    static std::size_t formatInteger(char* buffer, std::size_t size, int32_t value, uint8_t base, bool uppercase) {
        if (size == 0) return 0;
        
        char* start = buffer;
        
        // Handle negative numbers
        if (value < 0) {
            value = -value;
            if (size > 0) {
                *buffer++ = '-';
                size--;
            }
        }
        
        std::size_t len = formatUnsigned(buffer, size, static_cast<uint32_t>(value), base, uppercase);
        return static_cast<std::size_t>(buffer - start) + len;
    }
    
    /**
     * @brief Format unsigned integer
     * 
     * @param buffer Output buffer
     * @param size Buffer size
     * @param value Unsigned integer value
     * @param base Number base (10, 16, etc.)
     * @param uppercase Use uppercase letters for hex
     * @return Number of characters written
     * 
     * @note Uses division/modulo for base conversion. This is acceptable for
     *       debug/logging paths but should not be used in time-critical code.
     *       For ARM Cortex-M0+ without hardware division, consider disabling
     *       printf support or using base-16 only (can use shifts).
     */
    static std::size_t formatUnsigned(char* buffer, std::size_t size, uint32_t value, uint8_t base, bool uppercase) {
        if (size == 0) return 0;
        
        char temp[sbl::defaults::SMALL_BUFFER]; // Enough for any 32-bit number in any base
        char* temp_ptr = temp + sizeof(temp) - 1;
        *temp_ptr = '\0';
        
        if (value == 0) {
            *--temp_ptr = '0';
        } else {
            const char* digits = uppercase ? "0123456789ABCDEF" : "0123456789abcdef";
            
            while (value > 0) {
                *--temp_ptr = digits[value % base];
                value /= base;
            }
        }
        
        // Copy to output buffer
        std::size_t len = 0;
        while (*temp_ptr && len < size - 1) {
            buffer[len++] = *temp_ptr++;
        }
        
        return len;
    }
};
 
/**
 * @brief Embedded printf functions
 * 
 * These are the functions that logging will use when SBL_USE_EMBEDDED_PRINTF is defined.
 */
inline int embedded_vsnprintf(char* buffer, std::size_t size, const char* format, va_list args) {
    return EmbeddedPrintf::vsnprintf(buffer, size, format, args);
}
 
inline int embedded_snprintf(char* buffer, std::size_t size, const char* format, ...) {
    va_list args;
    va_start(args, format);
    int result = EmbeddedPrintf::vsnprintf(buffer, size, format, args);
    va_end(args);
    return result;
}
 
} // namespace util
} // namespace core
} // namespace sbl
 
#endif // SBL_CORE_UTIL_EMBEDDED_PRINTF_HPP_