reflow_css_cascade.c

Go to the documentation of this file.

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

typedef enum : uint16_t {
  k_priv_rank_inherited = 0U,     
  k_priv_spec_type      = 1U,     
  k_priv_spec_class     = 100U,   
  k_priv_spec_id        = 10000U, 
} priv_css_consts_t;

typedef enum : uint8_t {
  k_priv_cmt_marker = 2U, 
} priv_css_scan_t;
 
/* ===========================================================================
 * Public API -- stylesheet scanner
 * ===========================================================================
 */
 
ra8_err_t ra8_css_sheet_reset(ra8_css_sheet_t* sheet)
{
  if (sheet == nullptr) {
    return k_ra8_err_null_ptr;
  }
  sheet->rule_count = 0U;
  sheet->face_count = 0U;
  sheet->next_order = 0U;
  sheet->names_used = 0U;
  return k_ra8_ok;
}

RA8_INTERNAL
static size_t internal_skip_comment(const char* css, size_t len, size_t start)
{
  const char open_a = '/';
  const char open_b = '*';
  size_t     j      = start + (size_t)k_priv_cmt_marker;
  /* Bounded: j strictly increases each pass; capped at len. */
  while (((j + 1U) < len) && !((css[j] == open_b) && (css[j + 1U] == open_a))) {
    ++j;
  }
  const size_t past = j + (size_t)k_priv_cmt_marker;
  return (past <= len) ? past : len;
}

RA8_INTERNAL
static bool
internal_find_block(const char* css, size_t len, size_t i, size_t* out_open, size_t* out_close)
{
  const char open_c  = '{';
  const char close_c = '}';
  size_t     brace   = i;
  /* Bounded: brace strictly increases each pass; capped at len. */
  while ((brace < len) && (css[brace] != open_c)) {
    ++brace;
  }
  if (brace >= len) {
    return false;
  }
  size_t close = brace + 1U;
  /* Bounded: close strictly increases each pass; capped at len. */
  while ((close < len) && (css[close] != close_c)) {
    ++close;
  }
  *out_open  = brace;
  *out_close = close;
  return true;
}
 
ra8_err_t ra8_css_parse(ra8_css_sheet_t* sheet, const char* css, uint32_t len)
{
  if ((sheet == nullptr) || (css == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  const char open_a = '/';
  const char open_b = '*';
  size_t     i      = 0U;
  /* Bounded: each iteration advances past a block or breaks at EOF. */
  while (i < (size_t)len) {
    if (((i + 1U) < (size_t)len) && (css[i] == open_a) && (css[i + 1U] == open_b)) {
      i = internal_skip_comment(css, (size_t)len, i);
      continue;
    }
    if (priv_reflow_css_is_ws(css[i])) {
      ++i;
      continue;
    }
    size_t brace = 0U;
    size_t close = 0U;
    if (!internal_find_block(css, (size_t)len, i, &brace, &close)) {
      break; /* no block -> done */
    }
    priv_reflow_css_parse_one_block(sheet,
                                    &css[i],
                                    brace - i,
                                    &css[brace + 1U],
                                    close - (brace + 1U));
    i = (close < (size_t)len) ? (close + 1U) : (size_t)len;
  }
  return k_ra8_ok;
}
 
/* ===========================================================================
 * Selector matching + cascade + face lookup
 * ===========================================================================
 */

RA8_INTERNAL
static bool
internal_class_list_has(const char* list, size_t list_len, const char* name, size_t nlen)
{
  size_t i = 0U;
  /* Bounded: each pass skips >=0 ws then a token, advancing i to list_len. */
  while (i < list_len) {
    while ((i < list_len) && priv_reflow_css_is_ws(list[i])) {
      ++i;
    }
    size_t start = i;
    while ((i < list_len) && !priv_reflow_css_is_ws(list[i])) {
      ++i;
    }
    const size_t tlen  = i - start;
    bool         equal = tlen == nlen;
    for (size_t j = 0U; equal && (j < nlen); ++j) {
      if (list[start + j] != name[j]) {
        equal = false;
      }
    }
    if (equal) {
      return true;
    }
  }
  return false;
}
 
bool ra8_css_rule_matches(const ra8_css_rule_t*    rule,
                          const ra8_css_element_t* el,
                          const ra8_css_sheet_t*   sheet)
{
  if ((rule == nullptr) || (el == nullptr) || (sheet == nullptr)) {
    return false;
  }
  /* Every present constraint must match (no constraint = universal). */
  if ((rule->sel_tag != (uint8_t)k_reflow_tag_unknown) && (el->tag != rule->sel_tag)) {
    return false;
  }
  if (rule->class_len != 0U) {
    const char* nm = (const char*)&sheet->names[rule->class_off];
    if ((el->class_str == nullptr) ||
        !internal_class_list_has(el->class_str, el->class_len, nm, rule->class_len)) {
      return false;
    }
  }
  if (rule->id_len != 0U) {
    const char* nm    = (const char*)&sheet->names[rule->id_off];
    bool        equal = (el->id != nullptr) && (el->id_len == rule->id_len);
    for (uint16_t i = 0U; equal && (i < rule->id_len); ++i) {
      if (el->id[i] != nm[i]) {
        equal = false;
      }
    }
    if (!equal) {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL
static bool internal_anc_matches(const ra8_css_anc_t*     anc,
                                 const ra8_css_element_t* el,
                                 const ra8_css_sheet_t*   sheet)
{
  if ((anc->tag != (uint8_t)k_reflow_tag_unknown) && (el->tag != anc->tag)) {
    return false;
  }
  if (anc->class_len != 0U) {
    const char* nm = (const char*)&sheet->names[anc->class_off];
    if ((el->class_str == nullptr) ||
        !internal_class_list_has(el->class_str, el->class_len, nm, anc->class_len)) {
      return false;
    }
  }
  if (anc->id_len != 0U) {
    const char* nm    = (const char*)&sheet->names[anc->id_off];
    bool        equal = (el->id != nullptr) && (el->id_len == anc->id_len);
    for (uint16_t i = 0U; equal && (i < anc->id_len); ++i) {
      if (el->id[i] != nm[i]) {
        equal = false;
      }
    }
    if (!equal) {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL
static bool internal_rule_matches_ctx(const ra8_css_rule_t*    rule,
                                      const ra8_css_element_t* el,
                                      const ra8_css_element_t* ancestors,
                                      uint8_t                  n_anc,
                                      const ra8_css_sheet_t*   sheet)
{
  if (!ra8_css_rule_matches(rule, el, sheet)) {
    return false;
  }
  if (rule->anc_count == 0U) {
    return true;
  }
  /* Greedy right-to-left: match each ancestor part (innermost first) walking up
   * the stack from the parent. The descendant combinator allows any depth. */
  int32_t ai = (int32_t)rule->anc_count - 1;
  int32_t si = (int32_t)n_anc - 1;
  /* Bounded: si strictly decreases each pass; ends when si < 0 or ai < 0. */
  while ((ai >= 0) && (si >= 0)) {
    if (internal_anc_matches(&rule->anc[ai], &ancestors[si], sheet)) {
      --ai;
    }
    --si;
  }
  return ai < 0;
}

RA8_INTERNAL
static uint16_t internal_rule_rank(const ra8_css_rule_t* rule)
{
  uint16_t spec = 0U;
  if (rule->sel_tag != (uint8_t)k_reflow_tag_unknown) {
    spec = (uint16_t)(spec + (uint16_t)k_priv_spec_type);
  }
  if (rule->class_len != 0U) {
    spec = (uint16_t)(spec + (uint16_t)k_priv_spec_class);
  }
  if (rule->id_len != 0U) {
    spec = (uint16_t)(spec + (uint16_t)k_priv_spec_id);
  }
  /* Each descendant ancestor part adds to specificity per CSS. */
  for (uint8_t a = 0U; a < rule->anc_count; ++a) {
    if (rule->anc[a].tag != (uint8_t)k_reflow_tag_unknown) {
      spec = (uint16_t)(spec + (uint16_t)k_priv_spec_type);
    }
    if (rule->anc[a].class_len != 0U) {
      spec = (uint16_t)(spec + (uint16_t)k_priv_spec_class);
    }
    if (rule->anc[a].id_len != 0U) {
      spec = (uint16_t)(spec + (uint16_t)k_priv_spec_id);
    }
  }
  return spec;
}

RA8_INTERNAL
static const ra8_css_style_t* internal_resolve(uint8_t                setbit,
                                               const ra8_css_style_t* inherited,
                                               const ra8_css_sheet_t* sheet,
                                               const bool*            matched,
                                               const ra8_css_style_t* inl)
{
  const ra8_css_style_t* win        = nullptr;
  uint16_t               best_rank  = 0U;
  uint16_t               best_order = 0U;
  bool                   have       = false;
  if ((inherited->set & setbit) != 0U) {
    win       = inherited;
    best_rank = (uint16_t)k_priv_rank_inherited;
    have      = true;
  }
  /* Bounded: rule_count <= k_ra8_css_max_rules; i advances by 1 each step. */
  for (uint16_t i = 0U; i < sheet->rule_count; ++i) {
    if (!matched[i] || ((sheet->rules[i].decl.set & setbit) == 0U)) {
      continue;
    }
    const uint16_t rank = internal_rule_rank(&sheet->rules[i]);
    /* mcdc-deactivated: rules[].order is assigned monotonically in source order (internal_push_rule increments next_order) and this loop scans rules in that same order, so a later same-rank rule always has order > best_order; (order >= best_order) is invariantly true and its false arm is unreachable. */
    if ((!have) || (rank > best_rank) ||
        ((rank == best_rank) && (sheet->rules[i].order >= best_order))) {
      win        = &sheet->rules[i].decl;
      best_rank  = rank;
      best_order = sheet->rules[i].order;
      have       = true;
    }
  }
  if ((inl->set & setbit) != 0U) {
    win = inl;
  }
  return win;
}

RA8_INTERNAL
static void internal_cascade_emphasis(ra8_css_style_t*       out,
                                      const ra8_css_sheet_t* sheet,
                                      const bool*            matched,
                                      const ra8_css_style_t* inherited,
                                      const ra8_css_style_t* inl)
{
  static const struct {
    uint8_t setbit;   
    uint8_t stylebit; 
  } k_props[3] = {
    {(uint8_t)k_ra8_css_set_bold, (uint8_t)k_reflow_style_bold},
    {(uint8_t)k_ra8_css_set_italic, (uint8_t)k_reflow_style_italic},
    {(uint8_t)k_ra8_css_set_underline, (uint8_t)k_reflow_style_underline},
  };
  for (size_t p = 0U; p < (sizeof(k_props) / sizeof(k_props[0])); ++p) {
    const ra8_css_style_t* win =
      internal_resolve(k_props[p].setbit, inherited, sheet, matched, inl);
    if (win != nullptr) {
      out->set = (uint8_t)(out->set | k_props[p].setbit);
      if ((win->style & k_props[p].stylebit) != 0U) {
        out->style = (uint8_t)(out->style | k_props[p].stylebit);
      }
    }
  }
}

RA8_INTERNAL
static void internal_cascade_scalars(ra8_css_style_t*       out,
                                     const ra8_css_sheet_t* sheet,
                                     const bool*            matched,
                                     const ra8_css_style_t* inherited,
                                     const ra8_css_style_t* inl)
{
  const ra8_css_style_t* awin =
    internal_resolve((uint8_t)k_ra8_css_set_align, inherited, sheet, matched, inl);
  if (awin != nullptr) {
    out->set   = (uint8_t)(out->set | (uint8_t)k_ra8_css_set_align);
    out->align = awin->align;
  }
  const ra8_css_style_t* cwin =
    internal_resolve((uint8_t)k_ra8_css_set_color, inherited, sheet, matched, inl);
  if (cwin != nullptr) {
    out->set   = (uint8_t)(out->set | (uint8_t)k_ra8_css_set_color);
    out->color = cwin->color;
  }
  /* font-size + display resolve from rules + inline only -- not inherited via
   * this pure pass (a `%` is applied by the caller against the parent's resolved
   * px, so seeding `inherited` would double-apply it). */
  const ra8_css_style_t* fwin =
    internal_resolve((uint8_t)k_ra8_css_set_fontsize, inherited, sheet, matched, inl);
  if (fwin != nullptr) {
    out->set       = (uint8_t)(out->set | (uint8_t)k_ra8_css_set_fontsize);
    out->font_val  = fwin->font_val;
    out->font_unit = fwin->font_unit;
  }
  const ra8_css_style_t* dwin =
    internal_resolve((uint8_t)k_ra8_css_set_display, inherited, sheet, matched, inl);
  if (dwin != nullptr) {
    out->set     = (uint8_t)(out->set | (uint8_t)k_ra8_css_set_display);
    out->display = dwin->display;
  }
}

RA8_INTERNAL
static void internal_cascade_family(ra8_css_style_t*       out,
                                    const ra8_css_sheet_t* sheet,
                                    const bool*            matched,
                                    const ra8_css_style_t* inherited,
                                    const ra8_css_style_t* inl)
{
  const ra8_css_style_t* win =
    internal_resolve((uint8_t)k_ra8_css_set_family, inherited, sheet, matched, inl);
  if (win != nullptr) {
    out->set        = (uint8_t)(out->set | (uint8_t)k_ra8_css_set_family);
    out->family_off = win->family_off;
    out->family_len = win->family_len;
  }
}
 
ra8_css_style_t ra8_css_cascade_ctx(const ra8_css_sheet_t*   sheet,
                                    const ra8_css_element_t* el,
                                    ra8_css_style_t          inherited,
                                    ra8_css_style_t          inline_decl,
                                    const ra8_css_element_t* ancestors,
                                    uint8_t                  n_anc)
{
  if ((sheet == nullptr) || (el == nullptr)) {
    return inherited;
  }
  bool matched[k_ra8_css_max_rules] = {};
  /* Bounded: rule_count <= k_ra8_css_max_rules; i advances by 1 each step. */
  for (uint16_t i = 0U; i < sheet->rule_count; ++i) {
    matched[i] = internal_rule_matches_ctx(&sheet->rules[i], el, ancestors, n_anc, sheet);
  }
  ra8_css_style_t out = {};
  internal_cascade_emphasis(&out, sheet, matched, &inherited, &inline_decl);
  internal_cascade_scalars(&out, sheet, matched, &inherited, &inline_decl);
  internal_cascade_family(&out, sheet, matched, &inherited, &inline_decl);
  return out;
}
 
ra8_css_style_t ra8_css_cascade(const ra8_css_sheet_t*   sheet,
                                const ra8_css_element_t* el,
                                ra8_css_style_t          inherited,
                                ra8_css_style_t          inline_decl)
{
  return ra8_css_cascade_ctx(sheet, el, inherited, inline_decl, nullptr, 0U);
}

RA8_INTERNAL
static bool internal_ci_eq_span(const char* a, size_t alen, const char* b, size_t blen)
{
  /* mcdc-deactivated: internal_ci_eq_span is reached only via internal_family_eq from ra8_css_match_face, which rejects a NULL sheet and a NULL family at its entry, so both name pointers are non-NULL here; (a == nullptr) and (b == nullptr) are unreachable, only (alen != blen) varies. */
  if ((a == nullptr) || (b == nullptr) || (alen != blen)) {
    return false;
  }
  /* Bounded: k < alen (== blen); one byte folded per step. */
  for (size_t k = 0U; k < alen; ++k) {
    if (priv_reflow_css_lower(a[k]) != priv_reflow_css_lower(b[k])) {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL
static bool internal_family_eq(const ra8_css_sheet_t*    sheet,
                               const ra8_css_fontface_t* f,
                               const char*               family,
                               size_t                    family_len)
{
  return internal_ci_eq_span((const char*)&sheet->names[f->family_off],
                             (size_t)f->family_len,
                             family,
                             family_len);
}
 
int16_t ra8_css_match_face(const ra8_css_sheet_t* sheet,
                           const char*            family,
                           uint16_t               family_len,
                           bool                   want_bold,
                           bool                   want_italic)
{
  if ((sheet == nullptr) || (family == nullptr) || (family_len == 0U)) {
    return (int16_t)k_ra8_css_no_face;
  }
  int16_t fallback = (int16_t)k_ra8_css_no_face;
  /* Bounded: face_count <= k_ra8_css_max_faces; i advances by 1 each step. */
  for (uint16_t i = 0U; i < sheet->face_count; ++i) {
    const ra8_css_fontface_t* f = &sheet->faces[i];
    if (!internal_family_eq(sheet, f, family, (size_t)family_len)) {
      continue;
    }
    const bool face_bold   = f->weight_bold != 0U;
    const bool face_italic = f->style_italic != 0U;
    if ((face_bold == want_bold) && (face_italic == want_italic)) {
      return (int16_t)i;
    }
    if ((f->weight_bold == 0U) && (f->style_italic == 0U) && (fallback < 0)) {
      fallback = (int16_t)i;
    }
  }
  return fallback;
}
 
bool ra8_css_face_src(const ra8_css_sheet_t* sheet,
                      uint16_t               idx,
                      const char**           out_src,
                      uint16_t*              out_len)
{
  if ((sheet == nullptr) || (out_src == nullptr) || (out_len == nullptr) ||
      (idx >= sheet->face_count)) {
    return false;
  }
  *out_src = (const char*)&sheet->names[sheet->faces[idx].src_off];
  *out_len = sheet->faces[idx].src_len;
  return true;
}