xml_doctype.c

Go to the documentation of this file.

#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "xml_internal.h"

RA8_INTERNAL static bool internal_space(uint8_t byte)
{
  return (byte == (uint8_t)' ') || (byte == (uint8_t)'\t') || (byte == (uint8_t)'\n') ||
         (byte == (uint8_t)'\r');
}

RA8_INTERNAL static bool internal_skip_space(const uint8_t* source, size_t end, size_t* position)
{
  const size_t initial = *position;
  while ((*position < end) && internal_space(source[*position])) {
    ++*position;
  }
  return *position != initial;
}

RA8_INTERNAL static bool internal_pubid_byte(uint8_t byte)
{
  static const char punctuation[] = "-'()+,./:=?;!*#@$_%";
  return (byte == (uint8_t)' ') || (byte == (uint8_t)'\r') || (byte == (uint8_t)'\n') ||
         ((byte >= (uint8_t)'A') && (byte <= (uint8_t)'Z')) ||
         ((byte >= (uint8_t)'a') && (byte <= (uint8_t)'z')) ||
         ((byte >= (uint8_t)'0') && (byte <= (uint8_t)'9')) ||
         ((byte != 0U) && (strchr(punctuation, (int)byte) != nullptr));
}

RA8_INTERNAL static ra8_err_t
internal_literal(const uint8_t* source, size_t end, size_t* position, bool public_id)
{
  if ((*position >= end) ||
      ((source[*position] != (uint8_t)'\'') && (source[*position] != (uint8_t)'"'))) {
    return k_ra8_err_validation_failed;
  }
  const uint8_t quote = source[*position];
  *position += 1U;
  const size_t start = *position;
  while ((*position < end) && (source[*position] != quote)) {
    if (public_id && !internal_pubid_byte(source[*position])) {
      return k_ra8_err_validation_failed;
    }
    ++*position;
  }
  if (*position >= end) {
    return k_ra8_err_validation_failed;
  }
  const ra8_err_t err = public_id ? k_ra8_ok : priv_xml_raw(source, start, *position);
  ++*position;
  return err;
}

RA8_INTERNAL static ra8_err_t
internal_keyword(const uint8_t* source, size_t end, size_t* position, const char* keyword)
{
  const size_t length = strlen(keyword);
  // mcdc-deactivated: internal_keyword prefix recheck; the only caller, internal_external_id, has already proved `(*position + 6U) <= end` and matched the same six bytes before selecting the keyword, and both keywords are exactly six bytes long, so both conditions are constant-false on every reachable path.
  if (((*position + length) > end) || !priv_xml_bytes_equal(source, *position, keyword, length)) {
    return k_ra8_err_validation_failed;
  }
  *position += length;
  return internal_skip_space(source, end, position) ? k_ra8_ok : k_ra8_err_validation_failed;
}

RA8_INTERNAL static ra8_err_t
internal_external_id(const uint8_t* source, size_t end, size_t* position)
{
  if (((*position + 6U) <= end) && priv_xml_bytes_equal(source, *position, "SYSTEM", 6U)) {
    ra8_err_t err = internal_keyword(source, end, position, "SYSTEM");
    return (err == k_ra8_ok) ? internal_literal(source, end, position, false) : err;
  }
  if (((*position + 6U) <= end) && priv_xml_bytes_equal(source, *position, "PUBLIC", 6U)) {
    ra8_err_t err = internal_keyword(source, end, position, "PUBLIC");
    if (err == k_ra8_ok) {
      err = internal_literal(source, end, position, true);
    }
    if ((err == k_ra8_ok) && !internal_skip_space(source, end, position)) {
      err = k_ra8_err_validation_failed;
    }
    return (err == k_ra8_ok) ? internal_literal(source, end, position, false) : err;
  }
  return k_ra8_err_validation_failed;
}
 
ra8_err_t priv_xml_doctype(xml_reader_t* reader)
{
  static const char prefix[] = "<!DOCTYPE";
  const size_t      end      = reader->source_len;
  size_t            position = reader->position;
  if ((reader->root_count != 0U) || (reader->doctype_seen != 0U) ||
      ((position + sizeof(prefix) - 1U) > end) ||
      !priv_xml_bytes_equal(reader->source, position, prefix, sizeof(prefix) - 1U)) {
    return k_ra8_err_validation_failed;
  }
  position += sizeof(prefix) - 1U;
  if (!internal_skip_space(reader->source, end, &position)) {
    return k_ra8_err_validation_failed;
  }
  size_t name_end = 0U;
  if (priv_xml_qname(reader->source, end, position, &name_end) != k_ra8_ok) {
    return k_ra8_err_validation_failed;
  }
  position             = name_end;
  const bool separated = internal_skip_space(reader->source, end, &position);
  if ((position < end) && (reader->source[position] != (uint8_t)'>')) {
    if (!separated || (internal_external_id(reader->source, end, &position) != k_ra8_ok)) {
      return k_ra8_err_validation_failed;
    }
    (void)internal_skip_space(reader->source, end, &position);
  }
  if ((position >= end) || (reader->source[position] != (uint8_t)'>')) {
    return k_ra8_err_validation_failed;
  }
  reader->doctype_seen = 1U;
  reader->position     = position + 1U;
  return k_ra8_ok;
}