ra8_esp_hosted_fmt.c

Go to the documentation of this file.

 
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_esp_hosted_fmt_internal.h"

typedef enum : char {
  k_ra8_esp_hosted_fmt_ch_nul     = '\0', 
  k_ra8_esp_hosted_fmt_ch_percent = '%',  
  k_ra8_esp_hosted_fmt_ch_zero    = '0',  
  k_ra8_esp_hosted_fmt_ch_nine    = '9',  
  k_ra8_esp_hosted_fmt_ch_minus   = '-',  
  k_ra8_esp_hosted_fmt_ch_space   = ' ',  
  k_ra8_esp_hosted_fmt_ch_ell     = 'l',  
  k_ra8_esp_hosted_fmt_ch_zed     = 'z',  
} ra8_esp_hosted_fmt_char_t;

typedef enum : uint8_t {
  k_ra8_esp_hosted_fmt_radix_min = 2U,  
  k_ra8_esp_hosted_fmt_radix_dec = 10U, 
  k_ra8_esp_hosted_fmt_radix_hex = 16U, 
} ra8_esp_hosted_fmt_radix_t;

typedef struct ra8_esp_hosted_fmt_args {
  va_list ap; 
} ra8_esp_hosted_fmt_args_t;

typedef struct ra8_esp_hosted_fmt_cursor {
  char*    out; 
  uint32_t cap; 
  uint32_t len; 
} ra8_esp_hosted_fmt_cursor_t;

static const char s_ra8_esp_hosted_fmt_digits_lower[] = "0123456789abcdef";

static const char s_ra8_esp_hosted_fmt_digits_upper[] = "0123456789ABCDEF";

RA8_INTERNAL
static void internal_put(ra8_esp_hosted_fmt_cursor_t* cur, char ch)
{
  if ((cur->len + 1U) >= cur->cap) {
    return;
  }
  cur->out[cur->len] = ch;
  cur->len++;
}

RA8_INTERNAL
static void internal_pad(ra8_esp_hosted_fmt_cursor_t* cur, char pad, uint16_t count)
{
  uint16_t remaining = count;
  if (remaining > (uint16_t)k_ra8_esp_hosted_fmt_width_max) {
    remaining = (uint16_t)k_ra8_esp_hosted_fmt_width_max;
  }
  for (uint16_t i = 0U; i < remaining; i++) {
    internal_put(cur, pad);
  }
}

RA8_PRIV
uint8_t priv_ra8_esp_hosted_fmt_utoa(char* buf, uint64_t value, uint8_t base, bool upper)
{
  if (buf == nullptr) {
    return 0U;
  }
  if ((base < (uint8_t)k_ra8_esp_hosted_fmt_radix_min) ||
      (base > (uint8_t)k_ra8_esp_hosted_fmt_radix_hex)) {
    return 0U;
  }
 
  const char* glyphs =
    upper ? s_ra8_esp_hosted_fmt_digits_upper : s_ra8_esp_hosted_fmt_digits_lower;
  uint64_t remaining = value;
  uint8_t  count     = 0U;
 
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_esp_hosted_fmt_digits_max; i++) {
    buf[count] = glyphs[remaining % (uint64_t)base];
    count++;
    remaining /= (uint64_t)base;
    if (remaining == 0U) {
      break;
    }
  }
  buf[count] = (char)k_ra8_esp_hosted_fmt_ch_nul;
 
  for (uint8_t i = 0U; i < (uint8_t)(count / 2U); i++) {
    const char swap                = buf[i];
    buf[i]                         = buf[(uint8_t)(count - 1U - i)];
    buf[(uint8_t)(count - 1U - i)] = swap;
  }
  return count;
}

RA8_INTERNAL
static uint8_t internal_parse_flags(const char* text, ra8_esp_hosted_fmt_spec_t* out)
{
  uint8_t used = 0U;
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_esp_hosted_fmt_spec_max; i++) {
    if (text[used] == (char)k_ra8_esp_hosted_fmt_ch_zero) {
      out->zero_pad = true;
    } else if (text[used] == (char)k_ra8_esp_hosted_fmt_ch_minus) {
      out->left_justify = true;
    } else {
      break;
    }
    used++;
  }
  return used;
}

RA8_INTERNAL
static uint8_t internal_parse_width(const char* text, uint16_t* out_width)
{
  uint32_t width = 0U;
  uint8_t  used  = 0U;
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_esp_hosted_fmt_spec_max; i++) {
    if ((text[used] < (char)k_ra8_esp_hosted_fmt_ch_zero) ||
        (text[used] > (char)k_ra8_esp_hosted_fmt_ch_nine)) {
      break;
    }
    width = (width * (uint32_t)k_ra8_esp_hosted_fmt_radix_dec) +
            (uint32_t)(text[used] - (char)k_ra8_esp_hosted_fmt_ch_zero);
    if (width > (uint32_t)k_ra8_esp_hosted_fmt_width_max) {
      width = (uint32_t)k_ra8_esp_hosted_fmt_width_max;
    }
    used++;
  }
  *out_width = (uint16_t)width;
  return used;
}

RA8_INTERNAL
static uint8_t internal_parse_len(const char* text, ra8_esp_hosted_fmt_len_t* out_len)
{
  *out_len = k_ra8_esp_hosted_fmt_len_int;
  if (text[0] == (char)k_ra8_esp_hosted_fmt_ch_zed) {
    *out_len = k_ra8_esp_hosted_fmt_len_size;
    return 1U;
  }
  if (text[0] != (char)k_ra8_esp_hosted_fmt_ch_ell) {
    return 0U;
  }
  if (text[1] == (char)k_ra8_esp_hosted_fmt_ch_ell) {
    *out_len = k_ra8_esp_hosted_fmt_len_llong;
    return 2U;
  }
  *out_len = k_ra8_esp_hosted_fmt_len_long;
  return 1U;
}

RA8_INTERNAL
static bool internal_is_supported(char conv)
{
  return (conv == 'd') || (conv == 'i') || (conv == 'u') || (conv == 'x') || (conv == 'X') ||
         (conv == 'c') || (conv == 's') || (conv == 'p') ||
         (conv == (char)k_ra8_esp_hosted_fmt_ch_percent);
}

RA8_PRIV
bool priv_ra8_esp_hosted_fmt_parse(const char* after_percent, ra8_esp_hosted_fmt_spec_t* out)
{
  if ((after_percent == nullptr) || (out == nullptr)) {
    return false;
  }
 
  *out = (ra8_esp_hosted_fmt_spec_t){};
 
  uint8_t used = internal_parse_flags(after_percent, out);
  used         = (uint8_t)(used + internal_parse_width(&after_percent[used], &out->width));
  used         = (uint8_t)(used + internal_parse_len(&after_percent[used], &out->len));
 
  const char conv = after_percent[used];
  if (!internal_is_supported(conv)) {
    return false;
  }
 
  out->conv     = conv;
  out->consumed = (uint8_t)(used + 1U);
  return true;
}

RA8_INTERNAL
static uint64_t internal_next_unsigned(ra8_esp_hosted_fmt_args_t* args,
                                       ra8_esp_hosted_fmt_len_t   len)
{
  if (len == k_ra8_esp_hosted_fmt_len_llong) {
    // NOLINTNEXTLINE(clang-analyzer-security.VAList) -- Clang 22 loses caller va_copy state.
    return (uint64_t)va_arg(args->ap, unsigned long long);
  }
  if (len == k_ra8_esp_hosted_fmt_len_long) {
    // NOLINTNEXTLINE(clang-analyzer-security.VAList) -- Clang 22 loses caller va_copy state.
    return (uint64_t)va_arg(args->ap, unsigned long);
  }
  if (len == k_ra8_esp_hosted_fmt_len_size) {
    return (uint64_t)va_arg(args->ap, size_t);
  }
  return (uint64_t)va_arg(args->ap, unsigned int);
}

RA8_INTERNAL
static int64_t internal_next_signed(ra8_esp_hosted_fmt_args_t* args, ra8_esp_hosted_fmt_len_t len)
{
  if (len == k_ra8_esp_hosted_fmt_len_llong) {
    // NOLINTNEXTLINE(clang-analyzer-security.VAList) -- Clang 22 loses caller va_copy state.
    return (int64_t)va_arg(args->ap, long long);
  }
  if (len == k_ra8_esp_hosted_fmt_len_long) {
    // NOLINTNEXTLINE(clang-analyzer-security.VAList) -- Clang 22 loses caller va_copy state.
    return (int64_t)va_arg(args->ap, long);
  }
  if (len == k_ra8_esp_hosted_fmt_len_size) {
    return (int64_t)va_arg(args->ap, ptrdiff_t);
  }
  return (int64_t)va_arg(args->ap, int);
}

RA8_INTERNAL
static void internal_emit_token(ra8_esp_hosted_fmt_cursor_t*     cur,
                                const ra8_esp_hosted_fmt_spec_t* spec,
                                const char*                      token,
                                uint16_t                         token_len)
{
  const uint16_t pad_count = (spec->width > token_len) ? (uint16_t)(spec->width - token_len) : 0U;
  const char pad = (spec->zero_pad && !spec->left_justify) ? (char)k_ra8_esp_hosted_fmt_ch_zero
                                                           : (char)k_ra8_esp_hosted_fmt_ch_space;
 
  if (!spec->left_justify) {
    internal_pad(cur, pad, pad_count);
  }
  for (uint16_t i = 0U; i < token_len; i++) {
    internal_put(cur, token[i]);
  }
  if (spec->left_justify) {
    internal_pad(cur, (char)k_ra8_esp_hosted_fmt_ch_space, pad_count);
  }
}

RA8_INTERNAL
static uint16_t internal_bounded_len(const char* text)
{
  uint16_t len = 0U;
  for (uint16_t i = 0U; i < (uint16_t)k_ra8_esp_hosted_fmt_width_max; i++) {
    if (text[len] == (char)k_ra8_esp_hosted_fmt_ch_nul) {
      break;
    }
    len++;
  }
  return len;
}

RA8_INTERNAL
static void internal_emit_conv(ra8_esp_hosted_fmt_cursor_t*     cur,
                               const ra8_esp_hosted_fmt_spec_t* spec,
                               ra8_esp_hosted_fmt_args_t*       args)
{
  char digits[(uint32_t)k_ra8_esp_hosted_fmt_digits_max + 2U] = {};
 
  if (spec->conv == (char)k_ra8_esp_hosted_fmt_ch_percent) {
    internal_put(cur, (char)k_ra8_esp_hosted_fmt_ch_percent);
    return;
  }
  if (spec->conv == 'c') {
    // NOLINTNEXTLINE(clang-analyzer-security.VAList) -- Clang 22 loses caller va_copy state.
    digits[0] = (char)va_arg(args->ap, int);
    internal_emit_token(cur, spec, digits, 1U);
    return;
  }
  if (spec->conv == 's') {
    // NOLINTNEXTLINE(clang-analyzer-security.VAList) -- Clang 22 loses caller va_copy state.
    const char* text = va_arg(args->ap, const char*);
    const char* safe = (text == nullptr) ? "(null)" : text;
    internal_emit_token(cur, spec, safe, internal_bounded_len(safe));
    return;
  }
  if ((spec->conv == 'd') || (spec->conv == 'i')) {
    const int64_t  value     = internal_next_signed(args, spec->len);
    const bool     negative  = (value < 0);
    const uint64_t magnitude = negative ? (uint64_t)(-(value + 1)) + 1U : (uint64_t)value;
    uint8_t        used      = 0U;
    if (negative) {
      digits[0] = (char)k_ra8_esp_hosted_fmt_ch_minus;
      used      = 1U;
    }
    const uint8_t n = priv_ra8_esp_hosted_fmt_utoa(&digits[used],
                                                   magnitude,
                                                   (uint8_t)k_ra8_esp_hosted_fmt_radix_dec,
                                                   false);
    internal_emit_token(cur, spec, digits, (uint16_t)(used + n));
    return;
  }
 
  const bool    is_pointer = (spec->conv == 'p');
  const bool    upper      = (spec->conv == 'X');
  const uint8_t base       = ((spec->conv == 'u') ? (uint8_t)k_ra8_esp_hosted_fmt_radix_dec
                                                  : (uint8_t)k_ra8_esp_hosted_fmt_radix_hex);
  // NOLINTNEXTLINE(clang-analyzer-security.VAList) -- Clang 22 loses caller va_copy state.
  const uint64_t value = is_pointer ? (uint64_t)(uintptr_t)va_arg(args->ap, void*)
                                    : internal_next_unsigned(args, spec->len);
  const uint8_t  n     = priv_ra8_esp_hosted_fmt_utoa(digits, value, base, upper);
  internal_emit_token(cur, spec, digits, (uint16_t)n);
}

RA8_PRIV
uint32_t priv_ra8_esp_hosted_fmt_vformat(char* out, uint32_t cap, const char* fmt, va_list ap)
{
  if ((out == nullptr) || (cap == 0U) || (fmt == nullptr)) {
    if ((out != nullptr) && (cap != 0U)) {
      out[0] = (char)k_ra8_esp_hosted_fmt_ch_nul;
    }
    return 0U;
  }
 
  ra8_esp_hosted_fmt_cursor_t cur = {.out = out, .cap = cap, .len = 0U};
  ra8_esp_hosted_fmt_args_t   args;
  uint32_t                    pos = 0U;
 
  va_copy(args.ap, ap);
 
  for (uint32_t guard = 0U; guard < cap; guard++) {
    const char ch = fmt[pos];
    if (ch == (char)k_ra8_esp_hosted_fmt_ch_nul) {
      break;
    }
    pos++;
    if (ch != (char)k_ra8_esp_hosted_fmt_ch_percent) {
      internal_put(&cur, ch);
      continue;
    }
 
    ra8_esp_hosted_fmt_spec_t spec = {};
    if (!priv_ra8_esp_hosted_fmt_parse(&fmt[pos], &spec)) {
      internal_put(&cur, (char)k_ra8_esp_hosted_fmt_ch_percent);
      continue;
    }
    internal_emit_conv(&cur, &spec, &args);
    pos += spec.consumed;
  }
 
  // NOLINTNEXTLINE(clang-analyzer-security.VAList) -- Clang 22 loses local va_copy state.
  va_end(args.ap);
  cur.out[cur.len] = (char)k_ra8_esp_hosted_fmt_ch_nul;
  return cur.len;
}