reflow_tokenize_attr.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_err.h"
#include "reflow.h"
#include "reflow_tokenize_internal.h"
 
/* ===========================================================================
 * Quoted-attribute scanning + value capture
 * ===========================================================================
 */

RA8_INTERNAL
static bool internal_attr_name_at(const uint8_t* tag, size_t i, const char* name, size_t name_len)
{
  for (size_t k = 0U; k < name_len; ++k) {
    if ((tag[i + k] | 0x20U) != (uint8_t)name[k]) {
      return false;
    }
  }
  const uint8_t prev = (i == 0U) ? (uint8_t)'<' : tag[i - 1U];
  return !(((prev >= (uint8_t)'a') && (prev <= (uint8_t)'z')) ||
           ((prev >= (uint8_t)'A') && (prev <= (uint8_t)'Z')));
}

RA8_INTERNAL
static bool internal_attr_quoted_value(const uint8_t* tag,
                                       size_t         tag_len,
                                       size_t         pos,
                                       size_t*        vstart,
                                       size_t*        vlen)
{
  size_t j = pos;
  while ((j < tag_len) && priv_reflow_tok_is_xml_whitespace((char)tag[j])) {
    ++j;
  }
  if ((j >= tag_len) || (tag[j] != (uint8_t)'=')) {
    return false;
  }
  ++j;
  while ((j < tag_len) && priv_reflow_tok_is_xml_whitespace((char)tag[j])) {
    ++j;
  }
  if ((j >= tag_len) || ((tag[j] != (uint8_t)'"') && (tag[j] != (uint8_t)'\''))) {
    return false;
  }
  const uint8_t quote = tag[j];
  ++j;
  *vstart = j;
  while ((j < tag_len) && (tag[j] != quote)) {
    ++j;
  }
  *vlen = j - *vstart;
  return true;
}

bool priv_reflow_tok_find_attr(const uint8_t* tag,
                               size_t         tag_len,
                               const char*    name,
                               size_t         name_len,
                               size_t*        out_voff,
                               size_t*        out_vlen)
{
  if (tag_len < name_len) {
    return false;
  }
  for (size_t i = 0U; (i + name_len) <= tag_len; ++i) {
    if (internal_attr_name_at(tag, i, name, name_len) &&
        internal_attr_quoted_value(tag, tag_len, i + name_len, out_voff, out_vlen)) {
      return true;
    }
  }
  return false;
}

void priv_reflow_tok_capture_attr(reflow_t*      engine,
                                  const uint8_t* tag,
                                  size_t         tag_len,
                                  const char*    name,
                                  size_t         name_len,
                                  uint32_t*      out_off,
                                  uint32_t*      out_len)
{
  *out_off      = 0U;
  *out_len      = 0U;
  size_t vstart = 0U;
  size_t vlen   = 0U;
  if (!priv_reflow_tok_find_attr(tag, tag_len, name, name_len, &vstart, &vlen)) {
    return;
  }
  if ((vlen == 0U) ||
      (((size_t)engine->text_pool_used + vlen) > (size_t)k_reflow_text_pool_bytes)) {
    return;
  }
  const uint32_t off = engine->text_pool_used;
  (void)memcpy(&engine->text_pool[off], &tag[vstart], vlen);
  engine->text_pool_used += (uint32_t)vlen;
  *out_off = off;
  *out_len = (uint32_t)vlen;
}

ra8_css_element_t
priv_reflow_tok_css_element(reflow_html_tag_t kind, const uint8_t* tag, size_t span)
{
  ra8_css_element_t el = {};
  el.tag               = (uint8_t)kind;
  size_t off           = 0U;
  size_t len           = 0U;
  if (priv_reflow_tok_find_attr(tag, span, "id", sizeof("id") - 1U, &off, &len)) {
    el.id     = (const char*)&tag[off];
    el.id_len = (uint16_t)len;
  }
  if (priv_reflow_tok_find_attr(tag, span, "class", sizeof("class") - 1U, &off, &len)) {
    el.class_str = (const char*)&tag[off];
    el.class_len = (uint16_t)len;
  }
  return el;
}

ra8_css_style_t priv_reflow_tok_css_inline(const uint8_t* tag, size_t span)
{
  ra8_css_style_t inl = {};
  size_t          off = 0U;
  size_t          len = 0U;
  if (priv_reflow_tok_find_attr(tag, span, "style", sizeof("style") - 1U, &off, &len)) {
    (void)ra8_css_parse_inline((const char*)&tag[off], (uint32_t)len, &inl);
  }
  return inl;
}
 
/* ===========================================================================
 * Link interning + stylesheet-rel detection + face resolution
 * ===========================================================================
 */

uint8_t priv_reflow_tok_intern_link(reflow_t* engine, uint32_t href_off, uint32_t href_len)
{
  if ((href_len == 0U) || (engine->link_target_count >= (uint32_t)k_reflow_max_links)) {
    return 0U;
  }
  const uint32_t idx                 = engine->link_target_count;
  engine->link_targets[idx].href_off = href_off;
  engine->link_targets[idx].href_len = href_len;
  engine->link_target_count          = idx + 1U;
  return (uint8_t)(idx + 1U); /* 1-based: 0 means "no link" */
}

bool priv_reflow_tok_rel_is_stylesheet(const uint8_t* rel, size_t len)
{
  static const char k_kw[] = "stylesheet";
  const size_t      k_klen = sizeof(k_kw) - 1U;
  for (size_t i = 0U; (i + k_klen) <= len; i++) {
    size_t j = 0U;
    for (; (j < k_klen) && (rel[i + j] == (uint8_t)k_kw[j]); j++) {
    }
    if (j == k_klen) {
      return true;
    }
  }
  return false;
}

uint8_t priv_reflow_tok_resolve_face_slot(const reflow_t* engine, const ra8_css_style_t* comp)
{
  if ((engine->face_count == 0U) || ((comp->set & (uint8_t)k_ra8_css_set_family) == 0U) ||
      (comp->family_len == 0U)) {
    return 0U;
  }
  const char*   family = (const char*)&engine->css.names[comp->family_off];
  const bool    bold   = (comp->style & (uint8_t)k_reflow_style_bold) != 0U;
  const bool    italic = (comp->style & (uint8_t)k_reflow_style_italic) != 0U;
  const int16_t ci     = ra8_css_match_face(&engine->css, family, comp->family_len, bold, italic);
  if (ci < 0) {
    return 0U;
  }
  for (uint8_t k = 0U; k < engine->face_count; ++k) {
    if (engine->faces[k].css_face_idx == (uint8_t)ci) {
      return (uint8_t)(k + 1U);
    }
  }
  return 0U;
}