mdl_extract_internal.h

Go to the documentation of this file.

#pragma once
 
#include <stddef.h>
#include <string.h>
 
#include "ra8_attributes.h"

RA8_INTERNAL static inline char internal_lc(char c)
{
  /* The conditional operator promotes both arms to int, so the cast belongs
   * on the whole expression; both arms are already char-valued. */
  return (char)(((c >= 'A') && (c <= 'Z')) ? (c + ('a' - 'A')) : c);
}

RA8_INTERNAL static inline bool internal_is_attr_boundary(char c)
{
  return (c == ' ') || (c == '\t') || (c == '\n') || (c == '\r') || (c == '"') || (c == '\'') ||
         (c == '<');
}

RA8_INTERNAL static inline bool internal_is_name_end(char c)
{
  return (c == ' ') || (c == '\t') || (c == '\n') || (c == '\r') || (c == '>') || (c == '/');
}

RA8_INTERNAL static inline const char*
internal_find_ci(const char* hay, size_t hay_len, const char* needle)
{
  const size_t nlen = strlen(needle);
  if ((nlen == 0U) || (hay_len < nlen)) {
    return nullptr;
  }
  for (size_t i = 0U; i + nlen <= hay_len; ++i) {
    size_t j = 0U;
    while ((j < nlen) && (internal_lc(hay[i + j]) == internal_lc(needle[j]))) {
      ++j;
    }
    if (j == nlen) {
      return hay + i;
    }
  }
  return nullptr;
}

RA8_INTERNAL static inline size_t internal_skip_ws(const char* tag, size_t tag_len, size_t k)
{
  while ((k < tag_len) && ((tag[k] == ' ') || (tag[k] == '\t'))) {
    ++k;
  }
  return k;
}

RA8_INTERNAL static inline bool
internal_read_eq_value(const char* tag, size_t tag_len, size_t k, char* out, size_t out_cap)
{
  k = internal_skip_ws(tag, tag_len, k);
  if (!((k < tag_len) && (tag[k] == '='))) {
    return false;
  }
  k = internal_skip_ws(tag, tag_len, k + 1U);
  if (!((k < tag_len) && ((tag[k] == '"') || (tag[k] == '\'')))) {
    return false;
  }
  const char quote = tag[k];
  ++k;
  size_t n = 0U;
  while ((k < tag_len) && (tag[k] != quote) && (n + 1U < out_cap)) {
    out[n] = tag[k];
    ++n;
    ++k;
  }
  if ((k < tag_len) && (tag[k] == quote)) {
    out[n] = '\0';
    return true;
  }
  return false;
}

RA8_INTERNAL static inline bool internal_find_attr_value(const char* tag,
                                                         size_t      tag_len,
                                                         const char* attr,
                                                         char*       out,
                                                         size_t      out_cap)
{
  const size_t alen = strlen(attr);
  size_t       pos  = 0U;
  while (pos + alen <= tag_len) {
    const char* hit = internal_find_ci(tag + pos, tag_len - pos, attr);
    if (hit == nullptr) {
      return false;
    }
    const size_t idx     = (size_t)(hit - tag);
    const bool   left_ok = (idx == 0U) || internal_is_attr_boundary(tag[idx - 1U]);
    if (left_ok && internal_read_eq_value(tag, tag_len, idx + alen, out, out_cap)) {
      return true;
    }
    pos = idx + alen;
  }
  return false;
}

RA8_INTERNAL static inline bool internal_contains_ok(const char* url, const char* needle)
{
  if ((needle == nullptr) || (needle[0] == '\0')) {
    return true;
  }
  return strstr(url, needle) != nullptr;
}

RA8_INTERNAL static inline bool internal_copy_fits(char* out, size_t out_cap, const char* src)
{
  const size_t n = strlen(src);
  if (n + 1U > out_cap) {
    return false;
  }
  memcpy(out, src, n + 1U);
  return true;
}