iodine 0.7.11 → 0.7.12

data/ext/iodine/fio.h

@@ -182,8 +182,8 @@ Version and helper macros
 
 #ifndef FIO_IGNORE_MACRO
 /**
- * This is used internally to ignor macros that shadow functions (avoiding named
- * arguments when required.
+ * This is used internally to ignore macros that shadow functions (avoiding
+ * named arguments when required).
  */
 #define FIO_IGNORE_MACRO
 #endif
@@ -298,6 +298,18 @@ Memory pool / custom allocator for short lived objects
 
 ***************************************************************************** */
 
+/* inform the compiler that the returned value is aligned on 16 byte marker */
+#if FIO_FORCE_MALLOC
+#define FIO_ALIGN
+#define FIO_ALIGN_NEW
+#elif __clang__ || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 8)
+#define FIO_ALIGN __attribute__((assume_aligned(16)))
+#define FIO_ALIGN_NEW __attribute__((malloc, assume_aligned(16)))
+#else
+#define FIO_ALIGN
+#define FIO_ALIGN_NEW
+#endif
+
 /**
  * Allocates memory using a per-CPU core block memory pool.
  * Memory is zeroed out.
@@ -305,7 +317,7 @@ Memory pool / custom allocator for short lived objects
  * Allocations above FIO_MEMORY_BLOCK_ALLOC_LIMIT (12,288 bytes when using 32Kb
  * blocks) will be redirected to `mmap`, as if `fio_mmap` was called.
  */
-void *fio_malloc(size_t size);
+void *FIO_ALIGN_NEW fio_malloc(size_t size);
 
 /**
  * same as calling `fio_malloc(size_per_unit * unit_count)`;
@@ -313,7 +325,7 @@ void *fio_malloc(size_t size);
  * Allocations above FIO_MEMORY_BLOCK_ALLOC_LIMIT (12,288 bytes when using 32Kb
  * blocks) will be redirected to `mmap`, as if `fio_mmap` was called.
  */
-void *fio_calloc(size_t size_per_unit, size_t unit_count);
+void *FIO_ALIGN_NEW fio_calloc(size_t size_per_unit, size_t unit_count);
 
 /** Frees memory that was allocated using this library. */
 void fio_free(void *ptr);
@@ -322,7 +334,7 @@ void fio_free(void *ptr);
  * Re-allocates memory. An attempt to avoid copying the data is made only for
  * big memory allocations (larger than FIO_MEMORY_BLOCK_ALLOC_LIMIT).
  */
-void *fio_realloc(void *ptr, size_t new_size);
+void *FIO_ALIGN fio_realloc(void *ptr, size_t new_size);
 
 /**
  * Re-allocates memory. An attempt to avoid copying the data is made only for
@@ -330,7 +342,7 @@ void *fio_realloc(void *ptr, size_t new_size);
  *
  * This variation is slightly faster as it might copy less data.
  */
-void *fio_realloc2(void *ptr, size_t new_size, size_t copy_length);
+void *FIO_ALIGN fio_realloc2(void *ptr, size_t new_size, size_t copy_length);
 
 /**
  * Allocates memory directly using `mmap`, this is prefered for objects that
@@ -341,7 +353,7 @@ void *fio_realloc2(void *ptr, size_t new_size, size_t copy_length);
  *
  * `fio_free` can be used for deallocating the memory.
  */
-void *fio_mmap(size_t size);
+void *FIO_ALIGN_NEW fio_mmap(size_t size);
 
 /**
  * When forking is called manually, call this function to reset the facil.io
@@ -349,6 +361,8 @@ void *fio_mmap(size_t size);
  */
 void fio_malloc_after_fork(void);
 
+#undef FIO_ALIGN
+
 #if FIO_FORCE_MALLOC
 #define FIO_MALLOC(size) calloc((size), 1)
 #define FIO_CALLOC(size, units) calloc((size), (units))
@@ -445,15 +459,12 @@ extern int FIO_LOG_LEVEL;
 #define FIO_LOG_STATE(...)
 #endif
 
-#if DEBUG
 #define FIO_ASSERT(cond, ...)                                                  \
   if (!(cond)) {                                                               \
-    FIO_LOG_DEBUG(__VA_ARGS__);                                                \
+    FIO_LOG_FATAL("(" __FILE__ ":" FIO_MACRO2STR(__LINE__) ") "__VA_ARGS__);   \
+    perror("     errno");                                                      \
     exit(-1);                                                                  \
   }
-#else
-#define FIO_ASSERT(...)
-#endif
 
 #ifndef FIO_ASSERT_ALLOC
 /** Tests for an allocation failure. The behavior can be overridden. */
@@ -466,6 +477,17 @@ extern int FIO_LOG_LEVEL;
   }
 #endif
 
+#if DEBUG
+#define FIO_ASSERT_DEBUG(cond, ...)                                            \
+  if (!(cond)) {                                                               \
+    FIO_LOG_DEBUG(__VA_ARGS__);                                                \
+    perror("     errno");                                                      \
+    exit(-1);                                                                  \
+  }
+#else
+#define FIO_ASSERT_DEBUG(...)
+#endif
+
 /* *****************************************************************************
 
 
@@ -564,9 +586,24 @@ void fio_attach(intptr_t uuid, fio_protocol_s *protocol);
  * The old protocol's `on_close` (if any) will be scheduled.
  *
  * On error, the new protocol's `on_close` callback will be called immediately.
+ *
+ * NOTE: before attaching a file descriptor that was created outside of
+ * facil.io's library, make sure it is set to non-blocking mode (see
+ * `fio_set_non_block`). facil.io file descriptors are all non-blocking and it
+ * will assumes this is the case for the attached fd.
  */
 void fio_attach_fd(int fd, fio_protocol_s *protocol);
 
+/**
+ * Sets a socket to non blocking state.
+ *
+ * This will also set the O_CLOEXEC flag for the file descriptor.
+ *
+ * This function is called automatically for the new socket, when using
+ * `fio_accept` or `fio_connect`.
+ */
+int fio_set_non_block(int fd);
+
 /**
  * Returns the maximum number of open files facil.io can handle per worker
  * process.
@@ -926,6 +963,9 @@ intptr_t fio_socket(const char *address, const char *port, uint8_t is_server);
  * `fio_accept` accepts a new socket connection from a server socket - see the
  * server flag on `fio_socket`.
  *
+ * Accepted connection are automatically set to non-blocking mode and the
+ * O_CLOEXEC flag is set.
+ *
  * NOTE: this function does NOT attach the socket to the IO reactor - see
  * `fio_attach`.
  */
@@ -1237,17 +1277,6 @@ typedef struct fio_rw_hook_s {
    * deadlock might occur.
    */
   ssize_t (*write)(intptr_t uuid, void *udata, const void *buf, size_t count);
-  /**
-   * The `before_close` callback is called only once before closing the `uuid`.
-   *
-   * If the function returns a non-zero value, than closure will be delayed
-   * until the `flush` returns 0 (or less). This allows a closure signal to be
-   * sent by the read/write hook when such a signal is required.
-   *
-   * Note: facil.io library functions MUST NEVER be called by any r/w hook, or a
-   * deadlock might occur.
-   * */
-  ssize_t (*before_close)(intptr_t uuid, void *udata);
   /**
    * When implemented, this function will be called to flush any data remaining
    * in the internal buffer.
@@ -1259,6 +1288,18 @@ typedef struct fio_rw_hook_s {
    * deadlock might occur.
    */
   ssize_t (*flush)(intptr_t uuid, void *udata);
+  /**
+   * The `before_close` callback is called only once before closing the `uuid`
+   * and it might not get called at all if an abnormal closure is detected.
+   *
+   * If the function returns a non-zero value, than closure will be delayed
+   * until the `flush` returns 0 (or less). This allows a closure signal to be
+   * sent by the read/write hook when such a signal is required.
+   *
+   * Note: facil.io library functions MUST NEVER be called by any r/w hook, or a
+   * deadlock might occur.
+   * */
+  ssize_t (*before_close)(intptr_t uuid, void *udata);
   /**
    * Called to perform cleanup after the socket was closed or a new read/write
    * hook was set using `fio_rw_hook_set`.
@@ -1499,14 +1540,6 @@ fio_protocol_s *fio_protocol_try_lock(intptr_t uuid, enum fio_protocol_lock_e);
  * details. */
 void fio_protocol_unlock(fio_protocol_s *pr, enum fio_protocol_lock_e);
 
-/**
-Sets a socket to non blocking state.
-
-This function is called automatically for the new socket, when using
-`fio_accept` or `fio_connect`.
-*/
-int fio_set_non_block(int fd);
-
 /* *****************************************************************************
  * Pub/Sub / Cluster Messages API
  *
@@ -2853,18 +2886,21 @@ Embeded Linked List Implementation
 
 /** Removes a node from the containing node. */
 FIO_FUNC inline fio_ls_embd_s *fio_ls_embd_remove(fio_ls_embd_s *node) {
-  if (node->next == node) {
+  if (!node->next || node->next == node) {
     /* never remove the list's head */
     return NULL;
   }
   node->next->prev = node->prev;
   node->prev->next = node->next;
+  node->prev = node->next = node;
   return node;
 }
 
 /** Adds a node to the list's head. */
 FIO_FUNC inline void fio_ls_embd_push(fio_ls_embd_s *dest,
                                       fio_ls_embd_s *node) {
+  if (!dest || !node)
+    return;
   node->prev = dest->prev;
   node->next = dest;
   dest->prev->next = node;
@@ -2907,7 +2943,7 @@ Independent Linked List Implementation
 
 /** Removes an object from the containing node. */
 FIO_FUNC inline void *fio_ls_remove(fio_ls_s *node) {
-  if (node->next == node) {
+  if (!node || node->next == node) {
     /* never remove the list's head */
     return NULL;
   }
@@ -2920,6 +2956,8 @@ FIO_FUNC inline void *fio_ls_remove(fio_ls_s *node) {
 
 /** Adds an object to the list's head. */
 FIO_FUNC inline fio_ls_s *fio_ls_push(fio_ls_s *pos, const void *obj) {
+  if (!pos)
+    return NULL;
   /* prepare item */
   fio_ls_s *item = (fio_ls_s *)malloc(sizeof(*item));
   if (!item) {

data/ext/iodine/fio_cli.c

@@ -40,6 +40,8 @@ typedef struct {
   int unnamed_max;
   int pos;
   int unnamed_count;
+  int argc;
+  char const **argv;
   char const *description;
   char const **names;
 } fio_cli_parser_data_s;
@@ -138,32 +140,29 @@ static void fio_cli_set_arg(cstr_s arg, char const *value, char const *line,
   char const *type = fio_cli_get_line_type(parser, line);
   switch ((size_t)type) {
   case /* FIO_CLI_TYPE_BOOL */ 0x2:
-    if (value &&
-        (value == arg.data + arg.len ||
-         (value == arg.data + arg.len + 1 && arg.data[arg.len] == '='))) {
+    if (value && value != parser->argv[parser->pos + 1]) {
       goto error;
     }
     value = "1";
     break;
   case /* FIO_CLI_TYPE_INT */ 0x3: /* fallthrough */
-  {
-    if (!value)
-      goto error;
-    char const *tmp = value;
-    if (*tmp == '-' || *tmp == '+') {
-      ++tmp;
-    }
-    if (!*tmp) {
-      goto error;
-    }
-    while (*tmp && *tmp >= '0' && *tmp <= '9') {
-      ++tmp;
-    }
-    if (*tmp) {
-      goto error;
+    if (value) {
+      char const *tmp = value;
+      if (*tmp == '-' || *tmp == '+') {
+        ++tmp;
+      }
+      while (*tmp && *tmp >= '0' && *tmp <= '9') {
+        ++tmp;
+      }
+      if (*tmp) {
+        goto error;
+      }
     }
-  }
   case /* FIO_CLI_TYPE_STRING */ 0x1: /* fallthrough */
+    if (!value)
+      goto error;
+    if (!value[0])
+      goto finish;
     break;
   }
 
@@ -183,19 +182,19 @@ static void fio_cli_set_arg(cstr_s arg, char const *value, char const *line,
     }
   }
 
+finish:
+
   /* handle additional argv progress (if value is on separate argv) */
-  if (type != FIO_CLI_TYPE_BOOL && value && value != arg.data + arg.len &&
-      !arg.data[arg.len]) {
-    /* advance the position marker more than once? */
+  if (value && parser->pos < parser->argc &&
+      value == parser->argv[parser->pos + 1])
     ++parser->pos;
-  }
   return;
 
 error: /* handle errors*/
   /* TODO! */
   fprintf(stderr, "\n\r\x1B[31mError:\x1B[0m unknown argument %.*s %s %s\n\n",
           (int)arg.len, arg.data, arg.len ? "with value" : "",
-          value ? value : "(null)");
+          value ? (value[0] ? value : "(empty)") : "(null)");
 print_help:
   fprintf(stderr, "\n%s\n\n",
           parser->description ? parser->description
@@ -307,6 +306,8 @@ void fio_cli_start AVOID_MACRO(int argc, char const *argv[], int unnamed_min,
       .unnamed_min = unnamed_min,
       .unnamed_max = unnamed_max,
       .description = description,
+      .argc = argc,
+      .argv = argv,
       .names = names,
       .pos = 0,
   };

data/ext/iodine/fiobj.h

@@ -16,6 +16,10 @@ License: MIT
 
 #include <fio_siphash.h>
 
+#ifdef H_FACIL_IO_H
+#include <fiobj4fio.h>
+#endif
+
 #if DEBUG
 FIO_INLINE void fiobj_test(void) {
   fprintf(stderr, "\n=== FIOBJ Tests ===\n\n");

data/ext/iodine/fiobj_mustache.c

@@ -6,6 +6,14 @@
 #include <fiobj_mustache.h>
 #include <fiobj_str.h>
 
+#ifndef FIO_IGNORE_MACRO
+/**
+ * This is used internally to ignore macros that shadow functions (avoiding
+ * named arguments when required).
+ */
+#define FIO_IGNORE_MACRO
+#endif
+
 /**
  * Loads a mustache template, converting it into an opaque instruction array.
  *
@@ -20,6 +28,20 @@ mustache_s *fiobj_mustache_load(fio_str_info_s filename) {
   return mustache_load(.filename = filename.data, .filename_len = filename.len);
 }
 
+/**
+ * Loads a mustache template, converting it into an opaque instruction array.
+ *
+ * Returns a pointer to the instruction array.
+ *
+ * The `folder` argument should contain the template's root folder which would
+ * also be used to search for any required partial templates.
+ *
+ * The `filename` argument should contain the template's file name.
+ */
+mustache_s *fiobj_mustache_new FIO_IGNORE_MACRO(mustache_load_args_s args) {
+  return mustache_load FIO_IGNORE_MACRO(args);
+}
+
 /** Free the mustache template */
 void fiobj_mustache_free(mustache_s *mustache) { mustache_free(mustache); }
 
@@ -52,8 +74,10 @@ Mustache Callbacks
 ***************************************************************************** */
 
 /** HTML ecape table, created using the following Ruby Script:
-a = []
-256.times {|i| a[i] = "&\#x#{ i < 16 ? "0#{i.to_s(16)}" : i.to_s(16)};"}
+
+a = (0..255).to_a.map {|i| i.chr }
+# 100.times {|i| a[i] = "&\#x#{ i < 16 ? "0#{i.to_s(16)}" : i.to_s(16)};"}
+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 }
@@ -61,61 +85,58 @@ 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[] = {
-    "&#x00;", "&#x01;", "&#x02;", "&#x03;", "&#x04;", "&#x05;", "&#x06;",
-    "&#x07;", "&#x08;", "&#x09;", "&#x0a;", "&#x0b;", "&#x0c;", "&#x0d;",
-    "&#x0e;", "&#x0f;", "&#x10;", "&#x11;", "&#x12;", "&#x13;", "&#x14;",
-    "&#x15;", "&#x16;", "&#x17;", "&#x18;", "&#x19;", "&#x1a;", "&#x1b;",
-    "&#x1c;", "&#x1d;", "&#x1e;", "&#x1f;", "&#x20;", "&#x21;", "&quot;",
-    "&#x23;", "&#x24;", "&#x25;", "&amp;",  "&#x27;", "&#x28;", "&#x29;",
-    "&#x2a;", "&#x2b;", "&#x2c;", "&#x2d;", "&#x2e;", "&#x2f;", "0",
-    "1",      "2",      "3",      "4",      "5",      "6",      "7",
-    "8",      "9",      "&#x3a;", "&#x3b;", "&lt;",   "&#x3d;", "&gt;",
-    "&#x3f;", "&#x40;", "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",
-    "&#x5b;", "&#x5c;", "&#x5d;", "&#x5e;", "&#x5f;", "&#x60;", "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",      "&#x7b;", "&#x7c;", "&#x7d;",
-    "&#x7e;", "&#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 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 uint8_t html_escape_len[] = {
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 6, 4, 6, 4, 6, 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, 6, 6, 6, 6, 6,
-    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, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6};
+    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};
 
 static inline FIOBJ fiobj_mustache_find_obj(mustache_section_s *section,
                                             const char *name,
@@ -127,7 +148,7 @@ static inline FIOBJ fiobj_mustache_find_obj(mustache_section_s *section,
     if (!FIOBJ_TYPE_IS((FIOBJ)section->udata2, FIOBJ_T_HASH))
       continue;
     o = fiobj_hash_get((FIOBJ)section->udata2, key);
-    section = section->parent;
+    section = mustache_section_parent(section);
   } while (o == FIOBJ_INVALID && section);
   return o;
 }
@@ -201,13 +222,15 @@ static int mustache_on_text(mustache_section_s *section, const char *data,
  * Please note, this will handle both normal and inverted sections.
  */
 static int32_t mustache_on_section_test(mustache_section_s *section,
-                                        const char *name, uint32_t name_len) {
+                                        const char *name, uint32_t name_len,
+                                        uint8_t callable) {
   FIOBJ o = fiobj_mustache_find_obj(section, name, name_len);
-  if (!o)
+  if (!o || FIOBJ_TYPE_IS(o, FIOBJ_T_FALSE))
     return 0;
   if (FIOBJ_TYPE_IS(o, FIOBJ_T_ARRAY))
     return fiobj_ary_count(o);
   return 1;
+  (void)callable;
 }
 
 /**