reflow_svg.c

Go to the documentation of this file.

 
#include "reflow_svg.h"
 
#include <string.h>
 
#include "ra8_attributes.h"
#include "reflow_svg_internal.h"
 
/* ===========================================================================
 * Pure string / number helpers
 * ===========================================================================
 */

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

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

bool priv_ra8_svgp_starts_ci(const uint8_t* s, size_t len, size_t at, const char* lit)
{
  const size_t n = strlen(lit);
  if ((at + n) > len) {
    return false;
  }
  for (size_t k = 0U; k < n; ++k) {
    if (priv_ra8_svgp_lc((char)s[at + k]) != priv_ra8_svgp_lc(lit[k])) {
      return false;
    }
  }
  return true;
}

size_t priv_ra8_svgp_find_ci(const uint8_t* s, size_t len, size_t from, const char* lit)
{
  const size_t n = strlen(lit);
  if (n == 0U) {
    return len;
  }
  size_t i = from;
  /* Bounded: i advances by 1 each step, capped by len - n + 1. */
  while ((i + n) <= len) {
    if (priv_ra8_svgp_starts_ci(s, len, i, lit)) {
      return i;
    }
    ++i;
  }
  return len;
}

RA8_INTERNAL
static uint8_t internal_hex(char c)
{
  if ((c >= '0') && (c <= '9')) {
    const uint32_t code = (uint32_t)(uint8_t)c;
    return (uint8_t)(code - (uint32_t)(uint8_t)'0');
  }
  const char l = priv_ra8_svgp_lc(c);
  if ((l >= 'a') && (l <= 'f')) {
    const uint32_t code = (uint32_t)(uint8_t)l;
    return (uint8_t)((code - (uint32_t)(uint8_t)'a') + (uint32_t)k_svg_hex_a10);
  }
  return (uint8_t)k_svg_hex_base;
}

int32_t priv_ra8_svgp_num(const uint8_t* s, size_t len, size_t* i)
{
  while ((*i < len) && (priv_ra8_svgp_ws((char)s[*i]) || (s[*i] == (uint8_t)','))) {
    ++(*i);
  }
  int32_t sign = 1;
  if ((*i < len) && ((s[*i] == (uint8_t)'-') || (s[*i] == (uint8_t)'+'))) {
    sign = (s[*i] == (uint8_t)'-') ? INT32_C(-1) : INT32_C(1);
    ++(*i);
  }
  int32_t v = 0;
  while ((*i < len) && (s[*i] >= (uint8_t)'0') && (s[*i] <= (uint8_t)'9')) {
    v = (v * (int32_t)k_svg_dec) + ((int32_t)s[*i] - (int32_t)'0');
    ++(*i);
  }
  /* Skip a fractional part (truncated). */
  if ((*i < len) && (s[*i] == (uint8_t)'.')) {
    ++(*i);
    while ((*i < len) && (s[*i] >= (uint8_t)'0') && (s[*i] <= (uint8_t)'9')) {
      ++(*i);
    }
  }
  return v * sign;
}
 
/* ===========================================================================
 * Attribute + colour parsing
 * ===========================================================================
 */

RA8_INTERNAL
static bool internal_attr_at(const uint8_t* s, size_t len, size_t at, const char* name)
{
  const size_t n = strlen(name);
  if (!priv_ra8_svgp_starts_ci(s, len, at, name)) {
    return false;
  }
  if ((at > 0U) && !priv_ra8_svgp_ws((char)s[at - 1U])) {
    return false; /* must be preceded by whitespace */
  }
  const size_t after = at + n;
  if (after >= len) {
    return false;
  }
  return (s[after] == (uint8_t)'=') || priv_ra8_svgp_ws((char)s[after]);
}

bool priv_ra8_svgp_attr(const uint8_t* s, size_t len, const char* name, size_t* voff, size_t* vlen)
{
  /* Bounded: i advances by 1 each step, capped by len. */
  for (size_t i = 0U; i < len; ++i) {
    if (!internal_attr_at(s, len, i, name)) {
      continue;
    }
    size_t j = i + strlen(name);
    while ((j < len) && (s[j] != (uint8_t)'=')) {
      ++j;
    }
    ++j; /* past '=' */
    while ((j < len) && priv_ra8_svgp_ws((char)s[j])) {
      ++j;
    }
    if ((j >= len) || ((s[j] != (uint8_t)'"') && (s[j] != (uint8_t)'\''))) {
      return false;
    }
    const char q = (char)s[j];
    ++j;
    const size_t start = j;
    while ((j < len) && (s[j] != (uint8_t)q)) {
      ++j;
    }
    *voff = start;
    *vlen = j - start;
    return true;
  }
  return false;
}

int32_t priv_ra8_svgp_attr_num(const uint8_t* s, size_t len, const char* name, int32_t def)
{
  size_t off = 0U;
  size_t vl  = 0U;
  if (!priv_ra8_svgp_attr(s, len, name, &off, &vl)) {
    return def;
  }
  size_t k = 0U;
  return priv_ra8_svgp_num(&s[off], vl, &k);
}

RA8_INTERNAL
static bool internal_ci_eq(const uint8_t* s, size_t len, const char* lit)
{
  size_t k = 0U;
  for (; (k < len) && (lit[k] != '\0'); ++k) {
    if (priv_ra8_svgp_lc((char)s[k]) != priv_ra8_svgp_lc(lit[k])) {
      return false;
    }
  }
  return (k == len) && (lit[k] == '\0');
}

RA8_INTERNAL
static uint32_t internal_hex_color(const uint8_t* s, size_t len)
{
  uint32_t rgb = 0U;
  if (len == (size_t)k_svg_hex6) {
    for (size_t i = 0U; i < len; ++i) {
      const uint8_t v = internal_hex((char)s[i]);
      if (v >= (uint8_t)k_svg_hex_base) {
        return (uint32_t)k_svg_no_paint;
      }
      rgb = (rgb << (uint32_t)k_svg_hex_nib) | (uint32_t)v;
    }
    return rgb;
  }
  if (len == (size_t)k_svg_hex3) {
    for (size_t i = 0U; i < len; ++i) {
      const uint8_t v = internal_hex((char)s[i]);
      if (v >= (uint8_t)k_svg_hex_base) {
        return (uint32_t)k_svg_no_paint;
      }
      rgb =
        (rgb << (uint32_t)k_svg_hex_chan) | ((uint32_t)v << (uint32_t)k_svg_hex_nib) | (uint32_t)v;
    }
    return rgb;
  }
  return (uint32_t)k_svg_no_paint;
}

RA8_INTERNAL
static uint32_t internal_named_color(const uint8_t* s, size_t len)
{
  static const struct {
    const char* name; 
    uint32_t    rgb;  
  } k_names[] = {
    {"black", 0x000000U},
    {"white", 0xFFFFFFU},
    {"red", 0xFF0000U},
    {"green", 0x008000U},
    {"blue", 0x0000FFU},
    {"gray", 0x808080U},
    {"grey", 0x808080U},
    {"silver", 0xC0C0C0U},
    {"maroon", 0x800000U},
    {"navy", 0x000080U},
    {"yellow", 0xFFFF00U},
    {"orange", 0xFFA500U},
  };
  for (size_t k = 0U; k < (sizeof(k_names) / sizeof(k_names[0])); ++k) {
    if (internal_ci_eq(s, len, k_names[k].name)) {
      return k_names[k].rgb;
    }
  }
  return (uint32_t)k_svg_no_paint;
}

uint32_t priv_ra8_svgp_paint(const uint8_t* s, size_t len)
{
  if (len == 0U) {
    return (uint32_t)k_svg_no_paint;
  }
  if (s[0] == (uint8_t)'#') {
    return internal_hex_color(&s[1], len - 1U);
  }
  return internal_named_color(s, len);
}

uint32_t priv_ra8_svgp_attr_paint(const uint8_t* s, size_t len, const char* name, uint32_t def)
{
  size_t off = 0U;
  size_t vl  = 0U;
  if (!priv_ra8_svgp_attr(s, len, name, &off, &vl)) {
    return def;
  }
  return priv_ra8_svgp_paint(&s[off], vl);
}

int32_t priv_match_grad(const svg_grads_t* grads, const uint8_t* val, size_t vlen)
{
  if ((grads == nullptr) || !priv_ra8_svgp_starts_ci(val, vlen, 0U, "url(#")) {
    return -1;
  }
  const size_t idoff = strlen("url(#");
  size_t       idend = idoff;
  while ((idend < vlen) && (val[idend] != (uint8_t)')')) {
    ++idend;
  }
  const size_t idlen = idend - idoff;
  /* Bounded: <= grads->n (<= k_svg_grad_max) gradients. */
  for (int32_t i = 0; i < grads->n; ++i) {
    const char* gid   = grads->g[i].id;
    bool        equal = strlen(gid) == idlen;
    for (size_t k = 0U; (k < idlen) && equal; ++k) {
      equal = (uint8_t)gid[k] == val[idoff + k];
    }
    if (equal) {
      return i;
    }
  }
  return -1;
}

uint32_t priv_ra8_svgp_resolve_fill(const uint8_t*     s,
                                    size_t             len,
                                    const svg_xform_t* t,
                                    uint32_t           def,
                                    int32_t*           gi)
{
  *gi        = -1;
  size_t off = 0U;
  size_t vl  = 0U;
  if (!priv_ra8_svgp_attr(s, len, "fill", &off, &vl)) {
    return def;
  }
  if (priv_ra8_svgp_starts_ci(&s[off], vl, 0U, "url(#")) {
    *gi = priv_match_grad(t->grads, &s[off], vl);
    return (uint32_t)k_svg_no_paint;
  }
  return priv_ra8_svgp_paint(&s[off], vl);
}