iodine 0.7.60 → 0.8.0

data/ext/iodine/fio_json_parser.h

@@ -1,688 +0,0 @@
-#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) || !parser->depth)
-        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 || tmp == pos || JSON_NUMERAL[*tmp]) {
-        tmp = pos;
-        double f = fio_atof((char **)&tmp);
-        if (tmp > limit)
-          goto stop;
-        if (!tmp || tmp == pos || 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 + 2; /* avoid this: /*/
-        do {
-          ++tmp;
-          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