meshx_tiny_printf.h File Reference

Lightweight printf implementation to reduce flash footprint. More...

#include <stdarg.h>
#include <stddef.h>

Go to the source code of this file.

Functions
int	meshx_tiny_vsnprintf (char *buf, size_t size, const char *fmt, va_list args)
	Lightweight vsnprintf replacement. Supports: s, d, u, x, X, p, c, %%. Supports padding with '0' and width specifier.
int	meshx_tiny_snprintf (char *buf, size_t size, const char *fmt,...)
	Lightweight snprintf replacement.
int	meshx_tiny_printf (const char *fmt,...)
	Lightweight printf that writes directly to console.
int	meshx_tiny_vprintf (const char *fmt, va_list args)

Detailed Description

Lightweight printf implementation to reduce flash footprint.

Copyright © 2024 - 2025 MeshX

Function Documentation

meshx_tiny_printf()

int meshx_tiny_printf	(	const char *	fmt,
			... )

Lightweight printf that writes directly to console.

                                            {
    va_list args;
    va_start(args, fmt);
    int res = meshx_tiny_vprintf(fmt, args);
    va_end(args);
    return res;
}

meshx_tiny_snprintf()

int meshx_tiny_snprintf	(	char *	buf,
		size_t	size,
		const char *	fmt,
			... )

Lightweight snprintf replacement.

                                                                      {
    va_list args;
    va_start(args, fmt);
    int res = meshx_tiny_vsnprintf(buf, size, fmt, args);
    va_end(args);
    return res;
}

meshx_tiny_vprintf()

int meshx_tiny_vprintf	(	const char *	fmt,
		va_list	args )

                                                      {
    char buf[256];
    int res = meshx_tiny_vsnprintf(buf, sizeof(buf), fmt, args);
    if (res > 0) {
        meshx_platform_console_write(buf, (uint16_t)res);
    }
    return res;
}

meshx_tiny_vsnprintf()

int meshx_tiny_vsnprintf	(	char *	buf,
		size_t	size,
		const char *	fmt,
		va_list	args )

Lightweight vsnprintf replacement. Supports: s, d, u, x, X, p, c, %%. Supports padding with '0' and width specifier.

                                                                                {
    char *start = buf;
    size_t initial_size = size;
 
    if (size == 0) return 0;
 
    while (*fmt && size > 1) {
        if (*fmt == '%') {
            fmt++;
            bool left_align = false;
            if (*fmt == '-') {
                left_align = true;
                fmt++;
            }
            char pad = ' ';
            int width = 0;
            if (*fmt == '0') {
                pad = '0';
                fmt++;
            }
            while (isdigit((int)*fmt)) {
                width = width * 10 + (*fmt - '0');
                fmt++;
            }
 
            // Handle long modifiers (e.g., %ld, %lu, %lx)
            while (*fmt == 'l') fmt++; 
 
            switch (*fmt) {
                case 's':
                    out_str(&buf, &size, va_arg(args, const char *), width, left_align);
                    break;
                case 'd':
                case 'i':
                    out_int(&buf, &size, va_arg(args, int32_t), 10, width, pad);
                    break;
                case 'u':
                    out_uint(&buf, &size, va_arg(args, uint32_t), 10, width, pad, false);
                    break;
                case 'x':
                    out_uint(&buf, &size, va_arg(args, uint32_t), 16, width, pad, false);
                    break;
                case 'X':
                    out_uint(&buf, &size, va_arg(args, uint32_t), 16, width, pad, true);
                    break;
                case 'p':
                    out_str(&buf, &size, "0x", 0, false);
                    out_uint(&buf, &size, (uint32_t)(uintptr_t)va_arg(args, void *), 16, 8, '0', false);
                    break;
                case 'c':
                    out_char(&buf, &size, (char)va_arg(args, int));
                    break;
                case '%':
                    out_char(&buf, &size, '%');
                    break;
                default:
                    out_char(&buf, &size, '%');
                    out_char(&buf, &size, *fmt);
                    break;
            }
        } else {
            out_char(&buf, &size, *fmt);
        }
        fmt++;
    }
 
    if (size > 0) {
        *buf = '\0';
    } else if (initial_size > 0) {
        start[initial_size - 1] = '\0';
    }
 
    return (int)(buf - start);
}