ra8_rabook_xml_shim.c

Go to the documentation of this file.

#include "ra8_rabook_xml_shim.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#ifdef UNIT_TEST
#include "ra8_rabook_xml_shim_test_internal.h"
#endif

typedef struct {
  uint32_t offset; 
  uint16_t depth;  
} priv_selection_t;

RA8_INTERNAL static uint32_t internal_intern_span(ra8_rabook_ctx_t* ctx,
                                                  const uint8_t*    source,
                                                  size_t            source_len,
                                                  xml_span_t        span)
{
  if (ctx->failed) {
    return (uint32_t)k_book_nil;
  }
  size_t decoded = 0U;
  if (xml_decoded_size(source, source_len, span, &decoded) != k_ra8_ok) {
    ctx->failed = true;
    return (uint32_t)k_book_nil;
  }
  if ((decoded + 1U) > (size_t)(ctx->buf.string_cap - ctx->string_size)) {
    ctx->failed = true;
    return (uint32_t)k_book_nil;
  }
  char* const scratch = &ctx->buf.string_pool[ctx->string_size];
  size_t      written = 0U;
  if (xml_decode(source,
                 source_len,
                 span,
                 scratch,
                 (size_t)(ctx->buf.string_cap - ctx->string_size),
                 &written) != k_ra8_ok) {
    ctx->failed = true;
    return (uint32_t)k_book_nil;
  }
  uint32_t scan = 0U;
  while (scan < ctx->string_size) {
    const char*  candidate = &ctx->buf.string_pool[scan];
    const size_t length    = strlen(candidate);
    if (length == written) {
      size_t equal_bytes = 0U;
      while ((equal_bytes < written) && (candidate[equal_bytes] == scratch[equal_bytes])) {
        equal_bytes++;
      }
      if (equal_bytes == written) {
        return scan;
      }
    }
    scan += (uint32_t)length + 1U;
  }
  const uint32_t result = ctx->string_size;
  ctx->string_size += (uint32_t)written + 1U;
  return result;
}

RA8_INTERNAL static ra8_err_t internal_attributes(const uint8_t*              source,
                                                  size_t                      source_len,
                                                  const xml_event_t*          event,
                                                  ra8_rabook_ctx_t*           ctx,
                                                  ra8_rabook_xml_workspace_t* workspace)
{
  if (event->attribute_count > (uint16_t)k_ra8_rabook_xml_max_attributes) {
    ctx->failed = true;
    return k_ra8_err_no_mem;
  }
  xml_attr_cursor_t cursor = {};
  xml_attr_begin(event, &cursor);
  for (uint16_t i = 0U; i < event->attribute_count; ++i) {
    xml_attribute_t attribute = {};
    bool            has_value = false;
    const ra8_err_t attr_err =
      xml_attr_next(source, source_len, event, &cursor, &attribute, &has_value);
    if (attr_err != k_ra8_ok) {
      return k_ra8_err_validation_failed;
    }
    if (!has_value) {
      return k_ra8_err_validation_failed;
    }
    workspace->attributes[i].name_off =
      internal_intern_span(ctx, source, source_len, attribute.name);
    workspace->attributes[i].value_off =
      internal_intern_span(ctx, source, source_len, attribute.value);
    if (ctx->failed) {
      return k_ra8_err_no_mem;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_link(ra8_rabook_ctx_t*           ctx,
                                            ra8_rabook_xml_workspace_t* workspace,
                                            uint16_t                    parent_level,
                                            uint32_t                    next_sibling)
{
  const uint32_t  previous_node = workspace->last_children[parent_level];
  const ra8_err_t err =
    (previous_node == (uint32_t)k_book_nil)
      ? ra8_rabook_link_child(ctx, workspace->element_nodes[parent_level], next_sibling)
      : ra8_rabook_link_sibling(ctx, previous_node, next_sibling);
  if (err == k_ra8_ok) {
    workspace->last_children[parent_level] = next_sibling;
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_element(const uint8_t*              source,
                                               size_t                      source_len,
                                               const xml_event_t*          event,
                                               uint16_t                    selected_depth,
                                               ra8_rabook_ctx_t*           ctx,
                                               ra8_rabook_xml_workspace_t* workspace,
                                               uint32_t*                   out_node)
{
  const ra8_err_t attr_err = internal_attributes(source, source_len, event, ctx, workspace);
  if (attr_err != k_ra8_ok) {
    return attr_err;
  }
  const uint32_t name = internal_intern_span(ctx, source, source_len, event->name);
  const uint32_t node =
    ra8_rabook_add_element(ctx, name, workspace->attributes, event->attribute_count);
  if (node == (uint32_t)k_book_nil) {
    return k_ra8_err_no_mem;
  }
  const uint16_t level = (uint16_t)(event->depth - selected_depth);
  if (level > 0U) {
    if (internal_link(ctx, workspace, (uint16_t)(level - 1U), node) != k_ra8_ok) {
      return k_ra8_err_no_mem;
    }
  }
  workspace->element_nodes[level] = node;
  workspace->last_children[level] = (uint32_t)k_book_nil;
  *out_node                       = node;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_text(const uint8_t*              source,
                                            size_t                      source_len,
                                            const xml_event_t*          event,
                                            uint16_t                    selected_depth,
                                            ra8_rabook_ctx_t*           ctx,
                                            ra8_rabook_xml_workspace_t* workspace)
{
  size_t decoded = 0U;
  if (xml_decoded_size(source, source_len, event->markup, &decoded) != k_ra8_ok) {
    return k_ra8_err_validation_failed;
  }
  if (decoded == 0U) {
    return k_ra8_ok;
  }
  const uint32_t text = internal_intern_span(ctx, source, source_len, event->markup);
  const uint32_t node = ra8_rabook_add_text(ctx, text);
  if (node == (uint32_t)k_book_nil) {
    return k_ra8_err_no_mem;
  }
  const uint16_t parent_level = (uint16_t)(event->depth - selected_depth - 1U);
  return (internal_link(ctx, workspace, parent_level, node) == k_ra8_ok) ? k_ra8_ok
                                                                         : k_ra8_err_no_mem;
}

RA8_INTERNAL static ra8_err_t internal_select_event(const uint8_t*     source,
                                                    size_t             length,
                                                    const xml_event_t* event,
                                                    uint16_t*          root_depth,
                                                    bool*              saw_root,
                                                    uint16_t*          direct_children,
                                                    priv_selection_t*  out,
                                                    bool*              out_done)
{
  if (!*saw_root) {
    if (event->kind == (uint8_t)k_xml_event_start) {
      *saw_root   = true;
      *root_depth = event->depth;
      *out        = (priv_selection_t){event->markup.offset, event->depth};
    }
    return k_ra8_ok;
  }
  if (event->kind != (uint8_t)k_xml_event_start) {
    return k_ra8_ok;
  }
  if (event->depth != (uint16_t)(*root_depth + 1U)) {
    return k_ra8_ok;
  }
  if (*direct_children >= (uint16_t)k_ra8_rabook_xml_body_siblings) {
    return k_ra8_err_validation_failed;
  }
  if (xml_span_equal(source, length, event->name, "body")) {
    *out      = (priv_selection_t){event->markup.offset, event->depth};
    *out_done = true;
    return k_ra8_ok;
  }
  ++*direct_children;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_select(const uint8_t* source, size_t length, xml_workspace_t* xml, priv_selection_t* out)
{
  xml_reader_t reader          = {};
  ra8_err_t    err             = xml_reader_init(&reader, source, length, xml);
  uint16_t     root_depth      = 0U;
  uint16_t     direct_children = 0U;
  bool         saw_root        = false;
  bool         done            = false;
  while ((err == k_ra8_ok) && !done) {
    xml_event_t event = {};
    err               = xml_reader_next(&reader, &event);
    if (err == k_ra8_ok) {
      if (event.kind == (uint8_t)k_xml_event_none) {
        break;
      }
      err = internal_select_event(source,
                                  length,
                                  &event,
                                  &root_depth,
                                  &saw_root,
                                  &direct_children,
                                  out,
                                  &done);
    }
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_emit_start(const uint8_t*              source,
                                                  size_t                      length,
                                                  const priv_selection_t*     selection,
                                                  const xml_event_t*          event,
                                                  ra8_rabook_ctx_t*           ctx,
                                                  ra8_rabook_xml_workspace_t* workspace,
                                                  bool*                       active,
                                                  uint32_t*                   out_root)
{
  uint32_t        node = (uint32_t)k_book_nil;
  const ra8_err_t err =
    internal_element(source, length, event, selection->depth, ctx, workspace, &node);
  if (event->markup.offset == selection->offset) {
    *out_root = node;
  }
  if (err != k_ra8_ok) {
    return err;
  }
  if (event->self_closing == 0U) {
    return err;
  }
  if (event->markup.offset != selection->offset) {
    return err;
  }
  *active = false;
  return err;
}

RA8_INTERNAL static ra8_err_t internal_emit_event(const uint8_t*              source,
                                                  size_t                      length,
                                                  const priv_selection_t*     selection,
                                                  const xml_event_t*          event,
                                                  ra8_rabook_ctx_t*           ctx,
                                                  ra8_rabook_xml_workspace_t* workspace,
                                                  bool*                       active,
                                                  uint32_t*                   out_root)
{
  if (!*active) {
    if (event->kind != (uint8_t)k_xml_event_start) {
      return k_ra8_ok;
    }
    if (event->markup.offset != selection->offset) {
      return k_ra8_ok;
    }
    *active = true;
  }
  if (event->kind == (uint8_t)k_xml_event_start) {
    return internal_emit_start(source, length, selection, event, ctx, workspace, active, out_root);
  }
  if (event->kind == (uint8_t)k_xml_event_text) {
    return internal_text(source, length, event, selection->depth, ctx, workspace);
  }
  if (event->kind == (uint8_t)k_xml_event_end) {
    if (event->depth == selection->depth) {
      *active = false;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_emit(const uint8_t*              source,
                                            size_t                      length,
                                            const priv_selection_t*     selection,
                                            ra8_rabook_ctx_t*           ctx,
                                            ra8_rabook_xml_workspace_t* workspace,
                                            uint32_t*                   out_root)
{
  xml_reader_t reader = {};
  ra8_err_t    err    = xml_reader_init(&reader, source, length, &workspace->xml);
  bool         active = false;
  while (err == k_ra8_ok) {
    xml_event_t event = {};
    err               = xml_reader_next(&reader, &event);
    if (err == k_ra8_ok) {
      if (event.kind == (uint8_t)k_xml_event_none) {
        break;
      }
      err =
        internal_emit_event(source, length, selection, &event, ctx, workspace, &active, out_root);
    }
  }
  return err;
}
 
#ifdef UNIT_TEST
RA8_TEST_HELPER
ra8_err_t priv_ra8_rabook_xml_select_unvalidated_test(const uint8_t*              source,
                                                      size_t                      source_len,
                                                      ra8_rabook_xml_workspace_t* workspace)
{
  priv_selection_t selection = {};
  return internal_select(source, source_len, &workspace->xml, &selection);
}
 
RA8_TEST_HELPER ra8_err_t
priv_ra8_rabook_xml_emit_unvalidated_test(const uint8_t*              source,
                                          size_t                      source_len,
                                          ra8_rabook_ctx_t*           ctx,
                                          ra8_rabook_xml_workspace_t* workspace)
{
  const priv_selection_t selection = {.offset = 0U, .depth = 0U};
  uint32_t               root      = (uint32_t)k_book_nil;
  return internal_emit(source, source_len, &selection, ctx, workspace, &root);
}
#endif

RA8_INTERNAL static ra8_err_t
internal_parse_chapter_validate_args(const uint8_t*                    xhtml_bytes,
                                     size_t                            xhtml_len,
                                     const ra8_rabook_ctx_t*           ctx,
                                     const char*                       chapter_href,
                                     const char*                       chapter_title,
                                     const ra8_rabook_xml_workspace_t* workspace)
{
  if (xhtml_bytes == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (ctx == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (chapter_href == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (chapter_title == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (workspace == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (xhtml_len == 0U) {
    return k_ra8_err_invalid_size;
  }
  return k_ra8_ok;
}
 
ra8_err_t ra8_rabook_xml_parse_chapter(const uint8_t*              xhtml_bytes,
                                       size_t                      xhtml_len,
                                       ra8_rabook_ctx_t*           ctx,
                                       const char*                 chapter_href,
                                       const char*                 chapter_title,
                                       ra8_rabook_xml_workspace_t* workspace)
{
  const ra8_err_t arg_err = internal_parse_chapter_validate_args(xhtml_bytes,
                                                                 xhtml_len,
                                                                 ctx,
                                                                 chapter_href,
                                                                 chapter_title,
                                                                 workspace);
  if (arg_err != k_ra8_ok) {
    return arg_err;
  }
  const ra8_rabook_ctx_t checkpoint = *ctx;
  ra8_err_t              err        = xml_validate(xhtml_bytes, xhtml_len, &workspace->xml);
  priv_selection_t       selection  = {};
  if (err == k_ra8_ok) {
    err = internal_select(xhtml_bytes, xhtml_len, &workspace->xml, &selection);
  }
  uint32_t root = (uint32_t)k_book_nil;
  if (err == k_ra8_ok) {
    err = internal_emit(xhtml_bytes, xhtml_len, &selection, ctx, workspace, &root);
  }
  if (err != k_ra8_ok) {
    *ctx = checkpoint;
    return (err == k_ra8_err_validation_failed) ? err : k_ra8_err_no_mem;
  }
  if (ctx->failed) {
    *ctx = checkpoint;
    return k_ra8_err_no_mem;
  }
  if (root == (uint32_t)k_book_nil) {
    *ctx = checkpoint;
    return k_ra8_err_no_mem;
  }
  const uint32_t title   = ra8_rabook_intern(ctx, chapter_title);
  const uint32_t href    = ra8_rabook_intern(ctx, chapter_href);
  const uint32_t chapter = ra8_rabook_add_chapter(ctx, title, href, root);
  if (chapter == (uint32_t)k_book_nil) {
    *ctx = checkpoint;
    return k_ra8_err_no_mem;
  }
  return k_ra8_ok;
}