reflow_css_rules.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "reflow.h" /* reflow_html_tag_t */
#include "reflow_css.h"
#include "reflow_css_internal.h"
#include "reflow_tokenize_internal.h" /* priv_reflow_tok_classify */
 
/* ===========================================================================
 * Internal constants (no magic numbers)
 * ===========================================================================
 */

typedef enum : uint8_t {
  k_priv_url_len = 4U, 
} priv_css_face_t;
 
/* ===========================================================================
 * Selector parsing
 * ===========================================================================
 */

RA8_INTERNAL
static bool internal_is_name_char(char c)
{
  return ((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')) || ((c >= '0') && (c <= '9')) ||
         (c == '-') || (c == '_');
}

RA8_INTERNAL
static bool internal_intern_name(ra8_css_sheet_t* sheet, const char* s, size_t len, uint16_t* off)
{
  /* mcdc-deactivated: every caller guards the length before interning -- (nlen == 0U) reject at the selector site, (n > 0U) at the @font-face/font-family sites, and internal_extract_url rejects an empty url() -- so (len == 0U) is unreachable; only (len > k_ra8_css_name_max) varies. */
  if ((len == 0U) || (len > (size_t)k_ra8_css_name_max)) {
    return false;
  }
  if (((size_t)sheet->names_used + len) > (size_t)k_ra8_css_name_pool) {
    return false;
  }
  *off = sheet->names_used;
  (void)memcpy(&sheet->names[sheet->names_used], s, len);
  sheet->names_used = (uint16_t)(sheet->names_used + len);
  return true;
}

RA8_INTERNAL
static bool internal_parse_sel_type(const char* s, size_t len, size_t* i, ra8_css_rule_t* rule)
{
  if (s[*i] == '*') {
    ++(*i); /* universal: no type constraint */
    return true;
  }
  size_t start = *i;
  /* Bounded: i advances over name chars, capped by len. */
  while ((*i < len) && internal_is_name_char(s[*i])) {
    ++(*i);
  }
  const reflow_html_tag_t tag = priv_reflow_tok_classify(&s[start], *i - start);
  if (tag == k_reflow_tag_unknown) {
    return false; /* unrecognised tag -> drop the rule */
  }
  rule->sel_tag = (uint8_t)tag;
  return true;
}

RA8_INTERNAL
static bool internal_parse_sel_part(ra8_css_sheet_t* sheet,
                                    const char*      s,
                                    size_t           len,
                                    size_t*          i,
                                    ra8_css_rule_t*  rule)
{
  const char kind = s[*i];
  ++(*i);
  const size_t start = *i;
  while ((*i < len) && internal_is_name_char(s[*i])) {
    ++(*i);
  }
  const size_t nlen = *i - start;
  uint16_t     off  = 0U;
  if ((nlen == 0U) || !internal_intern_name(sheet, &s[start], nlen, &off)) {
    return false;
  }
  if (kind == '.') {
    if (rule->class_len != 0U) {
      return false; /* a second class -> unsupported in v1 */
    }
    rule->class_off = off;
    rule->class_len = (uint16_t)nlen;
    return true;
  }
  if (rule->id_len != 0U) {
    return false; /* a second id */
  }
  rule->id_off = off;
  rule->id_len = (uint16_t)nlen;
  return true;
}

RA8_INTERNAL
static bool
internal_parse_selector(ra8_css_sheet_t* sheet, const char* s, size_t len, ra8_css_rule_t* rule)
{
  if (len == 0U) {
    return false;
  }
  size_t i   = 0U;
  bool   any = false;
  if (internal_is_name_char(s[0]) || (s[0] == '*')) {
    if (!internal_parse_sel_type(s, len, &i, rule)) {
      return false;
    }
    any = true;
  }
  /* Then a run of `.class` / `#id` parts (at most one of each). */
  while (i < len) {
    if (((s[i] != '.') && (s[i] != '#')) || !internal_parse_sel_part(sheet, s, len, &i, rule)) {
      return false; /* combinator / pseudo / dup / bad name -> unsupported */
    }
    any = true;
  }
  return any;
}

RA8_INTERNAL
static int32_t
internal_split_compounds(const char* s, size_t len, const char** part_p, size_t* part_n)
{
  size_t nparts = 0U;
  size_t i      = 0U;
  /* Bounded: i advances to len; each pass consumes >=1 char after the ws skip. */
  while (i < len) {
    /* mcdc-deactivated: internal_split_compounds is only ever called with a whitespace-trimmed selector (priv_reflow_css_trim in internal_parse_selector_list and the block dispatcher), so there is no trailing whitespace for this inner skip to consume up to len; the (i < len) false arm is unreachable on any public path. */
    while ((i < len) && priv_reflow_css_is_ws(s[i])) {
      ++i;
    }
    if (i >= len) {
      break;
    }
    if (nparts > (size_t)k_ra8_css_max_anc) {
      return -1; /* more than one subject + k_ra8_css_max_anc ancestor parts */
    }
    const size_t start = i;
    while ((i < len) && !priv_reflow_css_is_ws(s[i])) {
      ++i;
    }
    part_p[nparts] = &s[start];
    part_n[nparts] = i - start;
    ++nparts;
  }
  return (int32_t)nparts;
}

RA8_INTERNAL
static bool internal_parse_complex_selector(ra8_css_sheet_t* sheet,
                                            const char*      s,
                                            size_t           len,
                                            ra8_css_rule_t*  rule)
{
  const char*   part_p[(size_t)k_ra8_css_max_anc + 1U] = {};
  size_t        part_n[(size_t)k_ra8_css_max_anc + 1U] = {};
  const int32_t nparts = internal_split_compounds(s, len, part_p, part_n);
  if (nparts <= 0) {
    return false;
  }
  const size_t np = (size_t)nparts;
  /* Last part = subject compound. */
  if (!internal_parse_selector(sheet, part_p[np - 1U], part_n[np - 1U], rule)) {
    return false;
  }
  /* Earlier parts = ancestor constraints (outermost first). */
  rule->anc_count = (uint8_t)(np - 1U);
  for (size_t a = 0U; (a + 1U) < np; ++a) {
    ra8_css_rule_t tmp = {};
    if (!internal_parse_selector(sheet, part_p[a], part_n[a], &tmp)) {
      return false;
    }
    rule->anc[a].tag       = tmp.sel_tag;
    rule->anc[a].class_off = tmp.class_off;
    rule->anc[a].class_len = tmp.class_len;
    rule->anc[a].id_off    = tmp.id_off;
    rule->anc[a].id_len    = tmp.id_len;
  }
  return true;
}

RA8_INTERNAL
static void internal_push_rule(ra8_css_sheet_t* sheet, const ra8_css_rule_t* rule)
{
  if (sheet->rule_count >= (uint16_t)k_ra8_css_max_rules) {
    return;
  }
  sheet->rules[sheet->rule_count]       = *rule;
  sheet->rules[sheet->rule_count].order = sheet->next_order;
  sheet->rule_count                     = (uint16_t)(sheet->rule_count + 1U);
  sheet->next_order                     = (uint16_t)(sheet->next_order + 1U);
}

RA8_INTERNAL
static void internal_parse_selector_list(ra8_css_sheet_t* sheet,
                                         const char*      sel,
                                         size_t           sel_len,
                                         ra8_css_style_t  decl)
{
  size_t i = 0U;
  while (i < sel_len) {
    size_t comma = i;
    while ((comma < sel_len) && (sel[comma] != ',')) {
      ++comma;
    }
    size_t         one_len = comma - i;
    const char*    one     = priv_reflow_css_trim(&sel[i], &one_len);
    ra8_css_rule_t rule    = {};
    rule.decl              = decl;
    if (internal_parse_complex_selector(sheet, one, one_len, &rule)) {
      internal_push_rule(sheet, &rule);
    }
    i = comma + 1U;
  }
}
 
/* ===========================================================================
 * @font-face + font-family parsing + block dispatch
 * ===========================================================================
 */

RA8_INTERNAL
static const char* internal_strip_quotes(const char* s, size_t* len)
{
  if ((*len >= 2U) && ((s[0] == '"') || (s[0] == '\'')) && (s[*len - 1U] == s[0])) {
    *len -= 2U;
    return &s[1];
  }
  return s;
}

RA8_INTERNAL
static bool internal_extract_url(const char* val, size_t vlen, const char** url, size_t* ulen)
{
  /* Bounded: at most (vlen - 3) windows; i advances by 1 each step. */
  for (size_t i = 0U; (i + (size_t)k_priv_url_len) <= vlen; ++i) {
    if (!priv_reflow_css_ci_eq(&val[i], (size_t)k_priv_url_len, "url(")) {
      continue;
    }
    size_t a = i + (size_t)k_priv_url_len;
    size_t b = a;
    while ((b < vlen) && (val[b] != ')')) {
      ++b;
    }
    size_t      n = b - a;
    const char* p = priv_reflow_css_trim(&val[a], &n);
    p             = internal_strip_quotes(p, &n);
    if (n == 0U) {
      return false;
    }
    *url  = p;
    *ulen = n;
    return true;
  }
  return false;
}

RA8_INTERNAL
static bool internal_is_bold_kw(const char* val, size_t vlen)
{
  return 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");
}

RA8_INTERNAL
static bool internal_is_italic_kw(const char* val, size_t vlen)
{
  return priv_reflow_css_ci_eq(val, vlen, "italic") || priv_reflow_css_ci_eq(val, vlen, "oblique");
}

RA8_INTERNAL
static void internal_face_apply(ra8_css_sheet_t*    sheet,
                                const char*         prop,
                                size_t              plen,
                                const char*         val,
                                size_t              vlen,
                                ra8_css_fontface_t* face)
{
  if (priv_reflow_css_ci_eq(prop, plen, "font-family")) {
    size_t      n   = vlen;
    const char* fam = internal_strip_quotes(val, &n);
    uint16_t    off = 0U;
    if ((n > 0U) && internal_intern_name(sheet, fam, n, &off)) {
      face->family_off = off;
      face->family_len = (uint16_t)n;
    }
  } else if (priv_reflow_css_ci_eq(prop, plen, "font-weight")) {
    face->weight_bold = internal_is_bold_kw(val, vlen) ? 1U : 0U;
  } else if (priv_reflow_css_ci_eq(prop, plen, "font-style")) {
    face->style_italic = internal_is_italic_kw(val, vlen) ? 1U : 0U;
  } else if (priv_reflow_css_ci_eq(prop, plen, "src")) {
    const char* url  = nullptr;
    size_t      ulen = 0U;
    uint16_t    off  = 0U;
    if (internal_extract_url(val, vlen, &url, &ulen) &&
        internal_intern_name(sheet, url, ulen, &off)) {
      face->src_off = off;
      face->src_len = (uint16_t)ulen;
    }
  } else {
    /* Other @font-face descriptors (unicode-range, ...) -> ignored. */
  }
}

typedef void (
  *priv_decl_fn)(void* ctx, const char* prop, size_t plen, const char* val, size_t vlen);

RA8_INTERNAL
static void internal_for_each_decl(const char* s, size_t len, priv_decl_fn cb, void* ctx)
{
  size_t i = 0U;
  /* Bounded: each pass advances past the next ';' (or to len). */
  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)) {
        cb(ctx, prop, plen, val, vlen);
      }
    }
    i = semi + 1U;
  }
}

typedef struct {
  ra8_css_sheet_t*    sheet; 
  ra8_css_fontface_t* face;  
} priv_face_ctx_t;

RA8_INTERNAL
static void internal_face_cb(void* ctx, const char* prop, size_t plen, const char* val, size_t vlen)
{
  priv_face_ctx_t* c = (priv_face_ctx_t*)ctx;
  internal_face_apply(c->sheet, prop, plen, val, vlen, c->face);
}

RA8_INTERNAL
static void internal_parse_fontface(ra8_css_sheet_t* sheet, const char* block, size_t len)
{
  if (sheet->face_count >= (uint16_t)k_ra8_css_max_faces) {
    return;
  }
  ra8_css_fontface_t face = {};
  priv_face_ctx_t    ctx  = {.sheet = sheet, .face = &face};
  internal_for_each_decl(block, len, internal_face_cb, &ctx);
  if ((face.family_len != 0U) && (face.src_len != 0U)) {
    sheet->faces[sheet->face_count] = face;
    sheet->face_count               = (uint16_t)(sheet->face_count + 1U);
  }
}

typedef struct {
  ra8_css_sheet_t* sheet; 
  ra8_css_style_t* decl;  
} priv_family_ctx_t;

RA8_INTERNAL
static void
internal_family_cb(void* ctx, const char* prop, size_t plen, const char* val, size_t vlen)
{
  priv_family_ctx_t* c = (priv_family_ctx_t*)ctx;
  if (!priv_reflow_css_ci_eq(prop, plen, "font-family")) {
    return;
  }
  size_t      n   = vlen;
  const char* fam = internal_strip_quotes(val, &n);
  uint16_t    off = 0U;
  if ((n > 0U) && internal_intern_name(c->sheet, fam, n, &off)) {
    c->decl->set        = (uint8_t)(c->decl->set | (uint8_t)k_ra8_css_set_family);
    c->decl->family_off = off;
    c->decl->family_len = (uint16_t)n;
  }
}

RA8_INTERNAL
static void internal_extract_family(ra8_css_sheet_t* sheet,
                                    const char*      block,
                                    size_t           len,
                                    ra8_css_style_t* decl)
{
  priv_family_ctx_t ctx = {.sheet = sheet, .decl = decl};
  internal_for_each_decl(block, len, internal_family_cb, &ctx);
}

RA8_INTERNAL
static void internal_parse_at_rule(ra8_css_sheet_t* sheet,
                                   const char*      sel,
                                   size_t           sel_len,
                                   const char*      block,
                                   size_t           block_len)
{
  if (priv_reflow_css_ci_eq(sel, sel_len, "@font-face")) {
    internal_parse_fontface(sheet, block, block_len);
  }
  /* @media / @import / @page / ... are out of v1 scope -> skipped. */
}

void priv_reflow_css_parse_one_block(ra8_css_sheet_t* sheet,
                                     const char*      sel,
                                     size_t           sel_len,
                                     const char*      block,
                                     size_t           block_len)
{
  size_t      tlen = sel_len;
  const char* tsel = priv_reflow_css_trim(sel, &tlen);
  if ((tlen > 0U) && (tsel[0] == '@')) {
    internal_parse_at_rule(sheet, tsel, tlen, block, block_len);
    return;
  }
  ra8_css_style_t decl = {};
  priv_reflow_css_parse_decls(block, block_len, &decl);
  internal_extract_family(sheet, block, block_len, &decl);
  internal_parse_selector_list(sheet, sel, sel_len, decl);
}