rabook_compile.c

Go to the documentation of this file.

 
#include "rabook_compile.h"
 
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"

static const char* const s_tag_rabook = "rabook_compile";

typedef enum : uint8_t {
  k_rabook_buffer_ptr_count = 8U, 
} ra8_rabook_buffer_ptr_count_t;

typedef enum : uint8_t {
  k_rabook_pool_none     = 0U, 
  k_rabook_pool_internal = 1U, 
  k_rabook_pool_external = 2U, 
} ra8_rabook_pool_mode_t;

RA8_INTERNAL
static ra8_err_t internal_check_buffer_members(const ra8_rabook_buffers_t* buf)
{
  RA8_CHECK_NULL_PTR(buf, s_tag_rabook, "buf");
 
  const void* const members[k_rabook_buffer_ptr_count] = {
    buf->chapters,
    buf->nodes,
    buf->attrs,
    buf->stylesheets,
    buf->images,
    buf->string_pool,
    buf->image_pool,
    buf->out,
  };
  static const char* const names[k_rabook_buffer_ptr_count] = {
    "buf->chapters",
    "buf->nodes",
    "buf->attrs",
    "buf->stylesheets",
    "buf->images",
    "buf->string_pool",
    "buf->image_pool",
    "buf->out",
  };
 
  for (uint8_t i = 0U; i < (uint8_t)k_rabook_buffer_ptr_count; i++) {
    RA8_CHECK_NULL_PTR(members[i], s_tag_rabook, names[i]);
  }
  return k_ra8_ok;
}
 
ra8_err_t rabook_compile_init(ra8_rabook_ctx_t* ctx, const ra8_rabook_buffers_t* buf)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag_rabook, "ctx");
  const ra8_err_t buf_err = internal_check_buffer_members(buf);
  if (buf_err != k_ra8_ok) {
    return buf_err;
  }
 
  *ctx                   = (ra8_rabook_ctx_t){};
  ctx->buf               = *buf;
  ctx->cover_image_index = (uint32_t)k_book_nil;
 
  /* Reserve string-pool offset 0 for "" so it is the empty-string sentinel that
   * add_text/add_element store, matching the desktop StringPool.__init__ in
   * tools/epub_compile/src/epub_compile.py (offset 0 == ""). */
  (void)ra8_rabook_intern(ctx, "");
  return k_ra8_ok;
}
 
uint32_t ra8_rabook_intern(ra8_rabook_ctx_t* ctx, const char* str)
{
  if (ctx == nullptr) {
    return (uint32_t)k_book_nil;
  }
  if (str == nullptr) {
    ctx->failed = true;
    return (uint32_t)k_book_nil;
  }
  if (ctx->failed) {
    return (uint32_t)k_book_nil;
  }
 
  const uint32_t len = (uint32_t)strlen(str);
  /* De-dup: walk the pool string-by-string, return the first exact match. */
  uint32_t scan = 0U;
  while (scan < ctx->string_size) {
    const char*    cand     = &ctx->buf.string_pool[scan];
    const uint32_t cand_len = (uint32_t)strlen(cand);
    if (cand_len == len) {
      uint32_t equal_bytes = 0U;
      while ((equal_bytes < len) && (cand[equal_bytes] == str[equal_bytes])) {
        equal_bytes++;
      }
      if (equal_bytes == len) {
        return scan;
      }
    }
    scan += cand_len + 1U; /* skip the candidate and its NUL */
  }
 
  /* Miss: append str + NUL, guarding the pool capacity. */
  const uint32_t need = len + 1U;
  if (need > (ctx->buf.string_cap - ctx->string_size)) {
    ctx->failed = true;
    return (uint32_t)k_book_nil;
  }
  const uint32_t off = ctx->string_size;
  (void)memcpy(&ctx->buf.string_pool[off], str, (size_t)len);
  ctx->buf.string_pool[off + len] = '\0';
  ctx->string_size += need;
  return off;
}

RA8_INTERNAL
static uint32_t
internal_append_attrs(ra8_rabook_ctx_t* ctx, const book_attr_t* attrs, uint16_t attr_count)
{
  if (attr_count == 0U) {
    return (uint32_t)k_book_nil;
  }
 
  const uint32_t first_attr = ctx->attr_count;
  for (uint16_t i = 0U; i < attr_count; i++) {
    ctx->buf.attrs[ctx->attr_count] = attrs[i];
    ctx->attr_count++;
  }
  return first_attr;
}
 
uint32_t ra8_rabook_add_element(ra8_rabook_ctx_t*  ctx,
                                uint32_t           name_off,
                                const book_attr_t* attrs,
                                uint16_t           attr_count)
{
  if (ctx == nullptr) {
    return (uint32_t)k_book_nil;
  }
  if (ctx->failed) {
    return (uint32_t)k_book_nil;
  }
  if (attr_count != 0U) {
    if (attrs == nullptr) {
      ctx->failed = true;
      return (uint32_t)k_book_nil;
    }
  }
  if (ctx->node_count >= ctx->buf.node_cap) {
    ctx->failed = true;
    return (uint32_t)k_book_nil;
  }
  if ((uint32_t)attr_count > (ctx->buf.attr_cap - ctx->attr_count)) {
    ctx->failed = true;
    return (uint32_t)k_book_nil;
  }
 
  const uint32_t first_attr = internal_append_attrs(ctx, attrs, attr_count);
 
  const uint32_t idx  = ctx->node_count;
  book_node_t*   node = &ctx->buf.nodes[idx];
  *node               = (book_node_t){};
  node->kind          = (uint8_t)k_book_node_element;
  node->attr_count    = attr_count;
  node->name_off      = name_off;
  node->text_off      = 0U;
  node->first_attr    = first_attr;
  node->first_child   = (uint32_t)k_book_nil;
  node->next_sibling  = (uint32_t)k_book_nil;
  ctx->node_count++;
  return idx;
}
 
uint32_t ra8_rabook_add_text(ra8_rabook_ctx_t* ctx, uint32_t text_off)
{
  if (ctx == nullptr) {
    return (uint32_t)k_book_nil;
  }
  if (ctx->failed) {
    return (uint32_t)k_book_nil;
  }
  if (ctx->node_count >= ctx->buf.node_cap) {
    ctx->failed = true;
    return (uint32_t)k_book_nil;
  }
 
  const uint32_t idx  = ctx->node_count;
  book_node_t*   node = &ctx->buf.nodes[idx];
  *node               = (book_node_t){};
  node->kind          = (uint8_t)k_book_node_text;
  node->attr_count    = 0U;
  node->name_off      = 0U;
  node->text_off      = text_off;
  node->first_attr    = (uint32_t)k_book_nil;
  node->first_child   = (uint32_t)k_book_nil;
  node->next_sibling  = (uint32_t)k_book_nil;
  ctx->node_count++;
  return idx;
}
 
ra8_err_t ra8_rabook_link_child(ra8_rabook_ctx_t* ctx, uint32_t parent, uint32_t child)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag_rabook, "ctx");
  if (parent >= ctx->node_count) {
    ra8_log_error(s_tag_rabook, "link_child parent out of range");
    return k_ra8_err_invalid_arg;
  }
  if (child >= ctx->node_count) {
    ra8_log_error(s_tag_rabook, "link_child child out of range");
    return k_ra8_err_invalid_arg;
  }
  ctx->buf.nodes[parent].first_child = child;
  return k_ra8_ok;
}
 
ra8_err_t
ra8_rabook_link_sibling(ra8_rabook_ctx_t* ctx, uint32_t previous_node, uint32_t next_sibling)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag_rabook, "ctx");
  if (previous_node >= ctx->node_count) {
    ra8_log_error(s_tag_rabook, "link_sibling node out of range");
    return k_ra8_err_invalid_arg;
  }
  if (next_sibling >= ctx->node_count) {
    ra8_log_error(s_tag_rabook, "link_sibling sibling out of range");
    return k_ra8_err_invalid_arg;
  }
  ctx->buf.nodes[previous_node].next_sibling = next_sibling;
  return k_ra8_ok;
}
 
uint32_t ra8_rabook_add_chapter(ra8_rabook_ctx_t* ctx,
                                uint32_t          title_off,
                                uint32_t          href_off,
                                uint32_t          root_node)
{
  if (ctx == nullptr) {
    return (uint32_t)k_book_nil;
  }
  if (ctx->failed) {
    return (uint32_t)k_book_nil;
  }
  if (ctx->chapter_count >= ctx->buf.chapter_cap) {
    ctx->failed = true;
    return (uint32_t)k_book_nil;
  }
 
  const uint32_t  idx = ctx->chapter_count;
  book_chapter_t* ch  = &ctx->buf.chapters[idx];
  ch->title_off       = title_off;
  ch->href_off        = href_off;
  ch->root_node       = root_node;
  ctx->chapter_count++;
  return idx;
}

RA8_INTERNAL
static uint32_t internal_append_image_descriptor(ra8_rabook_ctx_t* ctx,
                                                 uint32_t          id_off,
                                                 uint16_t          width,
                                                 uint16_t          height,
                                                 uint8_t           format,
                                                 uint8_t           pixel_format,
                                                 uint32_t          data_off,
                                                 uint32_t          data_size)
{
  const uint32_t idx = ctx->image_count;
  book_image_t*  img = &ctx->buf.images[idx];
  *img               = (book_image_t){};
  img->id_off        = id_off;
  img->width         = width;
  img->height        = height;
  img->format        = format;
  img->pixel_format  = pixel_format;
  img->data_off      = data_off;
  img->data_size     = data_size;
  img->raw_size      = data_size;
  ctx->image_count++;
  return idx;
}
 
uint32_t ra8_rabook_add_image(ra8_rabook_ctx_t* ctx,
                              uint32_t          id_off,
                              uint16_t          width,
                              uint16_t          height,
                              uint8_t           format,
                              uint8_t           pixel_format,
                              const uint8_t*    data,
                              uint32_t          data_size)
{
  if (ctx == nullptr) {
    return (uint32_t)k_book_nil;
  }
  if (ctx->failed) {
    return (uint32_t)k_book_nil;
  }
  if (data_size != 0U) {
    if (ctx->image_pool_mode == (uint8_t)k_rabook_pool_external) {
      ctx->failed = true;
      return (uint32_t)k_book_nil;
    }
    if (data == nullptr) {
      ctx->failed = true;
      return (uint32_t)k_book_nil;
    }
  }
  if (ctx->image_count >= ctx->buf.image_cap) {
    ctx->failed = true;
    return (uint32_t)k_book_nil;
  }
  if (data_size > (ctx->buf.image_pool_cap - ctx->image_pool_size)) {
    ctx->failed = true;
    return (uint32_t)k_book_nil;
  }
 
  const uint32_t data_off = ctx->image_pool_size;
  if (data_size != 0U) {
    ctx->image_pool_mode = (uint8_t)k_rabook_pool_internal;
    (void)memcpy(&ctx->buf.image_pool[data_off], data, (size_t)data_size);
    ctx->image_pool_size += data_size;
  }
 
  return internal_append_image_descriptor(ctx,
                                          id_off,
                                          width,
                                          height,
                                          format,
                                          pixel_format,
                                          data_off,
                                          data_size);
}
 
uint32_t ra8_rabook_add_image_external(ra8_rabook_ctx_t* ctx,
                                       uint32_t          id_off,
                                       uint16_t          width,
                                       uint16_t          height,
                                       uint8_t           format,
                                       uint8_t           pixel_format,
                                       uint32_t          data_size,
                                       uint32_t*         out_data_off)
{
  if (ctx == nullptr) {
    return (uint32_t)k_book_nil;
  }
  if (out_data_off == nullptr) {
    ctx->failed = true;
    return (uint32_t)k_book_nil;
  }
  if (ctx->failed) {
    ctx->failed = true;
    return (uint32_t)k_book_nil;
  }
  if (data_size != 0U) {
    if (ctx->image_pool_mode == (uint8_t)k_rabook_pool_internal) {
      ctx->failed = true;
      return (uint32_t)k_book_nil;
    }
  }
  if (ctx->image_count >= ctx->buf.image_cap) {
    ctx->failed = true;
    return (uint32_t)k_book_nil;
  }
  if (data_size > (UINT32_MAX - ctx->image_pool_size)) {
    ctx->failed = true;
    return (uint32_t)k_book_nil;
  }
 
  const uint32_t data_off = ctx->image_pool_size;
  if (data_size != 0U) {
    ctx->image_pool_mode = (uint8_t)k_rabook_pool_external;
    ctx->image_pool_size += data_size;
  }
 
  *out_data_off = data_off;
  return internal_append_image_descriptor(ctx,
                                          id_off,
                                          width,
                                          height,
                                          format,
                                          pixel_format,
                                          data_off,
                                          data_size);
}
 
uint32_t
ra8_rabook_add_stylesheet(ra8_rabook_ctx_t* ctx, uint32_t source_off, uint32_t scope_chapter)
{
  if (ctx == nullptr) {
    return (uint32_t)k_book_nil;
  }
  if (ctx->failed) {
    return (uint32_t)k_book_nil;
  }
  if (ctx->stylesheet_count >= ctx->buf.stylesheet_cap) {
    ctx->failed = true;
    return (uint32_t)k_book_nil;
  }
 
  const uint32_t     idx = ctx->stylesheet_count;
  book_stylesheet_t* ss  = &ctx->buf.stylesheets[idx];
  ss->source_off         = source_off;
  ss->scope_chapter      = scope_chapter;
  ctx->stylesheet_count++;
  return idx;
}
 
ra8_err_t ra8_rabook_set_metadata(ra8_rabook_ctx_t* ctx,
                                  uint32_t          title_off,
                                  uint32_t          author_off,
                                  uint32_t          language_off,
                                  uint32_t          identifier_off,
                                  uint32_t          cover_image_index)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag_rabook, "ctx");
  if (ctx->failed) {
    ra8_log_error(s_tag_rabook, "set_metadata after a builder overflow");
    return k_ra8_err_no_mem;
  }
  ctx->title_off         = title_off;
  ctx->author_off        = author_off;
  ctx->language_off      = language_off;
  ctx->identifier_off    = identifier_off;
  ctx->cover_image_index = cover_image_index;
  return k_ra8_ok;
}