rage-iodine 1.7.58

data/ext/iodine/mustache_parser.h

@@ -0,0 +1,1546 @@
+/*
+Copyright: Boaz Segev, 2018-2019
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef H_MUSTACHE_LOADR_H
+/**
+ * A mustache parser using a callback systems that allows this implementation to
+ * be framework agnostic (i.e., can be used with any JSON library).
+ */
+#define H_MUSTACHE_LOADR_H
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <ctype.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <unistd.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#ifdef __MINGW32__
+ssize_t pread(int, void*, size_t, off_t);
+#endif
+
+#if !defined(__GNUC__) && !defined(__clang__) && !defined(FIO_GNUC_BYPASS)
+#define __attribute__(...)
+#define __has_include(...) 0
+#define __has_builtin(...) 0
+#define FIO_GNUC_BYPASS 1
+#elif !defined(__clang__) && !defined(__has_builtin)
+#define __has_builtin(...) 0
+#define FIO_GNUC_BYPASS 1
+#endif
+
+#ifndef MUSTACHE_FUNC
+#define MUSTACHE_FUNC static __attribute__((unused))
+#endif
+
+/* *****************************************************************************
+Compile Time Behavior Flags
+***************************************************************************** */
+
+#ifndef MUSTACHE_USE_DYNAMIC_PADDING
+#define MUSTACHE_USE_DYNAMIC_PADDING 1
+#endif
+
+#ifndef MUSTACHE_FAIL_ON_MISSING_TEMPLATE
+#define MUSTACHE_FAIL_ON_MISSING_TEMPLATE 1
+#endif
+
+#if !defined(MUSTACHE_NESTING_LIMIT) || !MUSTACHE_NESTING_LIMIT
+#undef MUSTACHE_NESTING_LIMIT
+#define MUSTACHE_NESTING_LIMIT 82
+#endif
+
+/* *****************************************************************************
+Mustache API Argument types
+***************************************************************************** */
+
+/** an opaque type for mustache template data (when caching). */
+typedef struct mustache_s mustache_s;
+
+/** Error reporting type. */
+typedef enum mustache_error_en {
+  MUSTACHE_OK,
+  MUSTACHE_ERR_TOO_DEEP,
+  MUSTACHE_ERR_CLOSURE_MISMATCH,
+  MUSTACHE_ERR_FILE_NOT_FOUND,
+  MUSTACHE_ERR_FILE_TOO_BIG,
+  MUSTACHE_ERR_FILE_NAME_TOO_LONG,
+  MUSTACHE_ERR_FILE_NAME_TOO_SHORT,
+  MUSTACHE_ERR_EMPTY_TEMPLATE,
+  MUSTACHE_ERR_DELIMITER_TOO_LONG,
+  MUSTACHE_ERR_NAME_TOO_LONG,
+  MUSTACHE_ERR_UNKNOWN,
+  MUSTACHE_ERR_USER_ERROR,
+} mustache_error_en;
+
+/** Arguments for the `mustache_load` function, used by the mustache parser. */
+typedef struct {
+  /** The root template's file name. */
+  char const *filename;
+  /** The file name's length. */
+  size_t filename_len;
+  /** If data and data_len are set, they will be used as the file's contents. */
+  char const *data;
+  /** If data and data_len are set, they will be used as the file's contents. */
+  size_t data_len;
+  /** Parsing error reporting (can be NULL). */
+  mustache_error_en *err;
+} mustache_load_args_s;
+
+/* *****************************************************************************
+REQUIRED: Define INCLUDE_MUSTACHE_IMPLEMENTATION only in the implementation file
+***************************************************************************** */
+
+/**
+ * In non-implementation files, don't define the INCLUDE_MUSTACHE_IMPLEMENTATION
+ * macro.
+ *
+ * Before including the header within an implementation faile, define
+ * INCLUDE_MUSTACHE_IMPLEMENTATION as 1.
+ */
+#if INCLUDE_MUSTACHE_IMPLEMENTATION
+
+/* *****************************************************************************
+Mustache API Functions and Arguments
+***************************************************************************** */
+
+MUSTACHE_FUNC mustache_s *mustache_load(mustache_load_args_s args);
+
+#define mustache_load(...) mustache_load((mustache_load_args_s){__VA_ARGS__})
+
+/** free the mustache template */
+inline MUSTACHE_FUNC void mustache_free(mustache_s *mustache) {
+  free(mustache);
+}
+
+/** Arguments for the `mustache_build` function. */
+typedef struct {
+  /** The parsed template (an instruction collection). */
+  mustache_s *mustache;
+  /** Opaque user data (recommended for input review) - children will inherit
+   * the parent's udata value. Updated values will propegate to child sections
+   * but won't effect parent sections.
+   */
+  void *udata1;
+  /** Opaque user data (recommended for output handling)- children will inherit
+   * the parent's udata value. Updated values will propegate to child sections
+   * but won't effect parent sections.
+   */
+  void *udata2;
+  /** Formatting error reporting (can be NULL). */
+  mustache_error_en *err;
+} mustache_build_args_s;
+MUSTACHE_FUNC int mustache_build(mustache_build_args_s args);
+
+#define mustache_build(mustache_s_ptr, ...)                                    \
+  mustache_build(                                                              \
+      (mustache_build_args_s){.mustache = (mustache_s_ptr), __VA_ARGS__})
+
+/* *****************************************************************************
+Callbacks Types - types used by the template builder callbacks
+***************************************************************************** */
+
+/**
+ * A mustache section allows the callbacks to "walk" backwards towards the root
+ * in search of argument data.
+ *
+ * Note that every section is allowed a separate udata value.
+ */
+typedef struct mustache_section_s {
+  /** Opaque user data (recommended for input review) - children will inherit
+   * the parent's udata value. Updated values will propegate to child sections
+   * but won't effect parent sections.
+   */
+  void *udata1;
+  /** Opaque user data (recommended for output handling)- children will inherit
+   * the parent's udata value. Updated values will propegate to child sections
+   * but won't effect parent sections.
+   */
+  void *udata2;
+} mustache_section_s;
+
+/* *****************************************************************************
+Callbacks Helpers - These functions can be called from within callbacks
+***************************************************************************** */
+
+/**
+ * Returns the section's parent for nested sections, or NULL (for root section).
+ *
+ * This allows the `udata` values in the parent to be accessed and can be used,
+ * for example, when seeking a value (argument / keyword) within a nested data
+ * structure such as a Hash.
+ */
+static inline mustache_section_s *
+mustache_section_parent(mustache_section_s *section);
+
+/**
+ * This helper function should be used to write text to the output
+ * stream form within `mustache_on_arg` or `mustache_on_section_test`.
+ *
+ * This function will call the `mustache_on_text` callback for each slice of
+ * text that requires padding and for escaped data.
+ *
+ * `mustache_on_text` must NEVER call this function.
+ */
+static inline int mustache_write_text(mustache_section_s *section, char *text,
+                                      uint32_t len, uint8_t escape);
+
+/**
+ * Returns the section's unparsed content as a non-NUL terminated byte array.
+ *
+ * The length of the data will be placed in the `size_t` variable pointed to by
+ * `p_len`. Do NOT use `strlen`, since the data isn't NUL terminated.
+ *
+ * This allows text to be accessed when a section's content is, in fact, meant
+ * to be passed along to a function / lambda.
+ */
+static inline const char *mustache_section_text(mustache_section_s *section,
+                                                size_t *p_len);
+
+/* *****************************************************************************
+Client Callbacks - MUST be implemented by the including file
+***************************************************************************** */
+
+/**
+ * Called when an argument name was detected in the current section.
+ *
+ * A conforming implementation will search for the named argument both in the
+ * existing section and all of it's parents (walking backwards towards the root)
+ * until a value is detected.
+ *
+ * A missing value should be treated the same as an empty string.
+ *
+ * A conforming implementation will output the named argument's value (either
+ * HTML escaped or not, depending on the `escape` flag) as a string.
+ *
+ * A conforming implementation will test for dot notation in the name.
+ *
+ * NOTE: the `name` data is **not** NUL terminated. Use the `name_len` data to
+ * determine the actual string length.
+ */
+static int mustache_on_arg(mustache_section_s *section, const char *name,
+                           uint32_t name_len, unsigned char escape);
+
+/**
+ * Called when simple template text (string) is detected.
+ *
+ * A conforming implementation will output data as a string (no escaping).
+ *
+ * NOTE: the `data` is **not** NUL terminated. Use the `data_len` data to
+ * determine the actual data length.
+ */
+static int mustache_on_text(mustache_section_s *section, const char *data,
+                            uint32_t data_len);
+
+/**
+ * Called for nested sections, must return the number of objects in the new
+ * subsection (depending on the argument's name).
+ *
+ * Arrays should return the number of objects in the array.
+ *
+ * `true` values should return 1.
+ *
+ * `false` values should return 0.
+ *
+ * A return value of -1 will stop processing with an error.
+ *
+ * Please note, this will handle both normal and inverted sections.
+ *
+ * The `callable` value is true if the section is allowed to be a function /
+ * callback. If the section object represent a function / callback (lambda), the
+ * lambda should be called and the `mustache_on_section_test` callback should
+ * return 0.
+ *
+ * NOTE: the `name` data is **not** NUL terminated. Use the `name_len` data to
+ * determine the actual string length.
+ *
+ * A conforming implementation will test for dot notation in the name.
+ */
+static int32_t mustache_on_section_test(mustache_section_s *section,
+                                        const char *name, uint32_t name_len,
+                                        uint8_t callable);
+
+/**
+ * Called when entering a nested section.
+ *
+ * `index` is a zero based index indicating the number of repetitions that
+ * occurred so far (same as the array index for arrays).
+ *
+ * A return value of -1 will stop processing with an error.
+ *
+ * Note: this is a good time to update the subsection's `udata` with the value
+ * of the array index. The `udata` will always contain the value or the parent's
+ * `udata`.
+ *
+ * NOTE: the `name` data is **not** NUL terminated. Use the `name_len` data to
+ * determine the actual string length.
+ *
+ * A conforming implementation will test for dot notation in the name.
+ */
+static int mustache_on_section_start(mustache_section_s *section,
+                                     char const *name, uint32_t name_len,
+                                     uint32_t index);
+
+/**
+ * Called for cleanup in case of error.
+ */
+static void mustache_on_formatting_error(void *udata1, void *udata2);
+
+/* *****************************************************************************
+
+IMPLEMENTATION (beware: monolithic functions ahead)
+
+***************************************************************************** */
+
+/* *****************************************************************************
+Internal types
+***************************************************************************** */
+
+struct mustache_s {
+  /* The number of instructions in the engine */
+  union {
+    void *read_only_pt; /* ensure pointer wide padding */
+    struct {
+      uint32_t intruction_count;
+      uint32_t data_length;
+    } read_only;
+  } u;
+};
+
+typedef struct mustache__instruction_s {
+  enum {
+    MUSTACHE_WRITE_TEXT,
+    MUSTACHE_WRITE_ARG,
+    MUSTACHE_WRITE_ARG_UNESCAPED,
+    MUSTACHE_SECTION_START,
+    MUSTACHE_SECTION_START_INV,
+    MUSTACHE_SECTION_END,
+    MUSTACHE_SECTION_GOTO,
+    MUSTACHE_PADDING_PUSH,
+    MUSTACHE_PADDING_POP,
+    MUSTACHE_PADDING_WRITE,
+  } instruction;
+  /** the data the instruction acts upon */
+  struct {
+    /** The length instruction block in the instruction array (for sections). */
+    uint32_t end;
+    /** The length of the (string) data. */
+    uint32_t len;
+    /** The offset from the beginning of the data segment. */
+    uint32_t name_pos;
+    /** The offset between the name (start) and content (for sections). */
+    uint16_t name_len;
+    /** The offset between the name and the content (left / right by type). */
+    uint16_t offset;
+  } data;
+} mustache__instruction_s;
+
+typedef struct {
+  mustache_section_s sec; /* client visible section data */
+  uint32_t start;         /* section start instruction position */
+  uint32_t end;           /* instruction to jump to after completion */
+  uint32_t index;         /* zero based index for section loops */
+  uint32_t count; /* the number of times the section should be performed */
+  uint16_t frame; /* the stack frame's index (zero based) */
+} mustache__section_stack_frame_s;
+
+/*
+ * The stack memory is placed in a structure to allow stack unrolling and
+ * avoiding recursion with it's stack overflow risks.
+ */
+typedef struct {
+  mustache_s *data; /* the mustache template being built */
+  uint32_t pos;     /* the instruction postision index */
+  uint32_t padding; /* padding instruction position */
+  uint16_t index;   /* the stack postision index */
+  mustache__section_stack_frame_s stack[MUSTACHE_NESTING_LIMIT];
+} mustache__builder_stack_s;
+
+#define MUSTACHE_DELIMITER_LENGTH_LIMIT 5
+
+/*
+ * The stack memory is placed in a structure to allow stack unrolling and
+ * avoiding recursion with it's stack overflow risks.
+ */
+typedef struct {
+  mustache_s *m;
+  mustache__instruction_s *i;
+  mustache_error_en *err;
+  char *data;
+  char *path;
+  uint32_t i_capa;
+  uint32_t data_len;
+  uint32_t padding;
+  uint16_t path_len;
+  uint16_t path_capa;
+  uint16_t index; /* stack index */
+  struct {
+    uint32_t data_start;    /* template starting position (with header) */
+    uint32_t data_pos;      /* data reading position (how much was consumed) */
+    uint32_t data_end;      /* data ending position (for this template) */
+    uint16_t open_sections; /* counts open sections waiting for closure */
+    char del_start[MUSTACHE_DELIMITER_LENGTH_LIMIT]; /* currunt instruction
+                                                        start delimiter */
+    char del_end[MUSTACHE_DELIMITER_LENGTH_LIMIT];   /* currunt instruction end
+                                                        delimiter */
+    uint8_t del_start_len; /* currunt start delimiter length */
+    uint8_t del_end_len;   /* currunt end delimiter length */
+  } stack[MUSTACHE_NESTING_LIMIT];
+} mustache__loader_stack_s;
+
+/* *****************************************************************************
+Callbacks Helper Implementation
+***************************************************************************** */
+
+#define MUSTACH2INSTRUCTIONS(mustache)                                         \
+  ((mustache__instruction_s *)((mustache) + 1))
+#define MUSTACH2DATA(mustache)                                                 \
+  (char *)(MUSTACH2INSTRUCTIONS((mustache)) +                                  \
+           (mustache)->u.read_only.intruction_count)
+#define MUSTACHE_OBJECT_OFFSET(type, member, ptr)                              \
+  ((type *)((uintptr_t)(ptr) - (uintptr_t)(&(((type *)0)->member))))
+
+#define MUSTACHE_ASSERT(cond, msg)                                             \
+  if (!(cond)) {                                                               \
+    perror("FATAL ERROR: " msg);                                               \
+    exit(errno);                                                               \
+  }
+#define MUSTACHE_IGNORE_WHITESPACE(str, step)                                  \
+  while (isspace(*(str))) {                                                    \
+    (str) += (step);                                                           \
+  }
+
+/*
+ * used internally by some of the helpers to find convert a section pointer to
+ * the full builder stack data.
+ */
+static inline mustache__builder_stack_s *
+mustache___section2stack(mustache_section_s *section) {
+  mustache__section_stack_frame_s *f =
+      (mustache__section_stack_frame_s *)section;
+  return MUSTACHE_OBJECT_OFFSET(mustache__builder_stack_s, stack,
+                                (f - f->frame));
+}
+
+/**
+ * Returns the section's parent for nested sections, or NULL (for root section).
+ *
+ * This allows the `udata` values in the parent to be accessed and can be used,
+ * for example, when seeking a value (argument / keyword) within a nested data
+ * structure such as a Hash.
+ */
+static inline mustache_section_s *
+mustache_section_parent(mustache_section_s *section) {
+  mustache_section_s tmp = *section;
+  mustache__section_stack_frame_s *f =
+      (mustache__section_stack_frame_s *)section;
+  while (f->frame) {
+    --f;
+    if (tmp.udata1 != f->sec.udata1 || tmp.udata2 != f->sec.udata2)
+      return &f->sec;
+  }
+  return NULL;
+}
+
+/**
+ * Returns the section's unparsed content as a non-NUL terminated byte array.
+ *
+ * The length of the data will be placed in the `size_t` variable pointed to by
+ * `p_len`. Do NOT use `strlen`, since the data isn't NUL terminated.
+ *
+ * This allows text to be accessed when a section's content is, in fact, meant
+ * to be passed along to a function / lambda.
+ */
+static inline const char *mustache_section_text(mustache_section_s *section,
+                                                size_t *p_len) {
+  if (!section || !p_len)
+    goto error;
+  mustache__builder_stack_s *s = mustache___section2stack(section);
+  mustache__instruction_s *inst =
+      MUSTACH2INSTRUCTIONS(s->data) + s->pos; /* current instruction*/
+  if (inst->instruction != MUSTACHE_SECTION_START)
+    goto error;
+  const char *start =
+      MUSTACH2DATA(s->data) + inst->data.name_pos + inst->data.offset;
+  *p_len = inst->data.len;
+  return start;
+error:
+  *p_len = 0;
+  return NULL;
+}
+
+/**
+ * used internally to write escaped text rather than clear text.
+ */
+static inline int mustache__write_padding(mustache__builder_stack_s *s) {
+  mustache__instruction_s *const inst = MUSTACH2INSTRUCTIONS(s->data);
+  char *const data = MUSTACH2DATA(s->data);
+  for (uint32_t i = s->padding; i; i = inst[i].data.end) {
+    if (mustache_on_text(&s->stack[s->index].sec, data + inst[i].data.name_pos,
+                         inst[i].data.name_len) == -1)
+      return -1;
+  }
+  return 0;
+}
+
+/**
+ * used internally to write escaped text rather than clear text.
+ */
+static int mustache__write_escaped(mustache__builder_stack_s *s, char *text,
+                                   uint32_t len) {
+#define MUSTACHE_ESCAPE_BUFFER_SIZE 4096
+  /** HTML ecape table, created using the following Ruby Script:
+
+        a = (0..255).to_a.map {|i| i.chr }
+        100.times {|i| a[i] = "&\##{i.to_s(10)};"}
+        ('a'.ord..'z'.ord).each {|i| a[i] = i.chr }
+        ('A'.ord..'Z'.ord).each {|i| a[i] = i.chr }
+        ('0'.ord..'9'.ord).each {|i| a[i] = i.chr }
+        a['<'.ord] = "&lt;"
+        a['>'.ord] = "&gt;"
+        a['&'.ord] = "&amp;"
+        a['"'.ord] = "&quot;"
+        a["\'".ord] = "&apos;"
+        a['|'.ord] = "&\##{'|'.ord.to_s(10)};"
+
+        b = a.map {|s| s.length }
+        puts "static char *html_escape_strs[] = {",
+             a.to_s.slice(1..-2) ,"};",
+             "static uint8_t html_escape_len[] = {",
+             b.to_s.slice(1..-2),"};"
+*/
+  static const char *html_escape_strs[] = {
+      "&#0;",  "&#1;",  "&#2;",   "&#3;",  "&#4;",   "&#5;",  "&#6;",  "&#7;",
+      "&#8;",  "&#9;",  "&#10;",  "&#11;", "&#12;",  "&#13;", "&#14;", "&#15;",
+      "&#16;", "&#17;", "&#18;",  "&#19;", "&#20;",  "&#21;", "&#22;", "&#23;",
+      "&#24;", "&#25;", "&#26;",  "&#27;", "&#28;",  "&#29;", "&#30;", "&#31;",
+      "&#32;", "&#33;", "&quot;", "&#35;", "&#36;",  "&#37;", "&amp;", "&apos;",
+      "&#40;", "&#41;", "&#42;",  "&#43;", "&#44;",  "&#45;", "&#46;", "&#47;",
+      "0",     "1",     "2",      "3",     "4",      "5",     "6",     "7",
+      "8",     "9",     "&#58;",  "&#59;", "&lt;",   "&#61;", "&gt;",  "&#63;",
+      "&#64;", "A",     "B",      "C",     "D",      "E",     "F",     "G",
+      "H",     "I",     "J",      "K",     "L",      "M",     "N",     "O",
+      "P",     "Q",     "R",      "S",     "T",      "U",     "V",     "W",
+      "X",     "Y",     "Z",      "&#91;", "&#92;",  "&#93;", "&#94;", "&#95;",
+      "&#96;", "a",     "b",      "c",     "d",      "e",     "f",     "g",
+      "h",     "i",     "j",      "k",     "l",      "m",     "n",     "o",
+      "p",     "q",     "r",      "s",     "t",      "u",     "v",     "w",
+      "x",     "y",     "z",      "{",     "&#124;", "}",     "~",     "\x7F",
+      "\x80",  "\x81",  "\x82",   "\x83",  "\x84",   "\x85",  "\x86",  "\x87",
+      "\x88",  "\x89",  "\x8A",   "\x8B",  "\x8C",   "\x8D",  "\x8E",  "\x8F",
+      "\x90",  "\x91",  "\x92",   "\x93",  "\x94",   "\x95",  "\x96",  "\x97",
+      "\x98",  "\x99",  "\x9A",   "\x9B",  "\x9C",   "\x9D",  "\x9E",  "\x9F",
+      "\xA0",  "\xA1",  "\xA2",   "\xA3",  "\xA4",   "\xA5",  "\xA6",  "\xA7",
+      "\xA8",  "\xA9",  "\xAA",   "\xAB",  "\xAC",   "\xAD",  "\xAE",  "\xAF",
+      "\xB0",  "\xB1",  "\xB2",   "\xB3",  "\xB4",   "\xB5",  "\xB6",  "\xB7",
+      "\xB8",  "\xB9",  "\xBA",   "\xBB",  "\xBC",   "\xBD",  "\xBE",  "\xBF",
+      "\xC0",  "\xC1",  "\xC2",   "\xC3",  "\xC4",   "\xC5",  "\xC6",  "\xC7",
+      "\xC8",  "\xC9",  "\xCA",   "\xCB",  "\xCC",   "\xCD",  "\xCE",  "\xCF",
+      "\xD0",  "\xD1",  "\xD2",   "\xD3",  "\xD4",   "\xD5",  "\xD6",  "\xD7",
+      "\xD8",  "\xD9",  "\xDA",   "\xDB",  "\xDC",   "\xDD",  "\xDE",  "\xDF",
+      "\xE0",  "\xE1",  "\xE2",   "\xE3",  "\xE4",   "\xE5",  "\xE6",  "\xE7",
+      "\xE8",  "\xE9",  "\xEA",   "\xEB",  "\xEC",   "\xED",  "\xEE",  "\xEF",
+      "\xF0",  "\xF1",  "\xF2",   "\xF3",  "\xF4",   "\xF5",  "\xF6",  "\xF7",
+      "\xF8",  "\xF9",  "\xFA",   "\xFB",  "\xFC",   "\xFD",  "\xFE",  "\xFF"};
+  static const uint8_t html_escape_len[] = {
+      4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+      5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 5, 5, 5, 5, 6, 5, 5, 5, 5, 5, 5, 5, 5,
+      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5, 4, 5, 4, 5, 5, 1, 1, 1, 1, 1, 1, 1,
+      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5, 5, 5, 5,
+      5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+      1, 1, 1, 1, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+  char buffer[MUSTACHE_ESCAPE_BUFFER_SIZE];
+  size_t pos = 0;
+  const char *end = text + len;
+  while (text < end) {
+    if (MUSTACHE_USE_DYNAMIC_PADDING && *text == '\n' && s->padding) {
+      buffer[pos++] = '\n';
+      buffer[pos] = 0;
+      if (mustache_on_text(&s->stack[s->index].sec, buffer, pos) == -1)
+        return -1;
+      pos = 0;
+      if (mustache__write_padding(s) == -1)
+        return -1;
+    } else {
+      memcpy(buffer + pos, html_escape_strs[(uint8_t)text[0]],
+             html_escape_len[(uint8_t)text[0]]);
+      pos += html_escape_len[(uint8_t)text[0]];
+      if (pos >= (MUSTACHE_ESCAPE_BUFFER_SIZE - 6)) {
+        buffer[pos] = 0;
+        if (mustache_on_text(&s->stack[s->index].sec, buffer, pos) == -1)
+          return -1;
+        pos = 0;
+      }
+    }
+    ++text;
+  }
+  if (pos) {
+    buffer[pos] = 0;
+    if (mustache_on_text(&s->stack[s->index].sec, buffer, pos) == -1)
+      return -1;
+  }
+  return 0;
+#undef MUSTACHE_ESCAPE_BUFFER_SIZE
+}
+/**
+ * This helper function should be used to write text to the output
+ * stream (often used within the `mustache_on_arg` callback).
+ */
+static inline int mustache_write_text(mustache_section_s *section, char *text,
+                                      uint32_t len, uint8_t escape) {
+  mustache__builder_stack_s *s = mustache___section2stack(section);
+  if (escape)
+    return mustache__write_escaped(s, text, len);
+    /* TODO */
+#if MUSTACHE_USE_DYNAMIC_PADDING
+  char *end = memchr(text, '\n', len);
+  while (len && end) {
+    ++end;
+    const uint32_t slice_len = end - text;
+    if (mustache_on_text(&s->stack[s->index].sec, text, slice_len) == -1)
+      return -1;
+    text = end;
+    len -= slice_len;
+    end = memchr(text, '\n', len);
+    if (mustache__write_padding(s) == -1)
+      return -1;
+  }
+  if (len && mustache_on_text(&s->stack[s->index].sec, text, len) == -1)
+    return -1;
+#else
+  if (mustache_on_text(&s->stack[s->index].sec, text, len) == -1)
+    return -1;
+
+#endif
+  return 0;
+}
+
+/* *****************************************************************************
+Internal Helpers
+***************************************************************************** */
+
+/* the data segment's new length after loading the the template */
+/* The data segments includes a template header: */
+/*  | 4 bytes template start instruction position | */
+/*  | 2 bytes template name | 4 bytes next template position | */
+/*  | template name (filename) | ...[template data]... */
+/* this allows template data to be reused when repeating a template */
+
+/** a template file data segment header */
+typedef struct {
+  const char *filename;  /* template file name */
+  uint32_t inst_start;   /* start position for instructions */
+  uint32_t next;         /* next template position (absolute) */
+  uint16_t filename_len; /* file name length */
+  uint16_t path_len;     /* if the file is in a folder, this marks the '/' */
+} mustache__data_segment_s;
+
+/* data segment serialization, returns the number of bytes written. */
+static inline size_t
+mustache__data_segment_write(uint8_t *dest, mustache__data_segment_s data) {
+  dest[0] = 0xFF & data.inst_start;
+  dest[1] = 0xFF & (data.inst_start >> 1);
+  dest[2] = 0xFF & (data.inst_start >> 2);
+  dest[3] = 0xFF & (data.inst_start >> 3);
+  dest[4] = 0xFF & data.next;
+  dest[5] = 0xFF & (data.next >> 1);
+  dest[6] = 0xFF & (data.next >> 2);
+  dest[7] = 0xFF & (data.next >> 3);
+  dest[8] = 0xFF & data.filename_len;
+  dest[9] = 0xFF & (data.filename_len >> 1);
+  dest[10] = 0xFF & data.path_len;
+  dest[11] = 0xFF & (data.path_len >> 1);
+  if (data.filename_len)
+    memcpy(dest + 12, data.filename, data.filename_len);
+  (dest + 12)[data.filename_len] = 0;
+  return 13 + data.filename_len;
+}
+
+static inline size_t mustache__data_segment_length(size_t filename_len) {
+  return 13 + filename_len;
+}
+
+/* data segment serialization, reads data from raw stream. */
+static inline mustache__data_segment_s
+mustache__data_segment_read(uint8_t *data) {
+  mustache__data_segment_s s = {
+      .filename = (char *)(data + 12),
+      .inst_start = ((uint32_t)data[0] | ((uint32_t)data[1] << 1) |
+                     ((uint32_t)data[2] << 2) | ((uint32_t)data[3] << 3)),
+      .next = ((uint32_t)data[4] | ((uint32_t)data[5] << 1) |
+               ((uint32_t)data[6] << 2) | ((uint32_t)data[7] << 3)),
+      .filename_len = ((uint16_t)data[8] | ((uint16_t)data[9] << 1)),
+      .path_len = ((uint16_t)data[10] | ((uint16_t)data[11] << 1)),
+  };
+  return s;
+}
+
+static inline void mustache__stand_alone_adjust(mustache__loader_stack_s *s,
+                                                uint32_t stand_alone) {
+  if (!stand_alone)
+    return;
+  /* adjust reading position */
+  s->stack[s->index].data_pos +=
+      1 + (s->data[s->stack[s->index].data_pos] == '\r');
+  /* remove any padding from the beginning of the line */
+  if (s->m->u.read_only.intruction_count &&
+      s->i[s->m->u.read_only.intruction_count - 1].instruction ==
+          MUSTACHE_WRITE_TEXT) {
+    mustache__instruction_s *ins =
+        s->i + s->m->u.read_only.intruction_count - 1;
+    if (ins->data.name_len <= (stand_alone >> 1))
+      --s->m->u.read_only.intruction_count;
+    else
+      ins->data.name_len -= (stand_alone >> 1);
+  }
+}
+
+/* pushes an instruction to the instruction array */
+static inline int mustache__instruction_push(mustache__loader_stack_s *s,
+                                             mustache__instruction_s inst) {
+  if (s->m->u.read_only.intruction_count >= INT32_MAX)
+    goto instructions_too_long;
+  if (s->i_capa <= s->m->u.read_only.intruction_count) {
+    s->m = realloc(s->m, sizeof(*s->m) + (sizeof(*s->i) * (s->i_capa + 32)));
+    MUSTACHE_ASSERT(s->m, "Mustache memory allocation failed");
+    s->i_capa += 32;
+    s->i = MUSTACH2INSTRUCTIONS(s->m);
+  }
+  s->i[s->m->u.read_only.intruction_count] = inst;
+  ++s->m->u.read_only.intruction_count;
+  return 0;
+instructions_too_long:
+  *s->err = MUSTACHE_ERR_TOO_DEEP;
+  return -1;
+}
+
+/* pushes text and padding instruction to the instruction array */
+static inline int mustache__push_text_instruction(mustache__loader_stack_s *s,
+                                                  uint32_t pos, uint32_t len) {
+  /* always push padding instructions, in case or recursion with padding */
+  // if (!s->padding) {
+  //   /* no padding, push text, as is */
+  //   return mustache__instruction_push(
+  //       s, (mustache__instruction_s){
+  //              .instruction = MUSTACHE_WRITE_TEXT,
+  //              .data = {.name_pos = pos, .name_len = len},
+  //          });
+  // }
+  /* insert padding instruction after each new line */
+  for (;;) {
+    /* seek new line markers */
+    char *start = s->data + pos;
+    char *end = memchr(s->data + pos, '\n', len);
+    if (!end)
+      break;
+    /* offset marks the line's length */
+    const size_t offset = (end - start) + 1;
+    /* push text and padding instructions */
+    if (mustache__instruction_push(
+            s,
+            (mustache__instruction_s){
+                .instruction = MUSTACHE_WRITE_TEXT,
+                .data = {.name_pos = pos, .name_len = offset},
+            }) == -1 ||
+        mustache__instruction_push(s, (mustache__instruction_s){
+                                          .instruction = MUSTACHE_PADDING_WRITE,
+                                      }) == -1)
+      return -1;
+    pos += offset;
+    len -= offset;
+  }
+  /* done? */
+  if (!len)
+    return 0;
+  /* write any text that doesn't terminate in the EOL marker */
+  return mustache__instruction_push(
+      s, (mustache__instruction_s){
+             .instruction = MUSTACHE_WRITE_TEXT,
+             .data = {.name_pos = pos, .name_len = len},
+         });
+}
+
+/*
+ * Returns the instruction's position if the template is already existing.
+ *
+ * Returns `(uint32_t)-1` if the template is missing (not loaded, yet).
+ */
+static inline uint32_t mustache__file_is_loaded(mustache__loader_stack_s *s,
+                                                char *name, size_t name_len) {
+  char *data = s->data;
+  const char *end = data + s->m->u.read_only.data_length;
+  while (data < end) {
+    mustache__data_segment_s seg = mustache__data_segment_read((uint8_t *)data);
+    if (seg.filename_len == name_len && !memcmp(seg.filename, name, name_len))
+      return seg.inst_start;
+    data += seg.next;
+  }
+  return (uint32_t)-1;
+}
+
+static inline ssize_t mustache__load_data(mustache__loader_stack_s *s,
+                                          const char *name, size_t name_len,
+                                          const char *data, size_t data_len) {
+  const size_t old_len = s->data_len;
+  if (old_len + data_len > UINT32_MAX)
+    goto too_long;
+  s->data = realloc(s->data, old_len + data_len +
+                                 mustache__data_segment_length(name_len) + 1);
+  MUSTACHE_ASSERT(s->data,
+                  "failed to allocate memory for mustache template data");
+  size_t path_len = name_len;
+  while (path_len) {
+    --path_len;
+    if (name[path_len] == '/' || name[path_len] == '\\') {
+      ++path_len;
+      break;
+    }
+  }
+  mustache__data_segment_write(
+      (uint8_t *)s->data + old_len,
+      (mustache__data_segment_s){
+          .filename = name,
+          .filename_len = name_len,
+          .inst_start = s->m->u.read_only.intruction_count,
+          .next =
+              s->data_len + data_len + mustache__data_segment_length(name_len),
+          .path_len = path_len,
+      });
+  if (data) {
+    memcpy(s->data + old_len + mustache__data_segment_length(name_len), data,
+           data_len);
+  }
+  s->data_len += data_len + mustache__data_segment_length(name_len);
+  s->data[s->data_len] = 0;
+  s->m->u.read_only.data_length = s->data_len;
+
+  mustache__instruction_push(
+      s, (mustache__instruction_s){.instruction = MUSTACHE_SECTION_START});
+  /* advance stack frame */
+  ++s->index;
+  if (s->index >= MUSTACHE_NESTING_LIMIT)
+    goto too_long;
+  s->stack[s->index].data_pos =
+      old_len + mustache__data_segment_length(name_len);
+  s->stack[s->index].data_start = old_len;
+  s->stack[s->index].data_end = s->data_len;
+  /* reset delimiters */
+  s->stack[s->index].del_start_len = 2;
+  s->stack[s->index].del_end_len = 2;
+  s->stack[s->index].del_start[0] = s->stack[s->index].del_start[1] = '{';
+  s->stack[s->index].del_start[2] = 0;
+  s->stack[s->index].del_end[0] = s->stack[s->index].del_end[1] = '}';
+  s->stack[s->index].del_end[2] = 0;
+  s->stack[s->index].open_sections = 0;
+  return data_len;
+too_long:
+  *s->err = MUSTACHE_ERR_TOO_DEEP;
+  return -1;
+}
+
+static inline ssize_t mustache__load_file(mustache__loader_stack_s *s,
+                                          const char *name, size_t name_len) {
+  struct stat f_data;
+  uint16_t i = s->index;
+  uint32_t old_path_len = 0;
+  if (!name_len) {
+    goto name_missing_error;
+  }
+  if (name_len >= 8192)
+    goto name_length_error;
+  /* test file names by walking the stack backwards and matching paths */
+  do {
+    mustache__data_segment_s seg;
+    if (s->data)
+      seg = mustache__data_segment_read((uint8_t *)s->data +
+                                        s->stack[i].data_start);
+    else
+      seg = (mustache__data_segment_s){
+          .path_len = 0,
+      };
+    /* did we test this path for the file? */
+    if (old_path_len && (old_path_len == seg.path_len &&
+                         !memcmp(s->path, seg.filename, old_path_len))) {
+      continue;
+    }
+    old_path_len = seg.path_len;
+    /* make sure s->path capacity is enough. */
+    if (s->path_capa < seg.path_len + name_len + 10) {
+      s->path = realloc(s->path, seg.path_len + name_len + 10);
+      MUSTACHE_ASSERT(s->path,
+                      "failed to allocate memory for mustache template data");
+      s->path_capa = seg.path_len + name_len + 10;
+    }
+    /* if testing local folder, there's no need to keep looping */
+    if (!seg.path_len) {
+      i = 1;
+    } else {
+      memcpy(s->path, seg.filename, seg.path_len);
+    }
+    /* copy name to path */
+    memcpy(s->path + seg.path_len, name, name_len);
+    s->path[name_len + seg.path_len] = 0;
+    /* test if file exists */
+    if (!stat(s->path, &f_data) && S_ISREG(f_data.st_mode)) {
+      old_path_len = name_len + seg.path_len;
+      goto file_found;
+    }
+    /* add default extension  */
+    memcpy(s->path + seg.path_len + name_len, ".mustache", 9);
+    s->path[name_len + seg.path_len + 9] = 0;
+    /* test if new filename file exists */
+    if (!stat(s->path, &f_data) && S_ISREG(f_data.st_mode)) {
+      old_path_len = name_len + seg.path_len + 9;
+      goto file_found;
+    }
+  } while (--i);
+
+  /* test if the file is "virtual" (only true for the first template loaded) */
+  if (s->data) {
+    mustache__data_segment_s seg =
+        mustache__data_segment_read((uint8_t *)s->data);
+    if (seg.filename_len == name_len && !memcmp(seg.filename, name, name_len)) {
+      /* this name points to the original (root) template, and it's virtual */
+      if (mustache__instruction_push(
+              s, (mustache__instruction_s){
+                     .instruction = MUSTACHE_SECTION_GOTO,
+                     .data =
+                         {
+                             .len = 0,
+                             .end = s->m->u.read_only.intruction_count,
+                         },
+                 }))
+        goto unknown_error;
+      return 0;
+    }
+  }
+
+#if MUSTACHE_FAIL_ON_MISSING_TEMPLATE
+  *s->err = MUSTACHE_ERR_FILE_NOT_FOUND;
+  return -1;
+#else
+  return 0;
+#endif
+
+file_found:
+  if (f_data.st_size >= INT32_MAX) {
+    goto file_too_big;
+  } else if (f_data.st_size == 0) {
+    /* empty, do nothing */
+    return 0;
+  } else {
+    /* test if the file was previously loaded */
+    uint32_t pre_existing = mustache__file_is_loaded(s, s->path, old_path_len);
+    if (pre_existing != (uint32_t)-1) {
+      if (mustache__instruction_push(
+              s, (mustache__instruction_s){
+                     .instruction = MUSTACHE_SECTION_GOTO,
+                     .data =
+                         {
+                             .len = pre_existing,
+                             .end = s->m->u.read_only.intruction_count,
+                         },
+                 })) {
+        goto unknown_error;
+      }
+      return 0;
+    }
+  }
+  if (mustache__load_data(s, s->path, old_path_len, NULL, f_data.st_size) == -1)
+    goto unknown_error;
+  int fd = open(s->path, O_RDONLY);
+  if (fd == -1)
+    goto file_err;
+  if (pread(fd, s->data + s->data_len - f_data.st_size, f_data.st_size, 0) !=
+      f_data.st_size)
+    goto file_err;
+  close(fd);
+  return f_data.st_size;
+
+name_missing_error:
+  *s->err = MUSTACHE_ERR_FILE_NAME_TOO_SHORT;
+  return -1;
+
+name_length_error:
+  *s->err = MUSTACHE_ERR_FILE_NAME_TOO_LONG;
+  return -1;
+
+file_too_big:
+  *s->err = MUSTACHE_ERR_FILE_TOO_BIG;
+  return -1;
+
+file_err:
+  *s->err = MUSTACHE_ERR_UNKNOWN;
+  return -1;
+
+unknown_error:
+  return -1;
+}
+
+/* *****************************************************************************
+Calling the instrustion list (using the template engine)
+***************************************************************************** */
+
+/*
+ * This function reviews the instructions listed at the end of the mustache_s
+ * and performs any callbacks necessary.
+ *
+ * The `mustache_s` data is looks like this:
+ *
+ *  - header (the `mustache_s` struct): lists the length of the instruction
+ *    array and data segments.
+ *  - Instruction array: lists all the instructions extracted from the
+ *    template(s) (an array of `mustache__instruction_s`).
+ *  - Data segment: text and data related to the instructions.
+ *
+ * The instructions, much like machine code, might loop or jump. This is why the
+ * function keeps a stack of sorts. This allows the code to avoid recursion and
+ * minimize any risk of stack overflow caused by recursive templates.
+ */
+MUSTACHE_FUNC int(mustache_build)(mustache_build_args_s args) {
+  mustache_error_en err_if_missing;
+  if (!args.err)
+    args.err = &err_if_missing;
+  if (!args.mustache) {
+    goto user_error;
+  }
+  /* extract the instruction array and data segment from the mustache_s */
+  mustache__instruction_s *instructions = MUSTACH2INSTRUCTIONS(args.mustache);
+  char *const data = MUSTACH2DATA(args.mustache);
+  mustache__builder_stack_s s;
+  s.data = args.mustache;
+  s.pos = 0;
+  s.index = 0;
+  s.padding = 0;
+  s.stack[0] = (mustache__section_stack_frame_s){
+      .sec =
+          {
+              .udata1 = args.udata1,
+              .udata2 = args.udata2,
+          },
+      .start = 0,
+      .end = instructions[0].data.end,
+      .index = 0,
+      .count = 0,
+      .frame = 0,
+  };
+  while ((uintptr_t)(instructions + s.pos) < (uintptr_t)data) {
+    switch (instructions[s.pos].instruction) {
+    case MUSTACHE_WRITE_TEXT:
+      if (mustache_on_text(&s.stack[s.index].sec,
+                           data + instructions[s.pos].data.name_pos,
+                           instructions[s.pos].data.name_len))
+        goto user_error;
+      break;
+      /* fallthrough */
+    case MUSTACHE_WRITE_ARG:
+      if (mustache_on_arg(&s.stack[s.index].sec,
+                          data + instructions[s.pos].data.name_pos,
+                          instructions[s.pos].data.name_len, 1))
+        goto user_error;
+      break;
+    case MUSTACHE_WRITE_ARG_UNESCAPED:
+      if (mustache_on_arg(&s.stack[s.index].sec,
+                          data + instructions[s.pos].data.name_pos,
+                          instructions[s.pos].data.name_len, 0))
+        goto user_error;
+      break;
+      /* fallthrough */
+    case MUSTACHE_SECTION_GOTO:
+    /* fallthrough */
+    case MUSTACHE_SECTION_START:
+    case MUSTACHE_SECTION_START_INV:
+      /* advance stack*/
+      if (s.index + 1 >= MUSTACHE_NESTING_LIMIT) {
+        if (args.err)
+          *args.err = MUSTACHE_ERR_TOO_DEEP;
+        goto error;
+      }
+      s.stack[s.index + 1].sec = s.stack[s.index].sec;
+      ++s.index;
+      s.stack[s.index].start =
+          (instructions[s.pos].instruction == MUSTACHE_SECTION_GOTO
+               ? instructions[s.pos].data.len
+               : s.pos);
+      s.stack[s.index].end = instructions[s.pos].data.end;
+      s.stack[s.index].frame = s.index;
+      s.stack[s.index].index = 0;
+      s.stack[s.index].count = 1;
+
+      /* test section count */
+      if (instructions[s.pos].data.name_pos) {
+        /* this is a named section, it should be tested against user data */
+        int32_t val = mustache_on_section_test(
+            &s.stack[s.index].sec, data + instructions[s.pos].data.name_pos,
+            instructions[s.pos].data.name_len,
+            instructions[s.pos].instruction == MUSTACHE_SECTION_START);
+        if (val == -1) {
+          goto user_error;
+        }
+        if (instructions[s.pos].instruction == MUSTACHE_SECTION_START_INV) {
+          /* invert test */
+          val = (val == 0);
+        }
+        s.stack[s.index].count = (uint32_t)val;
+      }
+      /* fallthrough  */
+    case MUSTACHE_SECTION_END:
+      /* loop section or continue */
+      if (s.stack[s.index].index < s.stack[s.index].count) {
+        /* repeat / start section */
+        s.pos = s.stack[s.index].start;
+        s.stack[s.index].sec = s.stack[s.index - 1].sec;
+        /* review user callback (if it's a named section) */
+        if (instructions[s.pos].data.name_pos &&
+            mustache_on_section_start(&s.stack[s.index].sec,
+                                      data + instructions[s.pos].data.name_pos,
+                                      instructions[s.pos].data.name_len,
+                                      s.stack[s.index].index) == -1)
+          goto user_error;
+        /* skip padding instructions in GOTO tags (recursive partials) */
+        if (instructions[s.pos].instruction == MUSTACHE_SECTION_GOTO)
+          ++s.pos;
+        ++s.stack[s.index].index;
+        break;
+      }
+      s.pos = s.stack[s.index].end;
+      --s.index;
+      break;
+    case MUSTACHE_PADDING_PUSH:
+      s.padding = s.pos;
+      break;
+    case MUSTACHE_PADDING_POP:
+      s.padding = instructions[s.padding].data.end;
+      break;
+    case MUSTACHE_PADDING_WRITE:
+      for (uint32_t i = s.padding; i; i = instructions[i].data.end) {
+        if (mustache_on_text(&s.stack[s.index].sec,
+                             data + instructions[i].data.name_pos,
+                             instructions[i].data.name_len))
+          goto user_error;
+      }
+      break;
+    default:
+      /* not a valid engine */
+      fprintf(stderr, "ERROR: invalid mustache instruction set detected (wrong "
+                      "`mustache_s`?)\n");
+      if (args.err) {
+        *args.err = MUSTACHE_ERR_UNKNOWN;
+      }
+      goto error;
+    }
+    ++s.pos;
+  }
+  *args.err = MUSTACHE_OK;
+  return 0;
+user_error:
+  *args.err = MUSTACHE_ERR_USER_ERROR;
+error:
+  mustache_on_formatting_error(args.udata1, args.udata2);
+  return -1;
+}
+
+/* *****************************************************************************
+Building the instrustion list (parsing the template)
+***************************************************************************** */
+
+/* The parsing implementation, converts a template to an instruction array */
+MUSTACHE_FUNC mustache_s *(mustache_load)(mustache_load_args_s args) {
+  mustache_error_en err_if_missing;
+  mustache__loader_stack_s s;
+  uint8_t flag = 0;
+
+  if (!args.err)
+    args.err = &err_if_missing;
+  s.path_capa = 0;
+  s.path = NULL;
+  s.data = NULL;
+  s.data_len = 0;
+  s.i = NULL;
+  s.i_capa = 32;
+  s.index = 0;
+  s.padding = 0;
+  s.m = malloc(sizeof(*s.m) + (sizeof(*s.i) * 32));
+  MUSTACHE_ASSERT(s.m, "failed to allocate memory for mustache data");
+  s.m->u.read_only_pt = 0;
+  s.m->u.read_only.data_length = 0;
+  s.m->u.read_only.intruction_count = 0;
+  s.i = MUSTACH2INSTRUCTIONS(s.m);
+  s.err = args.err;
+
+  if (!args.filename_len && args.filename)
+    args.filename_len = strlen(args.filename);
+
+  if (args.data) {
+    if (mustache__load_data(&s, args.filename, args.filename_len, args.data,
+                            args.data_len) == -1) {
+      goto error;
+    }
+  } else {
+    if (mustache__load_file(&s, args.filename, args.filename_len) == -1) {
+      goto error;
+    }
+  }
+
+  /* loop while there are templates to be parsed on the stack */
+  while (s.index) {
+    /* parsing loop */
+    while (s.stack[s.index].data_pos < s.stack[s.index].data_end) {
+      /* stand-alone tag flag, also containes padding length after bit 1 */
+      uint32_t stand_alone = 0;
+      uint32_t stand_alone_pos = 0;
+      /* start parsing at current position */
+      const char *start = s.data + s.stack[s.index].data_pos;
+      /* find the next instruction (beg == beginning) */
+      char *beg = strstr(start, s.stack[s.index].del_start);
+      const char *org_beg = beg;
+      if (!beg || beg >= s.data + s.stack[s.index].data_end) {
+        /* no instructions left, only text */
+        mustache__push_text_instruction(&s, s.stack[s.index].data_pos,
+                                        s.stack[s.index].data_end -
+                                            s.stack[s.index].data_pos);
+        s.stack[s.index].data_pos = s.stack[s.index].data_end;
+        continue;
+      }
+      if (beg != start) {
+        /* there's text before the instruction */
+        mustache__push_text_instruction(&s, s.stack[s.index].data_pos,
+                                        (uint32_t)(uintptr_t)(beg - start));
+      }
+      /* move beg (reading position) after the delimiter */
+      beg += s.stack[s.index].del_start_len;
+      /* seek the end of the instruction delimiter */
+      char *end = strstr(beg, s.stack[s.index].del_end);
+      if (!end || end >= s.data + s.stack[s.index].data_end) {
+        /* delimiter not closed */
+        *args.err = MUSTACHE_ERR_CLOSURE_MISMATCH;
+        goto error;
+      }
+
+      /* update reading position in the stack */
+      s.stack[s.index].data_pos = (end - s.data) + s.stack[s.index].del_end_len;
+
+      /* Test for stand-alone tags */
+      if (!end[s.stack[s.index].del_end_len] ||
+          end[s.stack[s.index].del_end_len] == '\n' ||
+          (end[s.stack[s.index].del_end_len] == '\r' &&
+           end[1 + s.stack[s.index].del_end_len] == '\n')) {
+        char *pad = beg - (s.stack[s.index].del_start_len + 1);
+        while (pad >= start && (pad[0] == ' ' || pad[0] == '\t'))
+          --pad;
+        if (pad[0] == '\n' || pad[0] == 0) {
+          /* Yes, this a stand-alone tag, store padding length + flag  */
+          ++pad;
+          stand_alone_pos = pad - s.data;
+          stand_alone =
+              ((beg - (pad + s.stack[s.index].del_start_len)) << 1) | 1;
+        }
+      }
+
+      /* parse instruction content */
+      flag = 1;
+
+      switch (beg[0]) {
+      case '!':
+        /* comment, do nothing... almost */
+        mustache__stand_alone_adjust(&s, stand_alone);
+        break;
+
+      case '=':
+        /* define new seperators */
+        mustache__stand_alone_adjust(&s, stand_alone);
+        ++beg;
+        --end;
+        if (end[0] != '=') {
+          *args.err = MUSTACHE_ERR_CLOSURE_MISMATCH;
+          goto error;
+        }
+        --end;
+        MUSTACHE_IGNORE_WHITESPACE(beg, 1);
+        MUSTACHE_IGNORE_WHITESPACE(end, -1);
+        ++end;
+        {
+          char *div = beg;
+          while (div < end && !isspace(*div)) {
+            ++div;
+          }
+          if (div == end || div == beg) {
+            *args.err = MUSTACHE_ERR_CLOSURE_MISMATCH;
+            goto error;
+          }
+          if (div - beg >= MUSTACHE_DELIMITER_LENGTH_LIMIT) {
+            *args.err = MUSTACHE_ERR_DELIMITER_TOO_LONG;
+            goto error;
+          }
+          /* copy starting delimiter */
+          s.stack[s.index].del_start_len = div - beg;
+          for (size_t i = 0; i < s.stack[s.index].del_start_len; ++i) {
+            s.stack[s.index].del_start[i] = beg[i];
+          }
+          s.stack[s.index].del_start[s.stack[s.index].del_start_len] = 0;
+
+          ++div;
+          MUSTACHE_IGNORE_WHITESPACE(div, 1);
+          if (div == end) {
+            *args.err = MUSTACHE_ERR_CLOSURE_MISMATCH;
+            goto error;
+          }
+          if (end - div >= MUSTACHE_DELIMITER_LENGTH_LIMIT) {
+            *args.err = MUSTACHE_ERR_DELIMITER_TOO_LONG;
+            goto error;
+          }
+          /* copy ending delimiter */
+          s.stack[s.index].del_end_len = end - div;
+          for (size_t i = 0; i < s.stack[s.index].del_end_len; ++i) {
+            s.stack[s.index].del_end[i] = div[i];
+          }
+          s.stack[s.index].del_end[s.stack[s.index].del_end_len] = 0;
+        }
+        break;
+
+      case '^':
+        /* start inverted section */
+        flag = 0;
+        /* fallthrough */
+      case '#':
+        /* start section (or inverted section) */
+        mustache__stand_alone_adjust(&s, stand_alone);
+        ++beg;
+        --end;
+        MUSTACHE_IGNORE_WHITESPACE(beg, 1);
+        MUSTACHE_IGNORE_WHITESPACE(end, -1);
+        ++end;
+
+        ++s.stack[s.index].open_sections;
+        if (s.stack[s.index].open_sections >= MUSTACHE_NESTING_LIMIT) {
+          *args.err = MUSTACHE_ERR_TOO_DEEP;
+          goto error;
+        }
+        if (beg - s.data >= UINT16_MAX) {
+          *args.err = MUSTACHE_ERR_NAME_TOO_LONG;
+        }
+        if (mustache__instruction_push(
+                &s,
+                (mustache__instruction_s){
+                    .instruction = (flag ? MUSTACHE_SECTION_START
+                                         : MUSTACHE_SECTION_START_INV),
+                    .data = {
+                        .name_pos = beg - s.data,
+                        .name_len = end - beg,
+                        .offset = s.stack[s.index].data_pos - (beg - s.data),
+                    }})) {
+          goto error;
+        }
+        break;
+
+      case '>':
+        /* partial template - search data for loaded template or load new */
+        mustache__stand_alone_adjust(&s, stand_alone);
+        if ((stand_alone >> 1)) {
+          /* TODO: add padding markers */
+          if (mustache__instruction_push(
+                  &s, (mustache__instruction_s){
+                          .instruction = MUSTACHE_PADDING_PUSH,
+                          .data = {
+                              .name_pos = stand_alone_pos,
+                              .name_len = (stand_alone >> 1),
+                              .end = s.padding,
+                          }})) {
+            goto error;
+          }
+          s.padding = s.m->u.read_only.intruction_count - 1;
+        }
+        ++beg;
+        --end;
+        MUSTACHE_IGNORE_WHITESPACE(beg, 1);
+        MUSTACHE_IGNORE_WHITESPACE(end, -1);
+        ++end;
+        ssize_t loaded = mustache__load_file(&s, beg, end - beg);
+        if (loaded == -1)
+          goto error;
+        /* Add latest padding section to text */
+        if ((stand_alone >> 1)) {
+          if (loaded)
+            mustache__instruction_push(
+                &s, (mustache__instruction_s){
+                        .instruction = MUSTACHE_WRITE_TEXT,
+                        .data =
+                            {
+                                .name_pos = stand_alone_pos,
+                                .name_len = (stand_alone >> 1),
+                            },
+                    });
+          else if (mustache__instruction_push(
+                       &s, (mustache__instruction_s){.instruction =
+                                                         MUSTACHE_PADDING_POP}))
+            goto error;
+        }
+        break;
+
+      case '/':
+        /* section end */
+        mustache__stand_alone_adjust(&s, stand_alone);
+        ++beg;
+        --end;
+        MUSTACHE_IGNORE_WHITESPACE(beg, 1);
+        MUSTACHE_IGNORE_WHITESPACE(end, -1);
+        ++end;
+        if (!s.stack[s.index].open_sections) {
+          *args.err = MUSTACHE_ERR_CLOSURE_MISMATCH;
+          goto error;
+        } else {
+          uint32_t pos = s.m->u.read_only.intruction_count;
+          uint32_t nested = 0;
+          do {
+            --pos;
+            if (s.i[pos].instruction == MUSTACHE_SECTION_END)
+              ++nested;
+            else if (s.i[pos].instruction == MUSTACHE_SECTION_START ||
+                     s.i[pos].instruction == MUSTACHE_SECTION_START_INV) {
+              if (nested) {
+                --nested;
+              } else {
+                /* test instruction closure */
+                if (s.i[pos].data.name_len != end - beg ||
+                    memcmp(beg, s.data + s.i[pos].data.name_pos,
+                           s.i[pos].data.name_len)) {
+                  *args.err = MUSTACHE_ERR_CLOSURE_MISMATCH;
+                  goto error;
+                }
+                /* update initial instruction (do this before adding closure) */
+                s.i[pos].data.end = s.m->u.read_only.intruction_count;
+                s.i[pos].data.len = org_beg - (s.data + s.i[pos].data.name_pos +
+                                               s.i[pos].data.offset);
+                /* add closure instruction */
+                mustache__instruction_push(
+                    &s, (mustache__instruction_s){.instruction =
+                                                      MUSTACHE_SECTION_END,
+                                                  .data = s.i[pos].data});
+                /* update closure count */
+                --s.stack[s.index].open_sections;
+                /* stop loop */
+                pos = 0;
+                beg = NULL;
+              }
+            }
+          } while (pos);
+          if (beg) {
+            *args.err = MUSTACHE_ERR_CLOSURE_MISMATCH;
+            goto error;
+          }
+        }
+        break;
+
+      case '{':
+        /* step the read position forward if the ending was '}}}' */
+        if (s.data[s.stack[s.index].data_pos] == '}' &&
+            s.stack[s.index].del_end[0] == '}' &&
+            s.stack[s.index].del_end[s.stack[s.index].del_end_len - 1] == '}') {
+          ++s.stack[s.index].data_pos;
+        }
+        /* fallthrough */
+      case '&':
+        /* unescaped variable data */
+        flag = 0;
+        /* fallthrough */
+      case ':': /*fallthrough*/
+      case '<': /*fallthrough*/
+        ++beg;  /*fallthrough*/
+      default:
+        --end;
+        MUSTACHE_IGNORE_WHITESPACE(beg, 1);
+        MUSTACHE_IGNORE_WHITESPACE(end, -1);
+        ++end;
+        mustache__instruction_push(
+            &s, (mustache__instruction_s){
+                    .instruction = (flag ? MUSTACHE_WRITE_ARG
+                                         : MUSTACHE_WRITE_ARG_UNESCAPED),
+                    .data = {.name_pos = beg - s.data, .name_len = end - beg}});
+        break;
+      }
+    }
+    /* make sure all sections were closed */
+    if (s.stack[s.index].open_sections) {
+      *args.err = MUSTACHE_ERR_CLOSURE_MISMATCH;
+      goto error;
+    }
+    /* move padding from section tail to post closure (adjust for padding
+     * changes) */
+    flag = 0;
+    if (s.m->u.read_only.intruction_count &&
+        s.i[s.m->u.read_only.intruction_count - 1].instruction ==
+            MUSTACHE_PADDING_WRITE) {
+      --s.m->u.read_only.intruction_count;
+      flag = 1;
+    }
+    /* mark section length */
+    mustache__data_segment_s seg = mustache__data_segment_read(
+        (uint8_t *)s.data + s.stack[s.index].data_start);
+    s.i[seg.inst_start].data.end = s.m->u.read_only.intruction_count;
+    /* add instruction closure */
+    mustache__instruction_push(
+        &s, (mustache__instruction_s){.instruction = MUSTACHE_SECTION_END});
+    /* TODO: pop any padding (if exists) */
+    if (s.padding && s.padding + 1 == seg.inst_start) {
+      s.padding = s.i[s.padding].data.end;
+      mustache__instruction_push(&s, (mustache__instruction_s){
+                                         .instruction = MUSTACHE_PADDING_POP,
+                                     });
+    }
+    /* complete padding switch*/
+    if (flag) {
+      mustache__instruction_push(&s, (mustache__instruction_s){
+                                         .instruction = MUSTACHE_PADDING_WRITE,
+                                     });
+      flag = 0;
+    }
+    /* pop stack */
+    --s.index;
+  }
+
+  s.m = realloc(s.m, sizeof(*s.m) +
+                         (sizeof(*s.i) * s.m->u.read_only.intruction_count) +
+                         s.data_len);
+  MUSTACHE_ASSERT(s.m,
+                  "failed to allocate memory for consolidated mustache data");
+  memcpy(MUSTACH2DATA(s.m), s.data, s.data_len);
+  free(s.data);
+  free(s.path);
+
+  *args.err = MUSTACHE_OK;
+  return s.m;
+
+error:
+  free(s.data);
+  free(s.path);
+  free(s.m);
+  return NULL;
+}
+
+#endif /* INCLUDE_MUSTACHE_IMPLEMENTATION */
+
+#undef MUSTACHE_FUNC
+#undef MUSTACH2INSTRUCTIONS
+#undef MUSTACH2DATA
+#undef MUSTACHE_OBJECT_OFFSET
+#undef MUSTACHE_IGNORE_WHITESPACE
+
+#endif /* H_MUSTACHE_LOADR_H */