isomorfeus-iodine 0.7.44

data/ext/iodine/fio_json_parser.h

@@ -0,0 +1,687 @@
+#ifndef H_FIO_JSON_H
+/* *****************************************************************************
+ * Copyright: Boaz Segev, 2017-2019
+ * License: MIT
+ *
+ * This header file is a single-file JSON naive parse.
+ *
+ * The code was extracted form the FIOBJ implementation in order to allow the
+ * parser to be used independantly from the rest of the facil.io library.
+ *
+ * The parser ignores missing commas and other formatting errors when possible.
+ *
+ * The parser also extends the JSON format to allow for C and Bash style
+ * comments as well as hex numerical formats.
+ *****************************************************************************
+ */
+#define H_FIO_JSON_H
+
+#include <ctype.h>
+#include <math.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if DEBUG
+#include <stdio.h>
+#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
+
+/* *****************************************************************************
+JSON API
+***************************************************************************** */
+
+/* maximum allowed depth values max out at 32, since a bitmap is used */
+#if !defined(JSON_MAX_DEPTH) || JSON_MAX_DEPTH > 32
+#undef JSON_MAX_DEPTH
+#define JSON_MAX_DEPTH 32
+#endif
+
+/** The JSON parser type. Memory must be initialized to 0 before first uses. */
+typedef struct {
+  /** in dictionary flag. */
+  uint32_t dict;
+  /** level of nesting. */
+  uint8_t depth;
+  /** in dictionary waiting for key. */
+  uint8_t key;
+} json_parser_s;
+
+/**
+ * Stream parsing of JSON data using a persistent parser.
+ *
+ * Returns the number of bytes consumed (0 being a valid value).
+ *
+ * Unconsumed data should be resent to the parser once more data is available.
+ *
+ * For security (due to numeral parsing concerns), a NUL byte should be placed
+ * at `buffer[length]`.
+ */
+static size_t __attribute__((unused))
+fio_json_parse(json_parser_s *parser, const char *buffer, size_t length);
+
+/**
+ * This function allows JSON formatted strings to be converted to native
+ * strings.
+ */
+static size_t __attribute__((unused))
+fio_json_unescape_str(void *dest, const char *source, size_t length);
+
+/* *****************************************************************************
+JSON Callacks - these must be implemented in the C file that uses the parser
+***************************************************************************** */
+
+/** a NULL object was detected */
+static void fio_json_on_null(json_parser_s *p);
+/** a TRUE object was detected */
+static void fio_json_on_true(json_parser_s *p);
+/** a FALSE object was detected */
+static void fio_json_on_false(json_parser_s *p);
+/** a Numberl was detected (long long). */
+static void fio_json_on_number(json_parser_s *p, long long i);
+/** a Float was detected (double). */
+static void fio_json_on_float(json_parser_s *p, double f);
+/** a String was detected (int / float). update `pos` to point at ending */
+static void fio_json_on_string(json_parser_s *p, void *start, size_t length);
+/** a dictionary object was detected, should return 0 unless error occurred. */
+static int fio_json_on_start_object(json_parser_s *p);
+/** a dictionary object closure detected */
+static void fio_json_on_end_object(json_parser_s *p);
+/** an array object was detected, should return 0 unless error occurred. */
+static int fio_json_on_start_array(json_parser_s *p);
+/** an array closure was detected */
+static void fio_json_on_end_array(json_parser_s *p);
+/** the JSON parsing is complete */
+static void fio_json_on_json(json_parser_s *p);
+/** the JSON parsing is complete */
+static void fio_json_on_error(json_parser_s *p);
+
+/* *****************************************************************************
+JSON maps (arrays used to map data to simplify `if` statements)
+***************************************************************************** */
+
+/*
+Marks as object seperators any of the following:
+
+* White Space: [0x09, 0x0A, 0x0D, 0x20]
+* Comma ("," / 0x2C)
+* NOT Colon (":" / 0x3A)
+* == [0x09, 0x0A, 0x0D, 0x20, 0x2C]
+The rest belong to objects,
+*/
+static const uint8_t JSON_SEPERATOR[] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+/*
+Marks a numeral valid char (it's a permisive list):
+['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'e', 'E', '+', '-', 'x', 'b',
+'.']
+*/
+static const uint8_t JSON_NUMERAL[] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static const char hex_chars[] = {'0', '1', '2', '3', '4', '5', '6', '7',
+                                 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
+
+static const uint8_t is_hex[] = {
+    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,  0,  0,
+    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,  0,  0,
+    0,  0,  0,  0, 0, 0,  0,  0,  1,  2,  3,  4, 5, 6, 7, 8, 9, 10, 0,  0,
+    0,  0,  0,  0, 0, 11, 12, 13, 14, 15, 16, 0, 0, 0, 0, 0, 0, 0,  0,  0,
+    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 11, 12, 13,
+    14, 15, 16, 0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,  0,  0,
+    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,  0,  0,
+    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,  0,  0,
+    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,  0,  0,
+    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,  0,  0,
+    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,  0,  0,
+    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,  0,  0,
+    0,  0,  0,  0, 0, 0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0};
+
+/*
+Stops seeking a String:
+['\\', '"']
+*/
+static const uint8_t string_seek_stop[] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+/* *****************************************************************************
+JSON String Helper - Seeking to the end of a string
+***************************************************************************** */
+
+/**
+ * finds the first occurance of either '"' or '\\'.
+ */
+static inline int seek2marker(uint8_t **buffer,
+                              register const uint8_t *const limit) {
+  if (string_seek_stop[**buffer])
+    return 1;
+
+#if !ALLOW_UNALIGNED_MEMORY_ACCESS || (!__x86_64__ && !__aarch64__)
+  /* too short for this mess */
+  if ((uintptr_t)limit <= 8 + ((uintptr_t)*buffer & (~(uintptr_t)7)))
+    goto finish;
+  /* align memory */
+  if (1) {
+    {
+      const uint8_t *alignment =
+          (uint8_t *)(((uintptr_t)(*buffer) & (~(uintptr_t)7)) + 8);
+      if (limit >= alignment) {
+        while (*buffer < alignment) {
+          if (string_seek_stop[**buffer])
+            return 1;
+          *buffer += 1;
+        }
+      }
+    }
+    const uint8_t *limit64 = (uint8_t *)((uintptr_t)limit & (~(uintptr_t)7));
+#else
+  const uint8_t *limit64 = (uint8_t *)limit - 7;
+#endif
+    uint64_t wanted1 = 0x0101010101010101ULL * '"';
+    uint64_t wanted2 = 0x0101010101010101ULL * '\\';
+    for (; *buffer < limit64; *buffer += 8) {
+      const uint64_t eq1 = ~((*((uint64_t *)*buffer)) ^ wanted1);
+      const uint64_t t1 =
+          ((eq1 & 0x7f7f7f7f7f7f7f7fULL) + 0x0101010101010101ULL) &
+          (eq1 & 0x8080808080808080ULL);
+      const uint64_t eq2 = ~((*((uint64_t *)*buffer)) ^ wanted2);
+      const uint64_t t2 =
+          ((eq2 & 0x7f7f7f7f7f7f7f7fULL) + 0x0101010101010101ULL) &
+          (eq2 & 0x8080808080808080ULL);
+      if ((t1 | t2)) {
+        break;
+      }
+    }
+  }
+#if !ALLOW_UNALIGNED_MEMORY_ACCESS || (!__x86_64__ && !__aarch64__)
+finish:
+#endif
+  if (*buffer + 4 <= limit) {
+    if (string_seek_stop[(*buffer)[0]]) {
+      // *buffer += 0;
+      return 1;
+    }
+    if (string_seek_stop[(*buffer)[1]]) {
+      *buffer += 1;
+      return 1;
+    }
+    if (string_seek_stop[(*buffer)[2]]) {
+      *buffer += 2;
+      return 1;
+    }
+    if (string_seek_stop[(*buffer)[3]]) {
+      *buffer += 3;
+      return 1;
+    }
+    *buffer += 4;
+  }
+  while (*buffer < limit) {
+    if (string_seek_stop[**buffer])
+      return 1;
+    (*buffer)++;
+  }
+  return 0;
+}
+
+static inline int seek2eos(uint8_t **buffer,
+                           register const uint8_t *const limit) {
+  while (*buffer < limit) {
+    if (seek2marker(buffer, limit) && **buffer == '"')
+      return 1;
+    (*buffer) += 2; /* consume both the escape '\\' and the escape code. */
+  }
+  return 0;
+}
+
+/* *****************************************************************************
+JSON String to Numeral Helpers - allowing for stand-alone mode
+***************************************************************************** */
+
+#ifndef H_FACIL_IO_H /* defined in fio.h */
+
+/**
+ * We include this in case the parser is used outside of facil.io.
+ */
+int64_t __attribute__((weak)) fio_atol(char **pstr) {
+  return strtoll((char *)*pstr, (char **)pstr, 0);
+}
+#pragma weak fio_atol
+
+/**
+ * We include this in case the parser is used outside of facil.io.
+ */
+double __attribute__((weak)) fio_atof(char **pstr) {
+  return strtod((char *)*pstr, (char **)pstr);
+}
+#pragma weak fio_atof
+
+#endif
+
+/* *****************************************************************************
+JSON Consumption (astract parsing)
+***************************************************************************** */
+
+/**
+ * Returns the number of bytes consumed. Stops as close as possible to the end
+ * of the buffer or once an object parsing was completed.
+ */
+static size_t __attribute__((unused))
+fio_json_parse(json_parser_s *parser, const char *buffer, size_t length) {
+  if (!length || !buffer)
+    return 0;
+  uint8_t *pos = (uint8_t *)buffer;
+  const uint8_t *limit = pos + length;
+  do {
+    while (pos < limit && JSON_SEPERATOR[*pos])
+      ++pos;
+    if (pos == limit)
+      goto stop;
+    switch (*pos) {
+    case '"': {
+      uint8_t *tmp = pos + 1;
+      if (seek2eos(&tmp, limit) == 0)
+        goto stop;
+      if (parser->key) {
+        uint8_t *key = tmp + 1;
+        while (key < limit && JSON_SEPERATOR[*key])
+          ++key;
+        if (key >= limit)
+          goto stop;
+        if (*key != ':')
+          goto error;
+        ++pos;
+        fio_json_on_string(parser, pos, (uintptr_t)(tmp - pos));
+        pos = key + 1;
+        parser->key = 0;
+        continue; /* skip tests */
+      } else {
+        ++pos;
+        fio_json_on_string(parser, pos, (uintptr_t)(tmp - pos));
+        pos = tmp + 1;
+      }
+      break;
+    }
+    case '{':
+      if (parser->key) {
+#if DEBUG
+        fprintf(stderr, "ERROR: JSON key can't be a Hash.\n");
+#endif
+        goto error;
+      }
+      ++parser->depth;
+      if (parser->depth >= JSON_MAX_DEPTH)
+        goto error;
+      parser->dict = (parser->dict << 1) | 1;
+      ++pos;
+      if (fio_json_on_start_object(parser))
+        goto error;
+      break;
+    case '}':
+      if ((parser->dict & 1) == 0) {
+#if DEBUG
+        fprintf(stderr, "ERROR: JSON dictionary closure error.\n");
+#endif
+        goto error;
+      }
+      if (!parser->key) {
+#if DEBUG
+        fprintf(stderr, "ERROR: JSON dictionary closure missing key value.\n");
+        goto error;
+#endif
+        fio_json_on_null(parser); /* append NULL and recuperate from error. */
+      }
+      --parser->depth;
+      ++pos;
+      parser->dict = (parser->dict >> 1);
+      fio_json_on_end_object(parser);
+      break;
+    case '[':
+      if (parser->key) {
+#if DEBUG
+        fprintf(stderr, "ERROR: JSON key can't be an array.\n");
+#endif
+        goto error;
+      }
+      ++parser->depth;
+      if (parser->depth >= JSON_MAX_DEPTH)
+        goto error;
+      ++pos;
+      parser->dict = (parser->dict << 1);
+      if (fio_json_on_start_array(parser))
+        goto error;
+      break;
+    case ']':
+      if ((parser->dict & 1))
+        goto error;
+      --parser->depth;
+      ++pos;
+      parser->dict = (parser->dict >> 1);
+      fio_json_on_end_array(parser);
+      break;
+    case 't':
+      if (pos + 3 >= limit)
+        goto stop;
+      if (pos[1] == 'r' && pos[2] == 'u' && pos[3] == 'e')
+        fio_json_on_true(parser);
+      else
+        goto error;
+      pos += 4;
+      break;
+    case 'N': /* overflow */
+    case 'n':
+      if (pos + 2 <= limit && (pos[1] | 32) == 'a' && (pos[2] | 32) == 'n')
+        goto numeral;
+      if (pos + 3 >= limit)
+        goto stop;
+      if (pos[1] == 'u' && pos[2] == 'l' && pos[3] == 'l')
+        fio_json_on_null(parser);
+      else
+        goto error;
+      pos += 4;
+      break;
+    case 'f':
+      if (pos + 4 >= limit)
+        goto stop;
+      if (pos + 4 < limit && pos[1] == 'a' && pos[2] == 'l' && pos[3] == 's' &&
+          pos[4] == 'e')
+        fio_json_on_false(parser);
+      else
+        goto error;
+      pos += 5;
+      break;
+    case '-': /* overflow */
+    case '0': /* overflow */
+    case '1': /* overflow */
+    case '2': /* overflow */
+    case '3': /* overflow */
+    case '4': /* overflow */
+    case '5': /* overflow */
+    case '6': /* overflow */
+    case '7': /* overflow */
+    case '8': /* overflow */
+    case '9': /* overflow */
+    case '.': /* overflow */
+    case 'e': /* overflow */
+    case 'E': /* overflow */
+    case 'x': /* overflow */
+    case 'i': /* overflow */
+    case 'I': /* overflow */
+    numeral : {
+      uint8_t *tmp = pos;
+      long long i = fio_atol((char **)&tmp);
+      if (tmp > limit)
+        goto stop;
+      if (!tmp || JSON_NUMERAL[*tmp]) {
+        tmp = pos;
+        double f = fio_atof((char **)&tmp);
+        if (tmp > limit)
+          goto stop;
+        if (!tmp || JSON_NUMERAL[*tmp])
+          goto error;
+        fio_json_on_float(parser, f);
+        pos = tmp;
+      } else {
+        fio_json_on_number(parser, i);
+        pos = tmp;
+      }
+      break;
+    }
+    case '#': /* Ruby style comment */
+    {
+      uint8_t *tmp = memchr(pos, '\n', (uintptr_t)(limit - pos));
+      if (!tmp)
+        goto stop;
+      pos = tmp + 1;
+      continue; /* skip tests */
+      ;
+    }
+    case '/': /* C style / Javascript style comment */
+      if (pos[1] == '*') {
+        if (pos + 4 > limit)
+          goto stop;
+        uint8_t *tmp = pos + 3; /* avoid this: /*/
+        do {
+          tmp = memchr(tmp, '/', (uintptr_t)(limit - tmp));
+        } while (tmp && tmp[-1] != '*');
+        if (!tmp)
+          goto stop;
+        pos = tmp + 1;
+      } else if (pos[1] == '/') {
+        uint8_t *tmp = memchr(pos, '\n', (uintptr_t)(limit - pos));
+        if (!tmp)
+          goto stop;
+        pos = tmp + 1;
+      } else
+        goto error;
+      continue; /* skip tests */
+      ;
+    default:
+      goto error;
+    }
+    if (parser->depth == 0) {
+      fio_json_on_json(parser);
+      goto stop;
+    }
+    parser->key = (parser->dict & 1);
+  } while (pos < limit);
+stop:
+  return (size_t)((uintptr_t)pos - (uintptr_t)buffer);
+error:
+  fio_json_on_error(parser);
+  return 0;
+}
+
+/* *****************************************************************************
+JSON Unescape String
+***************************************************************************** */
+
+#ifdef __cplusplus
+#define REGISTER
+#else
+#define REGISTER register
+#endif
+
+/* converts a uint32_t to UTF-8 and returns the number of bytes written */
+static inline int utf8_from_u32(uint8_t *dest, uint32_t u) {
+  if (u <= 127) {
+    *dest = u;
+    return 1;
+  } else if (u <= 2047) {
+    *(dest++) = 192 | (u >> 6);
+    *(dest++) = 128 | (u & 63);
+    return 2;
+  } else if (u <= 65535) {
+    *(dest++) = 224 | (u >> 12);
+    *(dest++) = 128 | ((u >> 6) & 63);
+    *(dest++) = 128 | (u & 63);
+    return 3;
+  }
+  *(dest++) = 240 | ((u >> 18) & 7);
+  *(dest++) = 128 | ((u >> 12) & 63);
+  *(dest++) = 128 | ((u >> 6) & 63);
+  *(dest++) = 128 | (u & 63);
+  return 4;
+}
+
+static void __attribute__((unused))
+fio_json_unescape_str_internal(uint8_t **dest, const uint8_t **src) {
+  ++(*src);
+  switch (**src) {
+  case 'b':
+    **dest = '\b';
+    ++(*src);
+    ++(*dest);
+    return; /* from switch */
+  case 'f':
+    **dest = '\f';
+    ++(*src);
+    ++(*dest);
+    return; /* from switch */
+  case 'n':
+    **dest = '\n';
+    ++(*src);
+    ++(*dest);
+    return; /* from switch */
+  case 'r':
+    **dest = '\r';
+    ++(*src);
+    ++(*dest);
+    return; /* from switch */
+  case 't':
+    **dest = '\t';
+    ++(*src);
+    ++(*dest);
+    return;   /* from switch */
+  case 'u': { /* test for octal notation */
+    if (is_hex[(*src)[1]] && is_hex[(*src)[2]] && is_hex[(*src)[3]] &&
+        is_hex[(*src)[4]]) {
+      uint32_t t =
+          ((((is_hex[(*src)[1]] - 1) << 4) | (is_hex[(*src)[2]] - 1)) << 8) |
+          (((is_hex[(*src)[3]] - 1) << 4) | (is_hex[(*src)[4]] - 1));
+      if ((*src)[5] == '\\' && (*src)[6] == 'u' && is_hex[(*src)[7]] &&
+          is_hex[(*src)[8]] && is_hex[(*src)[9]] && is_hex[(*src)[10]]) {
+        /* Serrogate Pair */
+        t = (t & 0x03FF) << 10;
+        t |= ((((((is_hex[(*src)[7]] - 1) << 4) | (is_hex[(*src)[8]] - 1))
+                << 8) |
+               (((is_hex[(*src)[9]] - 1) << 4) | (is_hex[(*src)[10]] - 1))) &
+              0x03FF);
+        t += 0x10000;
+        (*src) += 6;
+      }
+      *dest += utf8_from_u32(*dest, t);
+      *src += 5;
+      return;
+    } else
+      goto invalid_escape;
+  }
+  case 'x': { /* test for hex notation */
+    if (is_hex[(*src)[1]] && is_hex[(*src)[2]]) {
+      **dest = ((is_hex[(*src)[1]] - 1) << 4) | (is_hex[(*src)[2]] - 1);
+      ++(*dest);
+      (*src) += 3;
+      return;
+    } else
+      goto invalid_escape;
+  }
+  case '0':
+  case '1':
+  case '2':
+  case '3':
+  case '4':
+  case '5':
+  case '6':
+  case '7': { /* test for octal notation */
+    if ((*src)[1] >= '0' && (*src)[1] <= '7') {
+      **dest = (((*src)[0] - '0') << 3) | ((*src)[1] - '0');
+      ++(*dest);
+      (*src) += 2;
+      break; /* from switch */
+    } else
+      goto invalid_escape;
+  }
+  case '"':
+  case '\\':
+  case '/':
+  /* fallthrough */
+  default:
+  invalid_escape:
+    **dest = **src;
+    ++(*src);
+    ++(*dest);
+  }
+}
+
+static size_t __attribute__((unused))
+fio_json_unescape_str(void *dest, const char *source, size_t length) {
+  const uint8_t *reader = (uint8_t *)source;
+  const uint8_t *stop = reader + length;
+  uint8_t *writer = (uint8_t *)dest;
+  /* copy in chuncks unless we hit an escape marker */
+  while (reader < stop) {
+#if !__x86_64__ && !__aarch64__
+    /* we can't leverage unaligned memory access, so we read the buffer twice */
+    uint8_t *tmp = memchr(reader, '\\', (size_t)(stop - reader));
+    if (!tmp) {
+      memmove(writer, reader, (size_t)(stop - reader));
+      writer += (size_t)(stop - reader);
+      goto finish;
+    }
+    memmove(writer, reader, (size_t)(tmp - reader));
+    writer += (size_t)(tmp - reader);
+    reader = tmp;
+#else
+    const uint8_t *limit64 = (uint8_t *)stop - 7;
+    uint64_t wanted1 = 0x0101010101010101ULL * '\\';
+    while (reader < limit64) {
+      const uint64_t eq1 = ~((*((uint64_t *)reader)) ^ wanted1);
+      const uint64_t t0 = (eq1 & 0x7f7f7f7f7f7f7f7fllu) + 0x0101010101010101llu;
+      const uint64_t t1 = (eq1 & 0x8080808080808080llu);
+      if ((t0 & t1)) {
+        break;
+      }
+      *((uint64_t *)writer) = *((uint64_t *)reader);
+      reader += 8;
+      writer += 8;
+    }
+    while (reader < stop) {
+      if (*reader == '\\')
+        break;
+      *writer = *reader;
+      ++reader;
+      ++writer;
+    }
+    if (reader >= stop)
+      goto finish;
+#endif
+    fio_json_unescape_str_internal(&writer, &reader);
+  }
+finish:
+  return (size_t)((uintptr_t)writer - (uintptr_t)dest);
+}
+
+#undef REGISTER
+
+#endif