reflow_css.c

Go to the documentation of this file.

 
#include "reflow_css.h"
 
#include <stddef.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "reflow.h" /* style/align enums, k_ra8_css_font_* units */
#include "reflow_css_internal.h"
 
/* ===========================================================================
 * Internal constants (no magic numbers)
 * ===========================================================================
 */

typedef enum : uint8_t {
  k_priv_hex_base = 16U, 
  k_priv_hex_a10  = 10U, 
  k_priv_hex3_len = 3U,  
  k_priv_hex6_len = 6U,  
  k_priv_hex_nib  = 4U,  
  k_priv_hex_chan = 8U,  
} priv_css_hex_t;

typedef enum : uint16_t {
  k_priv_fs_dec  = 10U,   
  k_priv_fs_pct1 = 100U,  
  k_priv_fs_frac = 2U,    
  k_priv_fs_max  = 9999U, 
  k_priv_fs_ulen = 2U,    
} priv_css_fs_t;

typedef enum : uint32_t {
  k_priv_col_black   = 0x000000U,   
  k_priv_col_white   = 0xFFFFFFU,   
  k_priv_col_red     = 0xFF0000U,   
  k_priv_col_green   = 0x008000U,   
  k_priv_col_blue    = 0x0000FFU,   
  k_priv_col_gray    = 0x808080U,   
  k_priv_col_silver  = 0xC0C0C0U,   
  k_priv_col_maroon  = 0x800000U,   
  k_priv_col_navy    = 0x000080U,   
  k_priv_col_invalid = 0xFFFFFFFFU, 
} priv_css_color_t;
 
/* ===========================================================================
 * Small pure string helpers
 * ===========================================================================
 */

bool priv_reflow_css_is_ws(char c)
{
  return (c == ' ') || (c == '\t') || (c == '\n') || (c == '\r') || (c == '\f');
}

char priv_reflow_css_lower(char c)
{
  return (char)(((c >= 'A') && (c <= 'Z')) ? (c + ('a' - 'A')) : c);
}

bool priv_reflow_css_ci_eq(const char* s, size_t len, const char* lit)
{
  if ((s == nullptr) || (lit == nullptr)) {
    return false;
  }
  size_t k = 0U;
  for (; (k < len) && (lit[k] != '\0'); ++k) {
    if (priv_reflow_css_lower(s[k]) != priv_reflow_css_lower(lit[k])) {
      return false;
    }
  }
  return (k == len) && (lit[k] == '\0');
}

RA8_INTERNAL
static bool internal_ci_contains(const char* s, size_t len, const char* sub)
{
  const size_t sl = strlen(sub);
  /* mcdc-deactivated: the sole caller passes internal_ci_contains(val, vlen, "underline") -- val is non-NULL (from priv_reflow_css_trim) and sub is a compile-time literal so sl == 9 (never 0); (s == nullptr) and (sl == 0U) are unreachable, only (sl > len) varies. */
  if ((s == nullptr) || (sl == 0U) || (sl > len)) {
    return false;
  }
  /* Bounded: at most (len - sl + 1) windows; i advances by 1 each step. */
  for (size_t i = 0U; (i + sl) <= len; ++i) {
    bool hit = true;
    /* Bounded: j < sl, the NUL-terminated literal's strlen. */
    for (size_t j = 0U; j < sl; ++j) {
      if (priv_reflow_css_lower(s[i + j]) != priv_reflow_css_lower(sub[j])) {
        hit = false;
        break;
      }
    }
    if (hit) {
      return true;
    }
  }
  return false;
}

const char* priv_reflow_css_trim(const char* s, size_t* len)
{
  size_t a = 0U;
  size_t b = *len;
  while ((a < b) && priv_reflow_css_is_ws(s[a])) {
    ++a;
  }
  while ((b > a) && priv_reflow_css_is_ws(s[b - 1U])) {
    --b;
  }
  *len = b - a;
  return &s[a];
}
 
/* ===========================================================================
 * Declaration-body parsing (colour / font-size / emphasis / align)
 * ===========================================================================
 */

RA8_INTERNAL
static uint8_t internal_hex_val(char c)
{
  if ((c >= '0') && (c <= '9')) {
    const int value = (int)c - (int)'0';
    return (uint8_t)value;
  }
  const char l = priv_reflow_css_lower(c);
  if ((l >= 'a') && (l <= 'f')) {
    const int value = ((int)l - (int)'a') + (int)k_priv_hex_a10;
    return (uint8_t)value;
  }
  return (uint8_t)k_priv_hex_base;
}

RA8_INTERNAL
static uint32_t internal_parse_hex_color(const char* s, size_t len)
{
  uint32_t rgb = 0U;
  if (len == (size_t)k_priv_hex6_len) {
    /* Bounded: exactly k_priv_hex6_len digits. */
    for (size_t i = 0U; i < len; ++i) {
      const uint8_t v = internal_hex_val(s[i]);
      if (v >= (uint8_t)k_priv_hex_base) {
        return (uint32_t)k_priv_col_invalid;
      }
      rgb = (rgb << (uint32_t)k_priv_hex_nib) | (uint32_t)v;
    }
    return rgb;
  }
  if (len == (size_t)k_priv_hex3_len) {
    /* Bounded: exactly k_priv_hex3_len digits; each expands d -> dd. */
    for (size_t i = 0U; i < len; ++i) {
      const uint8_t v = internal_hex_val(s[i]);
      if (v >= (uint8_t)k_priv_hex_base) {
        return (uint32_t)k_priv_col_invalid;
      }
      rgb = (rgb << (uint32_t)k_priv_hex_chan) | ((uint32_t)v << (uint32_t)k_priv_hex_nib) |
            (uint32_t)v;
    }
    return rgb;
  }
  return (uint32_t)k_priv_col_invalid;
}

RA8_INTERNAL
static uint32_t internal_parse_color(const char* s, size_t len)
{
  /* mcdc-deactivated: the sole caller internal_apply_decl passes val (non-NULL, from priv_reflow_css_trim) and vlen > 0 (gated by (plen > 0U) && (vlen > 0U) in priv_reflow_css_parse_decls); (s == nullptr) and (len == 0U) are unreachable on any public path. */
  if ((s == nullptr) || (len == 0U)) {
    return (uint32_t)k_priv_col_invalid;
  }
  if (s[0] == '#') {
    return internal_parse_hex_color(&s[1], len - 1U);
  }
  if (priv_reflow_css_ci_eq(s, len, "black")) {
    return (uint32_t)k_priv_col_black;
  }
  if (priv_reflow_css_ci_eq(s, len, "white")) {
    return (uint32_t)k_priv_col_white;
  }
  if (priv_reflow_css_ci_eq(s, len, "red")) {
    return (uint32_t)k_priv_col_red;
  }
  if (priv_reflow_css_ci_eq(s, len, "green")) {
    return (uint32_t)k_priv_col_green;
  }
  if (priv_reflow_css_ci_eq(s, len, "blue")) {
    return (uint32_t)k_priv_col_blue;
  }
  if (priv_reflow_css_ci_eq(s, len, "gray") || priv_reflow_css_ci_eq(s, len, "grey")) {
    return (uint32_t)k_priv_col_gray;
  }
  if (priv_reflow_css_ci_eq(s, len, "silver")) {
    return (uint32_t)k_priv_col_silver;
  }
  if (priv_reflow_css_ci_eq(s, len, "maroon")) {
    return (uint32_t)k_priv_col_maroon;
  }
  if (priv_reflow_css_ci_eq(s, len, "navy")) {
    return (uint32_t)k_priv_col_navy;
  }
  return (uint32_t)k_priv_col_invalid;
}

RA8_INTERNAL
static uint32_t internal_scan_hundredths(const char* s, size_t len, size_t* i, bool* any)
{
  uint32_t hund = 0U;
  /* Bounded: integer digits, i advances by 1 each step, capped by len. */
  while ((*i < len) && (s[*i] >= '0') && (s[*i] <= '9')) {
    const int digit = (int)s[*i] - (int)'0';
    hund            = (hund * (uint32_t)k_priv_fs_dec) + (uint32_t)digit;
    *any            = true;
    ++(*i);
  }
  hund *= (uint32_t)k_priv_fs_pct1; /* integer part -> hundredths */
  if ((*i < len) && (s[*i] == '.')) {
    ++(*i);
    uint32_t place = (uint32_t)k_priv_fs_pct1 / (uint32_t)k_priv_fs_dec; /* tenths */
    size_t   fd    = 0U;
    /* Bounded: at most k_priv_fs_frac fractional digits. */
    while ((*i < len) && (s[*i] >= '0') && (s[*i] <= '9') && (fd < (size_t)k_priv_fs_frac)) {
      const int digit = (int)s[*i] - (int)'0';
      hund += (uint32_t)digit * place;
      place /= (uint32_t)k_priv_fs_dec;
      *any = true;
      ++fd;
      ++(*i);
    }
    /* Bounded: skip any remaining fractional digits, i capped by len. */
    while ((*i < len) && (s[*i] >= '0') && (s[*i] <= '9')) {
      ++(*i);
    }
  }
  return hund;
}

RA8_INTERNAL
static uint16_t internal_fs_whole(uint32_t hund)
{
  const uint32_t whole = hund / (uint32_t)k_priv_fs_pct1;
  return (uint16_t)((whole > (uint32_t)k_priv_fs_max) ? (uint32_t)k_priv_fs_max : whole);
}

RA8_INTERNAL
static bool internal_parse_fontsize(const char* s, size_t len, uint16_t* out_val, uint8_t* out_unit)
{
  size_t   i    = 0U;
  bool     any  = false;
  uint32_t hund = internal_scan_hundredths(s, len, &i, &any);
  if (!any) {
    return false;
  }
  const size_t rem = len - i;
  if ((rem == (size_t)k_priv_fs_ulen) && priv_reflow_css_ci_eq(&s[i], rem, "px")) {
    *out_val  = internal_fs_whole(hund);
    *out_unit = (uint8_t)k_ra8_css_font_px;
    return true;
  }
  if ((rem == 1U) && (s[i] == '%')) {
    *out_val  = internal_fs_whole(hund);
    *out_unit = (uint8_t)k_ra8_css_font_pct;
    return true;
  }
  if ((rem == (size_t)k_priv_fs_ulen) && priv_reflow_css_ci_eq(&s[i], rem, "em")) {
    /* 1em = 100%; `hund` is value*100, which is already the percent. */
    *out_val  = (uint16_t)((hund > (uint32_t)k_priv_fs_max) ? (uint32_t)k_priv_fs_max : hund);
    *out_unit = (uint8_t)k_ra8_css_font_pct;
    return true;
  }
  return false;
}

RA8_INTERNAL
static void internal_set_emphasis(ra8_css_style_t* out, uint8_t setbit, uint8_t stylebit, bool on)
{
  out->set   = (uint8_t)(out->set | setbit);
  out->style = (uint8_t)(on ? (out->style | stylebit) : (out->style & (uint8_t)~stylebit));
}

RA8_INTERNAL
static bool internal_apply_emphasis(const char*      prop,
                                    size_t           plen,
                                    const char*      val,
                                    size_t           vlen,
                                    ra8_css_style_t* out)
{
  if (priv_reflow_css_ci_eq(prop, plen, "font-weight")) {
    const bool on =
      priv_reflow_css_ci_eq(val, vlen, "bold") || priv_reflow_css_ci_eq(val, vlen, "bolder") ||
      priv_reflow_css_ci_eq(val, vlen, "600") || priv_reflow_css_ci_eq(val, vlen, "700") ||
      priv_reflow_css_ci_eq(val, vlen, "800") || priv_reflow_css_ci_eq(val, vlen, "900");
    internal_set_emphasis(out, (uint8_t)k_ra8_css_set_bold, (uint8_t)k_reflow_style_bold, on);
    return true;
  }
  if (priv_reflow_css_ci_eq(prop, plen, "font-style")) {
    const bool on =
      priv_reflow_css_ci_eq(val, vlen, "italic") || priv_reflow_css_ci_eq(val, vlen, "oblique");
    internal_set_emphasis(out, (uint8_t)k_ra8_css_set_italic, (uint8_t)k_reflow_style_italic, on);
    return true;
  }
  if (priv_reflow_css_ci_eq(prop, plen, "text-decoration") ||
      priv_reflow_css_ci_eq(prop, plen, "text-decoration-line")) {
    const bool on = internal_ci_contains(val, vlen, "underline");
    internal_set_emphasis(out,
                          (uint8_t)k_ra8_css_set_underline,
                          (uint8_t)k_reflow_style_underline,
                          on);
    return true;
  }
  return false;
}

RA8_INTERNAL
static void internal_apply_align(const char* val, size_t vlen, ra8_css_style_t* out)
{
  out->set = (uint8_t)(out->set | (uint8_t)k_ra8_css_set_align);
  if (priv_reflow_css_ci_eq(val, vlen, "right")) {
    out->align = (uint8_t)k_reflow_align_right;
  } else if (priv_reflow_css_ci_eq(val, vlen, "center")) {
    out->align = (uint8_t)k_reflow_align_center;
  } else if (priv_reflow_css_ci_eq(val, vlen, "justify")) {
    out->align = (uint8_t)k_reflow_align_justify;
  } else {
    out->align = (uint8_t)k_reflow_align_left;
  }
}

RA8_INTERNAL
static void internal_apply_decl(const char*      prop,
                                size_t           plen,
                                const char*      val,
                                size_t           vlen,
                                ra8_css_style_t* out)
{
  if (internal_apply_emphasis(prop, plen, val, vlen, out)) {
    return;
  }
  if (priv_reflow_css_ci_eq(prop, plen, "text-align")) {
    internal_apply_align(val, vlen, out);
  } else if (priv_reflow_css_ci_eq(prop, plen, "color")) {
    const uint32_t rgb = internal_parse_color(val, vlen);
    if (rgb != (uint32_t)k_priv_col_invalid) {
      out->set   = (uint8_t)(out->set | (uint8_t)k_ra8_css_set_color);
      out->color = rgb;
    }
  } else if (priv_reflow_css_ci_eq(prop, plen, "font-size")) {
    uint16_t fv = 0U;
    uint8_t  fu = 0U;
    if (internal_parse_fontsize(val, vlen, &fv, &fu)) {
      out->set       = (uint8_t)(out->set | (uint8_t)k_ra8_css_set_fontsize);
      out->font_val  = fv;
      out->font_unit = fu;
    }
  } else if (priv_reflow_css_ci_eq(prop, plen, "display")) {
    out->set     = (uint8_t)(out->set | (uint8_t)k_ra8_css_set_display);
    out->display = priv_reflow_css_ci_eq(val, vlen, "none") ? 1U : 0U;
  } else {
    /* Unknown property -> ignore (no set bit). */
  }
}

void priv_reflow_css_parse_decls(const char* s, size_t len, ra8_css_style_t* out)
{
  size_t i = 0U;
  /* Bounded: each iteration consumes at least one byte via the ';' advance. */
  while (i < len) {
    size_t semi = i;
    while ((semi < len) && (s[semi] != ';')) {
      ++semi;
    }
    size_t colon = i;
    while ((colon < semi) && (s[colon] != ':')) {
      ++colon;
    }
    if (colon < semi) {
      size_t      plen = colon - i;
      const char* prop = priv_reflow_css_trim(&s[i], &plen);
      size_t      vlen = semi - (colon + 1U);
      const char* val  = priv_reflow_css_trim(&s[colon + 1U], &vlen);
      if ((plen > 0U) && (vlen > 0U)) {
        internal_apply_decl(prop, plen, val, vlen, out);
      }
    }
    i = semi + 1U;
  }
}
 
/* ===========================================================================
 * Public API -- inline declarations
 * ===========================================================================
 */
 
ra8_err_t ra8_css_parse_inline(const char* decls, uint32_t len, ra8_css_style_t* out)
{
  if ((decls == nullptr) || (out == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *out = (ra8_css_style_t){};
  priv_reflow_css_parse_decls(decls, (size_t)len, out);
  return k_ra8_ok;
}