book_xhtml.c

Go to the documentation of this file.

#include <string.h>
 
#include "book.h"
#include "book_internal.h"
#include "book_paged.h"
#include "ra8_attributes.h"
#include "ra8_check.h"

static const char* const s_tag_xhtml = "book_xhtml";

typedef struct {
  bool     is_close; 
  uint32_t value;    
} book_walk_entry_t;

RA8_INTERNAL static bool
internal_emit(char* out, size_t cap, size_t* pos, const char* src, size_t len)
{
  if (len > (cap - *pos)) {
    return false;
  }
  (void)memcpy(&out[*pos], src, len);
  *pos += len;
  return true;
}

RA8_INTERNAL static bool internal_emit_cstr(char* out, size_t cap, size_t* pos, const char* str)
{
  return internal_emit(out, cap, pos, str, strlen(str));
}

RA8_INTERNAL static bool
internal_emit_escaped(char* out, size_t cap, size_t* pos, const char* str, bool in_attr)
{
  for (const char* p = str; *p != '\0'; ++p) {
    bool ok = true;
    switch (*p) {
      case '&':
        ok = internal_emit_cstr(out, cap, pos, "&amp;");
        break;
      case '<':
        ok = internal_emit_cstr(out, cap, pos, "&lt;");
        break;
      case '>':
        ok = internal_emit_cstr(out, cap, pos, "&gt;");
        break;
      case '"':
        ok = in_attr ? internal_emit_cstr(out, cap, pos, "&quot;")
                     : internal_emit(out, cap, pos, p, 1U);
        break;
      default:
        ok = internal_emit(out, cap, pos, p, 1U);
        break;
    }
    if (!ok) {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL static bool internal_is_void(const char* name)
{
  static const char* const k_void[] = {
    "br",
    "hr",
    "img",
    "meta",
    "link",
    "input",
    "area",
    "base",
    "col",
    "embed",
    "param",
    "source",
    "track",
    "wbr",
  };
  for (size_t i = 0U; i < (sizeof(k_void) / sizeof(k_void[0])); ++i) {
    if (strcmp(name, k_void[i]) == 0) {
      return true;
    }
  }
  return false;
}

RA8_INTERNAL static bool
internal_emit_attrs(const void* base, const book_node_t* node, char* out, size_t cap, size_t* pos)
{
  const book_attr_t* attrs = book_attrs(base);
  for (uint16_t i = 0U; i < node->attr_count; ++i) {
    const book_attr_t* a = &attrs[node->first_attr + i];
    bool ok = internal_emit(out, cap, pos, " ", 1U) &&
              internal_emit_cstr(out, cap, pos, book_string(base, a->name_off)) &&
              internal_emit(out, cap, pos, "=\"", 2U) &&
              internal_emit_escaped(out, cap, pos, book_string(base, a->value_off), true) &&
              internal_emit(out, cap, pos, "\"", 1U);
    if (!ok) {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL static bool internal_open_element(const void*        base,
                                               const book_node_t* node,
                                               char*              out,
                                               size_t             cap,
                                               size_t*            pos,
                                               book_walk_entry_t* stack,
                                               uint32_t*          sp)
{
  const char* name = book_string(base, node->name_off);
  if (!internal_emit(out, cap, pos, "<", 1U) || !internal_emit_cstr(out, cap, pos, name) ||
      !internal_emit_attrs(base, node, out, cap, pos)) {
    return false;
  }
  if (internal_is_void(name)) {
    return internal_emit(out, cap, pos, "/>", 2U);
  }
  if (!internal_emit(out, cap, pos, ">", 1U) || ((*sp + 2U) > k_book_xhtml_stack)) {
    return false;
  }
  stack[*sp] = (book_walk_entry_t){true, node->name_off}; /* close after children */
  *sp += 1U;
  stack[*sp] = (book_walk_entry_t){false, node->first_child}; /* children first */
  *sp += 1U;
  return true;
}

RA8_INTERNAL static bool internal_walk_to_xhtml(const void* base,
                                                uint32_t    root,
                                                uint32_t    node_count,
                                                char*       out,
                                                size_t      cap,
                                                size_t*     pos)
{
  const book_node_t* nodes = book_nodes(base);
  /* Explicit DFS stack (~4 KiB) kept in module-static storage so this frame
   * stays within the stack-usage budget; the walk is iterative (no recursion)
   * and single-threaded, so the shared buffer never overlaps. */
  static book_walk_entry_t s_xhtml_stack[k_book_xhtml_stack];
  book_walk_entry_t*       stack = s_xhtml_stack;
  uint32_t                 sp    = 0U;
  bool                     ok    = true;
  stack[sp]                      = (book_walk_entry_t){false, root};
  sp += 1U;
 
  const uint32_t max_iter = (node_count * k_book_xhtml_iter_x) + k_book_xhtml_stack;
  uint32_t       guard    = 0U;
  while ((sp > 0U) && ok && (guard < max_iter)) {
    ++guard;
    sp -= 1U;
    book_walk_entry_t e = stack[sp];
    if (e.is_close) {
      ok = internal_emit(out, cap, pos, "</", 2U) &&
           internal_emit_cstr(out, cap, pos, book_string(base, e.value)) &&
           internal_emit(out, cap, pos, ">", 1U);
      continue;
    }
    if (e.value == k_book_nil) {
      continue;
    }
    const book_node_t* node = &nodes[e.value];
    if (sp >= k_book_xhtml_stack) {
      return false;
    }
    /* Continue this level's sibling chain after the whole subtree + close. */
    stack[sp] = (book_walk_entry_t){false, node->next_sibling};
    sp += 1U;
    if (node->kind == (uint8_t)k_book_node_text) {
      ok = internal_emit_escaped(out, cap, pos, book_string(base, node->text_off), false);
    } else {
      ok = internal_open_element(base, node, out, cap, pos, stack, &sp);
    }
  }
  return ok && (guard < max_iter);
}

RA8_PRIV bool priv_book_is_block(const char* name)
{
  static const char* const k_block[] = {
    "p",      "h1",         "h2",      "h3",    "h4",     "h5",      "h6",         "li",
    "ul",     "ol",         "div",     "br",    "hr",     "section", "tr",         "pre",
    "header", "blockquote", "article", "aside", "footer", "figure",  "figcaption",
  };
  for (size_t i = 0U; i < (sizeof(k_block) / sizeof(k_block[0])); ++i) {
    if (strcmp(name, k_block[i]) == 0) {
      return true;
    }
  }
  return false;
}

RA8_PRIV bool
priv_book_emit_text(char* out, size_t cap, size_t* pos, const char* str, bool* at_break)
{
  for (const char* p = str; *p != '\0'; ++p) {
    const char c  = *p;
    const bool ws = (c == ' ') || (c == '\t') || (c == '\n') || (c == '\r');
    if (!ws) {
      if (!internal_emit(out, cap, pos, &c, 1U)) {
        return false;
      }
      *at_break = false;
      continue;
    }
    if (*at_break) {
      continue;
    }
    if (!internal_emit(out, cap, pos, " ", 1U)) {
      return false;
    }
    *at_break = true;
  }
  return true;
}

RA8_PRIV bool priv_book_emit_break(char* out, size_t cap, size_t* pos, bool* at_break)
{
  while ((*pos > 0U) && (out[*pos - 1U] == ' ')) {
    (*pos)--;
  }
  *at_break = true;
  if ((*pos > 0U) && (out[*pos - 1U] == '\n')) {
    return true;
  }
  return internal_emit(out, cap, pos, "\n", 1U);
}

RA8_INTERNAL static bool internal_walk_text(const void* base,
                                            uint32_t    root,
                                            uint32_t    node_count,
                                            char*       out,
                                            size_t      cap,
                                            size_t*     pos)
{
  const book_node_t* nodes = book_nodes(base);
  /* Explicit DFS stack (2 KiB) kept in module-static storage so this frame
   * stays within the stack-usage budget; iterative (no recursion) and
   * single-threaded, so the shared buffer never overlaps. */
  static uint32_t s_text_stack[k_book_xhtml_stack];
  uint32_t*       stack    = s_text_stack;
  uint32_t        sp       = 0U;
  bool            ok       = true;
  bool            at_break = true;
  stack[sp]                = root;
  sp += 1U;
 
  const uint32_t max_iter = (node_count * k_book_xhtml_iter_x) + k_book_xhtml_stack;
  uint32_t       guard    = 0U;
  while ((sp > 0U) && ok && (guard < max_iter)) {
    ++guard;
    sp -= 1U;
    const uint32_t n = stack[sp];
    if (n == k_book_nil) {
      continue;
    }
    const book_node_t* node = &nodes[n];
    if (sp >= k_book_xhtml_stack) {
      return false;
    }
    stack[sp] = node->next_sibling; /* sibling chain after this subtree */
    sp += 1U;
    if (node->kind == (uint8_t)k_book_node_text) {
      ok = priv_book_emit_text(out, cap, pos, book_string(base, node->text_off), &at_break);
      continue;
    }
    if (priv_book_is_block(book_string(base, node->name_off))) {
      ok = priv_book_emit_break(out, cap, pos, &at_break);
    }
    if (ok && (sp < k_book_xhtml_stack)) {
      stack[sp] = node->first_child; /* descend, pre-order */
      sp += 1U;
    }
  }
  return ok && (guard < max_iter);
}
 
ra8_err_t
book_chapter_text(const void* base, uint32_t chapter_idx, char* out, size_t cap, size_t* out_len)
{
  RA8_CHECK_NULL_PTR(base, s_tag_xhtml, "text: null base");
  RA8_CHECK_NULL_PTR(out, s_tag_xhtml, "text: null out");
  RA8_CHECK_NULL_PTR(out_len, s_tag_xhtml, "text: null out_len");
 
  const book_header_t* hdr = book_header(base);
  if (chapter_idx >= hdr->chapter_count) {
    return k_ra8_err_invalid_arg;
  }
  const uint32_t root = book_chapters(base)[chapter_idx].root_node;
  size_t         pos  = 0U;
  if (!internal_walk_text(base, root, hdr->node_count, out, cap, &pos)) {
    return k_ra8_err_invalid_size;
  }
  *out_len = pos;
  return k_ra8_ok;
}
 
ra8_err_t book_chapter_to_xhtml(const void* base,
                                uint32_t    chapter_idx,
                                char*       out,
                                size_t      cap,
                                size_t*     out_len)
{
  RA8_CHECK_NULL_PTR(base, s_tag_xhtml, "to_xhtml: null base");
  RA8_CHECK_NULL_PTR(out, s_tag_xhtml, "to_xhtml: null out");
  RA8_CHECK_NULL_PTR(out_len, s_tag_xhtml, "to_xhtml: null out_len");
 
  const book_header_t* hdr = book_header(base);
  if (chapter_idx >= hdr->chapter_count) {
    return k_ra8_err_invalid_arg;
  }
 
  const uint32_t root = book_chapters(base)[chapter_idx].root_node;
  size_t         pos  = 0U;
  if (!internal_walk_to_xhtml(base, root, hdr->node_count, out, cap, &pos)) {
    return k_ra8_err_invalid_size;
  }
  *out_len = pos;
  return k_ra8_ok;
}