test build

5 files changed, 37 insertions, 13626 deletions

diff --git a/396.patch b/396.patch
new file mode 100644
index 0000000..b4b4ab6
--- /dev/null
+++ b/396.patch
@@ -0,0 +1,22 @@
+From cd4d854606a17b24d7a37fb46f5b7eb559062ad8 Mon Sep 17 00:00:00 2001
+From: Remi Collet <remi@remirepo.net>
+Date: Tue, 9 Apr 2019 09:25:10 +0200
+Subject: [PATCH] fix #395 build with -std=c99 option
+
+---
+ config.m4 | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/config.m4 b/config.m4
+index 042812e7..62ee41e7 100644
+--- a/config.m4
++++ b/config.m4
+@@ -10,7 +10,7 @@ if test "$PHP_DDTRACE" != "no"; then
+     PHP_SUBST(EXTRA_CFLAGS)
+   fi
+ 
+-  PHP_NEW_EXTENSION(ddtrace, src/ext/ddtrace.c src/ext/dispatch_setup.c src/ext/dispatch.c src/ext/request_hooks.c src/ext/compat_zend_string.c src/ext/dispatch_compat_php5.c src/ext/dispatch_compat_php7.c src/ext/backtrace.c src/ext/logging.c src/ext/env_config.c src/ext/serializer.c src/ext/mpack/mpack.c, $ext_shared,, -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1)
++  PHP_NEW_EXTENSION(ddtrace, src/ext/ddtrace.c src/ext/dispatch_setup.c src/ext/dispatch.c src/ext/request_hooks.c src/ext/compat_zend_string.c src/ext/dispatch_compat_php5.c src/ext/dispatch_compat_php7.c src/ext/backtrace.c src/ext/logging.c src/ext/env_config.c src/ext/serializer.c src/ext/mpack/mpack.c, $ext_shared,, -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1 -Wall -std=c99)
+   PHP_ADD_BUILD_DIR($ext_builddir/src/ext, 1)
+ 
+   PHP_ADD_INCLUDE($ext_builddir)
diff --git a/LICENSE b/LICENSE
deleted file mode 100644
index d32cc9a..0000000
--- a/LICENSE
+++ /dev/null
@@ -1,22 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015-2018 Nicholas Fraser
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
diff --git a/mpack.c b/mpack.c
deleted file mode 100644
index df9ed1b..0000000
--- a/mpack.c
+++ /dev/null
@@ -1,6442 +0,0 @@
-/**
- * The MIT License (MIT)
- * 
- * Copyright (c) 2015-2018 Nicholas Fraser
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * 
- */
-
-/*
- * This is the MPack 1.0 amalgamation package.
- *
- * http://github.com/ludocode/mpack
- */
-
-#define MPACK_INTERNAL 1
-#define MPACK_EMIT_INLINE_DEFS 1
-
-#include "mpack.h"
-
-
-/* mpack/mpack-platform.c.c */
-
-
-// We define MPACK_EMIT_INLINE_DEFS and include mpack.h to emit
-// standalone definitions of all (non-static) inline functions in MPack.
-
-#define MPACK_INTERNAL 1
-#define MPACK_EMIT_INLINE_DEFS 1
-
-/* #include "mpack-platform.h" */
-/* #include "mpack.h" */
-
-
-#if MPACK_DEBUG && MPACK_STDIO
-#include <stdarg.h>
-#endif
-
-// Ignore warnings that we convert to errors for ddtrace
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-
-
-#if MPACK_DEBUG
-
-#if MPACK_STDIO
-void mpack_assert_fail_format(const char* format, ...) {
-    char buffer[512];
-    va_list args;
-    va_start(args, format);
-    vsnprintf(buffer, sizeof(buffer), format, args);
-    va_end(args);
-    buffer[sizeof(buffer) - 1] = 0;
-    mpack_assert_fail_wrapper(buffer);
-}
-
-void mpack_break_hit_format(const char* format, ...) {
-    char buffer[512];
-    va_list args;
-    va_start(args, format);
-    vsnprintf(buffer, sizeof(buffer), format, args);
-    va_end(args);
-    buffer[sizeof(buffer) - 1] = 0;
-    mpack_break_hit(buffer);
-}
-#endif
-
-#if !MPACK_CUSTOM_ASSERT
-void mpack_assert_fail(const char* message) {
-    MPACK_UNUSED(message);
-
-    #if MPACK_STDIO
-    fprintf(stderr, "%s\n", message);
-    #endif
-}
-#endif
-
-// We split the assert failure from the wrapper so that a
-// custom assert function can return.
-void mpack_assert_fail_wrapper(const char* message) {
-
-    #ifdef MPACK_GCOV
-    // gcov marks even __builtin_unreachable() as an uncovered line. this
-    // silences it.
-    (mpack_assert_fail(message), __builtin_unreachable());
-
-    #else
-    mpack_assert_fail(message);
-
-    // mpack_assert_fail() is not supposed to return. in case it does, we
-    // abort.
-
-    #if !MPACK_NO_BUILTINS
-    #if defined(__GNUC__) || defined(__clang__)
-    __builtin_trap();
-    #elif defined(WIN32)
-    __debugbreak();
-    #endif
-    #endif
-
-    #if (defined(__GNUC__) || defined(__clang__)) && !MPACK_NO_BUILTINS
-    __builtin_abort();
-    #elif MPACK_STDLIB
-    abort();
-    #endif
-
-    MPACK_UNREACHABLE;
-    #endif
-}
-
-#if !MPACK_CUSTOM_BREAK
-
-// If we have a custom assert handler, break wraps it by default.
-// This allows users of MPack to only implement mpack_assert_fail() without
-// having to worry about the difference between assert and break.
-//
-// MPACK_CUSTOM_BREAK is available to define a separate break handler
-// (which is needed by the unit test suite), but this is not offered in
-// mpack-config.h for simplicity.
-
-#if MPACK_CUSTOM_ASSERT
-void mpack_break_hit(const char* message) {
-    mpack_assert_fail_wrapper(message);
-}
-#else
-void mpack_break_hit(const char* message) {
-    MPACK_UNUSED(message);
-
-    #if MPACK_STDIO
-    fprintf(stderr, "%s\n", message);
-    #endif
-
-    #if defined(__GNUC__) || defined(__clang__) && !MPACK_NO_BUILTINS
-    __builtin_trap();
-    #elif defined(WIN32) && !MPACK_NO_BUILTINS
-    __debugbreak();
-    #elif MPACK_STDLIB
-    abort();
-    #endif
-}
-#endif
-
-#endif
-
-#endif
-
-
-
-// The below are adapted from the C wikibook:
-//     https://en.wikibooks.org/wiki/C_Programming/Strings
-
-#ifndef mpack_memcmp
-int mpack_memcmp(const void* s1, const void* s2, size_t n) {
-     const unsigned char *us1 = (const unsigned char *) s1;
-     const unsigned char *us2 = (const unsigned char *) s2;
-     while (n-- != 0) {
-         if (*us1 != *us2)
-             return (*us1 < *us2) ? -1 : +1;
-         us1++;
-         us2++;
-     }
-     return 0;
-}
-#endif
-
-#ifndef mpack_memcpy
-void* mpack_memcpy(void* MPACK_RESTRICT s1, const void* MPACK_RESTRICT s2, size_t n) {
-    char* MPACK_RESTRICT dst = (char *)s1;
-    const char* MPACK_RESTRICT src = (const char *)s2;
-    while (n-- != 0)
-        *dst++ = *src++;
-    return s1;
-}
-#endif
-
-#ifndef mpack_memmove
-void* mpack_memmove(void* s1, const void* s2, size_t n) {
-    char *p1 = (char *)s1;
-    const char *p2 = (const char *)s2;
-    if (p2 < p1 && p1 < p2 + n) {
-        p2 += n;
-        p1 += n;
-        while (n-- != 0)
-            *--p1 = *--p2;
-    } else
-        while (n-- != 0)
-            *p1++ = *p2++;
-    return s1;
-}
-#endif
-
-#ifndef mpack_memset
-void* mpack_memset(void* s, int c, size_t n) {
-    unsigned char *us = (unsigned char *)s;
-    unsigned char uc = (unsigned char)c;
-    while (n-- != 0)
-        *us++ = uc;
-    return s;
-}
-#endif
-
-#ifndef mpack_strlen
-size_t mpack_strlen(const char* s) {
-    const char* p = s;
-    while (*p != '\0')
-        p++;
-    return (size_t)(p - s);
-}
-#endif
-
-
-
-#if defined(MPACK_MALLOC) && !defined(MPACK_REALLOC)
-void* mpack_realloc(void* old_ptr, size_t used_size, size_t new_size) {
-    if (new_size == 0) {
-        if (old_ptr)
-            MPACK_FREE(old_ptr);
-        return NULL;
-    }
-
-    void* new_ptr = MPACK_MALLOC(new_size);
-    if (new_ptr == NULL)
-        return NULL;
-
-    mpack_memcpy(new_ptr, old_ptr, used_size);
-    MPACK_FREE(old_ptr);
-    return new_ptr;
-}
-#endif
-
-/* mpack/mpack-common.c.c */
-
-#define MPACK_INTERNAL 1
-
-/* #include "mpack-common.h" */
-
-#if MPACK_DEBUG && MPACK_STDIO
-#include <stdarg.h>
-#endif
-
-const char* mpack_error_to_string(mpack_error_t error) {
-    #if MPACK_STRINGS
-    switch (error) {
-        #define MPACK_ERROR_STRING_CASE(e) case e: return #e
-        MPACK_ERROR_STRING_CASE(mpack_ok);
-        MPACK_ERROR_STRING_CASE(mpack_error_io);
-        MPACK_ERROR_STRING_CASE(mpack_error_invalid);
-        MPACK_ERROR_STRING_CASE(mpack_error_unsupported);
-        MPACK_ERROR_STRING_CASE(mpack_error_type);
-        MPACK_ERROR_STRING_CASE(mpack_error_too_big);
-        MPACK_ERROR_STRING_CASE(mpack_error_memory);
-        MPACK_ERROR_STRING_CASE(mpack_error_bug);
-        MPACK_ERROR_STRING_CASE(mpack_error_data);
-        MPACK_ERROR_STRING_CASE(mpack_error_eof);
-        #undef MPACK_ERROR_STRING_CASE
-    }
-    mpack_assert(0, "unrecognized error %i", (int)error);
-    return "(unknown mpack_error_t)";
-    #else
-    MPACK_UNUSED(error);
-    return "";
-    #endif
-}
-
-const char* mpack_type_to_string(mpack_type_t type) {
-    #if MPACK_STRINGS
-    switch (type) {
-        #define MPACK_TYPE_STRING_CASE(e) case e: return #e
-        MPACK_TYPE_STRING_CASE(mpack_type_missing);
-        MPACK_TYPE_STRING_CASE(mpack_type_nil);
-        MPACK_TYPE_STRING_CASE(mpack_type_bool);
-        MPACK_TYPE_STRING_CASE(mpack_type_float);
-        MPACK_TYPE_STRING_CASE(mpack_type_double);
-        MPACK_TYPE_STRING_CASE(mpack_type_int);
-        MPACK_TYPE_STRING_CASE(mpack_type_uint);
-        MPACK_TYPE_STRING_CASE(mpack_type_str);
-        MPACK_TYPE_STRING_CASE(mpack_type_bin);
-        MPACK_TYPE_STRING_CASE(mpack_type_array);
-        MPACK_TYPE_STRING_CASE(mpack_type_map);
-        #if MPACK_EXTENSIONS
-        MPACK_TYPE_STRING_CASE(mpack_type_ext);
-        #endif
-        #undef MPACK_TYPE_STRING_CASE
-    }
-    mpack_assert(0, "unrecognized type %i", (int)type);
-    return "(unknown mpack_type_t)";
-    #else
-    MPACK_UNUSED(type);
-    return "";
-    #endif
-}
-
-int mpack_tag_cmp(mpack_tag_t left, mpack_tag_t right) {
-
-    // positive numbers may be stored as int; convert to uint
-    if (left.type == mpack_type_int && left.v.i >= 0) {
-        left.type = mpack_type_uint;
-        left.v.u = (uint64_t)left.v.i;
-    }
-    if (right.type == mpack_type_int && right.v.i >= 0) {
-        right.type = mpack_type_uint;
-        right.v.u = (uint64_t)right.v.i;
-    }
-
-    if (left.type != right.type)
-        return ((int)left.type < (int)right.type) ? -1 : 1;
-
-    switch (left.type) {
-        case mpack_type_missing: // fallthrough
-        case mpack_type_nil:
-            return 0;
-
-        case mpack_type_bool:
-            return (int)left.v.b - (int)right.v.b;
-
-        case mpack_type_int:
-            if (left.v.i == right.v.i)
-                return 0;
-            return (left.v.i < right.v.i) ? -1 : 1;
-
-        case mpack_type_uint:
-            if (left.v.u == right.v.u)
-                return 0;
-            return (left.v.u < right.v.u) ? -1 : 1;
-
-        case mpack_type_array:
-        case mpack_type_map:
-            if (left.v.n == right.v.n)
-                return 0;
-            return (left.v.n < right.v.n) ? -1 : 1;
-
-        case mpack_type_str:
-        case mpack_type_bin:
-            if (left.v.l == right.v.l)
-                return 0;
-            return (left.v.l < right.v.l) ? -1 : 1;
-
-        #if MPACK_EXTENSIONS
-        case mpack_type_ext:
-            if (left.exttype == right.exttype) {
-                if (left.v.l == right.v.l)
-                    return 0;
-                return (left.v.l < right.v.l) ? -1 : 1;
-            }
-            return (int)left.exttype - (int)right.exttype;
-        #endif
-
-        // floats should not normally be compared for equality. we compare
-        // with memcmp() to silence compiler warnings, but this will return
-        // equal if both are NaNs with the same representation (though we may
-        // want this, for instance if you are for some bizarre reason using
-        // floats as map keys.) i'm not sure what the right thing to
-        // do is here. check for NaN first? always return false if the type
-        // is float? use operator== and pragmas to silence compiler warning?
-        // please send me your suggestions.
-        // note also that we don't convert floats to doubles, so when this is
-        // used for ordering purposes, all floats are ordered before all
-        // doubles.
-        case mpack_type_float:
-            return mpack_memcmp(&left.v.f, &right.v.f, sizeof(left.v.f));
-        case mpack_type_double:
-            return mpack_memcmp(&left.v.d, &right.v.d, sizeof(left.v.d));
-    }
-
-    mpack_assert(0, "unrecognized type %i", (int)left.type);
-    return false;
-}
-
-#if MPACK_DEBUG && MPACK_STDIO
-static char mpack_hex_char(uint8_t hex_value) {
-    return (hex_value < 10) ? (char)('0' + hex_value) : (char)('a' + (hex_value - 10));
-}
-
-static void mpack_tag_debug_complete_bin_ext(mpack_tag_t tag, size_t string_length, char* buffer, size_t buffer_size,
-        const char* prefix, size_t prefix_size)
-{
-    // If at any point in this function we run out of space in the buffer, we
-    // bail out. The outer tag print wrapper will make sure we have a
-    // null-terminator.
-
-    if (string_length == 0 || string_length >= buffer_size)
-        return;
-    buffer += string_length;
-    buffer_size -= string_length;
-
-    size_t total = mpack_tag_bytes(&tag);
-    if (total == 0) {
-        strncpy(buffer, ">", buffer_size);
-        return;
-    }
-
-    strncpy(buffer, ": ", buffer_size);
-    if (buffer_size < 2)
-        return;
-    buffer += 2;
-    buffer_size -= 2;
-
-    size_t hex_bytes = 0;
-    for (size_t i = 0; i < MPACK_PRINT_BYTE_COUNT && i < prefix_size && buffer_size > 2; ++i) {
-        uint8_t byte = (uint8_t)prefix[i];
-        buffer[0] = mpack_hex_char((uint8_t)(byte >> 4));
-        buffer[1] = mpack_hex_char((uint8_t)(byte & 0xfu));
-        buffer += 2;
-        buffer_size -= 2;
-        ++hex_bytes;
-    }
-
-    if (buffer_size != 0)
-        mpack_snprintf(buffer, buffer_size, "%s>", (total > hex_bytes) ? "..." : "");
-}
-
-static void mpack_tag_debug_pseudo_json_bin(mpack_tag_t tag, char* buffer, size_t buffer_size,
-        const char* prefix, size_t prefix_size)
-{
-    mpack_assert(mpack_tag_type(&tag) == mpack_type_bin);
-    size_t length = (size_t)mpack_snprintf(buffer, buffer_size, "<binary data of length %u", tag.v.l);
-    mpack_tag_debug_complete_bin_ext(tag, length, buffer, buffer_size, prefix, prefix_size);
-}
-
-#if MPACK_EXTENSIONS
-static void mpack_tag_debug_pseudo_json_ext(mpack_tag_t tag, char* buffer, size_t buffer_size,
-        const char* prefix, size_t prefix_size)
-{
-    mpack_assert(mpack_tag_type(&tag) == mpack_type_ext);
-    size_t length = (size_t)mpack_snprintf(buffer, buffer_size, "<ext data of type %i and length %u",
-            mpack_tag_ext_exttype(&tag), mpack_tag_ext_length(&tag));
-    mpack_tag_debug_complete_bin_ext(tag, length, buffer, buffer_size, prefix, prefix_size);
-}
-#endif
-
-static void mpack_tag_debug_pseudo_json_impl(mpack_tag_t tag, char* buffer, size_t buffer_size,
-        const char* prefix, size_t prefix_size)
-{
-    switch (tag.type) {
-        case mpack_type_missing:
-            mpack_snprintf(buffer, buffer_size, "<missing!>");
-            return;
-        case mpack_type_nil:
-            mpack_snprintf(buffer, buffer_size, "null");
-            return;
-        case mpack_type_bool:
-            mpack_snprintf(buffer, buffer_size, tag.v.b ? "true" : "false");
-            return;
-        case mpack_type_int:
-            mpack_snprintf(buffer, buffer_size, "%" PRIi64, tag.v.i);
-            return;
-        case mpack_type_uint:
-            mpack_snprintf(buffer, buffer_size, "%" PRIu64, tag.v.u);
-            return;
-        case mpack_type_float:
-            mpack_snprintf(buffer, buffer_size, "%f", tag.v.f);
-            return;
-        case mpack_type_double:
-            mpack_snprintf(buffer, buffer_size, "%f", tag.v.d);
-            return;
-
-        case mpack_type_str:
-            mpack_snprintf(buffer, buffer_size, "<string of %u bytes>", tag.v.l);
-            return;
-        case mpack_type_bin:
-            mpack_tag_debug_pseudo_json_bin(tag, buffer, buffer_size, prefix, prefix_size);
-            return;
-        #if MPACK_EXTENSIONS
-        case mpack_type_ext:
-            mpack_tag_debug_pseudo_json_ext(tag, buffer, buffer_size, prefix, prefix_size);
-            return;
-        #endif
-
-        case mpack_type_array:
-            mpack_snprintf(buffer, buffer_size, "<array of %u elements>", tag.v.n);
-            return;
-        case mpack_type_map:
-            mpack_snprintf(buffer, buffer_size, "<map of %u key-value pairs>", tag.v.n);
-            return;
-    }
-
-    mpack_snprintf(buffer, buffer_size, "<unknown!>");
-}
-
-void mpack_tag_debug_pseudo_json(mpack_tag_t tag, char* buffer, size_t buffer_size,
-        const char* prefix, size_t prefix_size)
-{
-    mpack_assert(buffer_size > 0, "buffer size cannot be zero!");
-    buffer[0] = 0;
-
-    mpack_tag_debug_pseudo_json_impl(tag, buffer, buffer_size, prefix, prefix_size);
-
-    // We always null-terminate the buffer manually just in case the snprintf()
-    // function doesn't null-terminate when the string doesn't fit.
-    buffer[buffer_size - 1] = 0;
-}
-
-static void mpack_tag_debug_describe_impl(mpack_tag_t tag, char* buffer, size_t buffer_size) {
-    switch (tag.type) {
-        case mpack_type_missing:
-            mpack_snprintf(buffer, buffer_size, "missing");
-            return;
-        case mpack_type_nil:
-            mpack_snprintf(buffer, buffer_size, "nil");
-            return;
-        case mpack_type_bool:
-            mpack_snprintf(buffer, buffer_size, tag.v.b ? "true" : "false");
-            return;
-        case mpack_type_int:
-            mpack_snprintf(buffer, buffer_size, "int %" PRIi64, tag.v.i);
-            return;
-        case mpack_type_uint:
-            mpack_snprintf(buffer, buffer_size, "uint %" PRIu64, tag.v.u);
-            return;
-        case mpack_type_float:
-            mpack_snprintf(buffer, buffer_size, "float %f", tag.v.f);
-            return;
-        case mpack_type_double:
-            mpack_snprintf(buffer, buffer_size, "double %f", tag.v.d);
-            return;
-        case mpack_type_str:
-            mpack_snprintf(buffer, buffer_size, "str of %u bytes", tag.v.l);
-            return;
-        case mpack_type_bin:
-            mpack_snprintf(buffer, buffer_size, "bin of %u bytes", tag.v.l);
-            return;
-        #if MPACK_EXTENSIONS
-        case mpack_type_ext:
-            mpack_snprintf(buffer, buffer_size, "ext of type %i, %u bytes",
-                    mpack_tag_ext_exttype(&tag), mpack_tag_ext_length(&tag));
-            return;
-        #endif
-        case mpack_type_array:
-            mpack_snprintf(buffer, buffer_size, "array of %u elements", tag.v.n);
-            return;
-        case mpack_type_map:
-            mpack_snprintf(buffer, buffer_size, "map of %u key-value pairs", tag.v.n);
-            return;
-    }
-
-    mpack_snprintf(buffer, buffer_size, "unknown!");
-}
-
-void mpack_tag_debug_describe(mpack_tag_t tag, char* buffer, size_t buffer_size) {
-    mpack_assert(buffer_size > 0, "buffer size cannot be zero!");
-    buffer[0] = 0;
-
-    mpack_tag_debug_describe_impl(tag, buffer, buffer_size);
-
-    // We always null-terminate the buffer manually just in case the snprintf()
-    // function doesn't null-terminate when the string doesn't fit.
-    buffer[buffer_size - 1] = 0;
-}
-#endif
-
-
-
-#if MPACK_READ_TRACKING || MPACK_WRITE_TRACKING
-
-#ifndef MPACK_TRACKING_INITIAL_CAPACITY
-// seems like a reasonable number. we grow by doubling, and it only
-// needs to be as long as the maximum depth of the message.
-#define MPACK_TRACKING_INITIAL_CAPACITY 8
-#endif
-
-mpack_error_t mpack_track_init(mpack_track_t* track) {
-    track->count = 0;
-    track->capacity = MPACK_TRACKING_INITIAL_CAPACITY;
-    track->elements = (mpack_track_element_t*)MPACK_MALLOC(sizeof(mpack_track_element_t) * track->capacity);
-    if (track->elements == NULL)
-        return mpack_error_memory;
-    return mpack_ok;
-}
-
-mpack_error_t mpack_track_grow(mpack_track_t* track) {
-    mpack_assert(track->elements, "null track elements!");
-    mpack_assert(track->count == track->capacity, "incorrect growing?");
-
-    size_t new_capacity = track->capacity * 2;
-
-    mpack_track_element_t* new_elements = (mpack_track_element_t*)mpack_realloc(track->elements,
-            sizeof(mpack_track_element_t) * track->count, sizeof(mpack_track_element_t) * new_capacity);
-    if (new_elements == NULL)
-        return mpack_error_memory;
-
-    track->elements = new_elements;
-    track->capacity = new_capacity;
-    return mpack_ok;
-}
-
-mpack_error_t mpack_track_push(mpack_track_t* track, mpack_type_t type, uint64_t count) {
-    mpack_assert(track->elements, "null track elements!");
-    mpack_log("track pushing %s count %i\n", mpack_type_to_string(type), (int)count);
-
-    // maps have twice the number of elements (key/value pairs)
-    if (type == mpack_type_map)
-        count *= 2;
-
-    // grow if needed
-    if (track->count == track->capacity) {
-        mpack_error_t error = mpack_track_grow(track);
-        if (error != mpack_ok)
-            return error;
-    }
-
-    // insert new track
-    track->elements[track->count].type = type;
-    track->elements[track->count].left = count;
-    ++track->count;
-    return mpack_ok;
-}
-
-mpack_error_t mpack_track_pop(mpack_track_t* track, mpack_type_t type) {
-    mpack_assert(track->elements, "null track elements!");
-    mpack_log("track popping %s\n", mpack_type_to_string(type));
-
-    if (track->count == 0) {
-        mpack_break("attempting to close a %s but nothing was opened!", mpack_type_to_string(type));
-        return mpack_error_bug;
-    }
-
-    mpack_track_element_t* element = &track->elements[track->count - 1];
-
-    if (element->type != type) {
-        mpack_break("attempting to close a %s but the open element is a %s!",
-                mpack_type_to_string(type), mpack_type_to_string(element->type));
-        return mpack_error_bug;
-    }
-
-    if (element->left != 0) {
-        mpack_break("attempting to close a %s but there are %" PRIu64 " %s left",
-                mpack_type_to_string(type), element->left,
-                (type == mpack_type_map || type == mpack_type_array) ? "elements" : "bytes");
-        return mpack_error_bug;
-    }
-
-    --track->count;
-    return mpack_ok;
-}
-
-mpack_error_t mpack_track_peek_element(mpack_track_t* track, bool read) {
-    MPACK_UNUSED(read);
-    mpack_assert(track->elements, "null track elements!");
-
-    // if there are no open elements, that's fine, we can read/write elements at will
-    if (track->count == 0)
-        return mpack_ok;
-
-    mpack_track_element_t* element = &track->elements[track->count - 1];
-
-    if (element->type != mpack_type_map && element->type != mpack_type_array) {
-        mpack_break("elements cannot be %s within an %s", read ? "read" : "written",
-                mpack_type_to_string(element->type));
-        return mpack_error_bug;
-    }
-
-    if (element->left == 0) {
-        mpack_break("too many elements %s for %s", read ? "read" : "written",
-                mpack_type_to_string(element->type));
-        return mpack_error_bug;
-    }
-
-    return mpack_ok;
-}
-
-mpack_error_t mpack_track_element(mpack_track_t* track, bool read) {
-    mpack_error_t error = mpack_track_peek_element(track, read);
-    if (track->count > 0 && error == mpack_ok)
-        --track->elements[track->count - 1].left;
-    return error;
-}
-
-mpack_error_t mpack_track_bytes(mpack_track_t* track, bool read, uint64_t count) {
-    MPACK_UNUSED(read);
-    mpack_assert(track->elements, "null track elements!");
-
-    if (track->count == 0) {
-        mpack_break("bytes cannot be %s with no open bin, str or ext", read ? "read" : "written");
-        return mpack_error_bug;
-    }
-
-    mpack_track_element_t* element = &track->elements[track->count - 1];
-
-    if (element->type == mpack_type_map || element->type == mpack_type_array) {
-        mpack_break("bytes cannot be %s within an %s", read ? "read" : "written",
-                mpack_type_to_string(element->type));
-        return mpack_error_bug;
-    }
-
-    if (element->left < count) {
-        mpack_break("too many bytes %s for %s", read ? "read" : "written",
-                mpack_type_to_string(element->type));
-        return mpack_error_bug;
-    }
-
-    element->left -= count;
-    return mpack_ok;
-}
-
-mpack_error_t mpack_track_str_bytes_all(mpack_track_t* track, bool read, uint64_t count) {
-    mpack_error_t error = mpack_track_bytes(track, read, count);
-    if (error != mpack_ok)
-        return error;
-
-    mpack_track_element_t* element = &track->elements[track->count - 1];
-
-    if (element->type != mpack_type_str) {
-        mpack_break("the open type must be a string, not a %s", mpack_type_to_string(element->type));
-        return mpack_error_bug;
-    }
-
-    if (element->left != 0) {
-        mpack_break("not all bytes were read; the wrong byte count was requested for a string read.");
-        return mpack_error_bug;
-    }
-
-    return mpack_ok;
-}
-
-mpack_error_t mpack_track_check_empty(mpack_track_t* track) {
-    if (track->count != 0) {
-        mpack_break("unclosed %s", mpack_type_to_string(track->elements[0].type));
-        return mpack_error_bug;
-    }
-    return mpack_ok;
-}
-
-mpack_error_t mpack_track_destroy(mpack_track_t* track, bool cancel) {
-    mpack_error_t error = cancel ? mpack_ok : mpack_track_check_empty(track);
-    if (track->elements) {
-        MPACK_FREE(track->elements);
-        track->elements = NULL;
-    }
-    return error;
-}
-#endif
-
-
-
-static bool mpack_utf8_check_impl(const uint8_t* str, size_t count, bool allow_null) {
-    while (count > 0) {
-        uint8_t lead = str[0];
-
-        // NUL
-        if (!allow_null && lead == '\0') // we don't allow NUL bytes in MPack C-strings
-            return false;
-
-        // ASCII
-        if (lead <= 0x7F) {
-            ++str;
-            --count;
-
-        // 2-byte sequence
-        } else if ((lead & 0xE0) == 0xC0) {
-            if (count < 2) // truncated sequence
-                return false;
-
-            uint8_t cont = str[1];
-            if ((cont & 0xC0) != 0x80) // not a continuation byte
-                return false;
-
-            str += 2;
-            count -= 2;
-
-            uint32_t z = ((uint32_t)(lead & ~0xE0) << 6) |
-                          (uint32_t)(cont & ~0xC0);
-
-            if (z < 0x80) // overlong sequence
-                return false;
-
-        // 3-byte sequence
-        } else if ((lead & 0xF0) == 0xE0) {
-            if (count < 3) // truncated sequence
-                return false;
-
-            uint8_t cont1 = str[1];
-            if ((cont1 & 0xC0) != 0x80) // not a continuation byte
-                return false;
-            uint8_t cont2 = str[2];
-            if ((cont2 & 0xC0) != 0x80) // not a continuation byte
-                return false;
-
-            str += 3;
-            count -= 3;
-
-            uint32_t z = ((uint32_t)(lead  & ~0xF0) << 12) |
-                         ((uint32_t)(cont1 & ~0xC0) <<  6) |
-                          (uint32_t)(cont2 & ~0xC0);
-
-            if (z < 0x800) // overlong sequence
-                return false;
-            if (z >= 0xD800 && z <= 0xDFFF) // surrogate
-                return false;
-
-        // 4-byte sequence
-        } else if ((lead & 0xF8) == 0xF0) {
-            if (count < 4) // truncated sequence
-                return false;
-
-            uint8_t cont1 = str[1];
-            if ((cont1 & 0xC0) != 0x80) // not a continuation byte
-                return false;
-            uint8_t cont2 = str[2];
-            if ((cont2 & 0xC0) != 0x80) // not a continuation byte
-                return false;
-            uint8_t cont3 = str[3];
-            if ((cont3 & 0xC0) != 0x80) // not a continuation byte
-                return false;
-
-            str += 4;
-            count -= 4;
-
-            uint32_t z = ((uint32_t)(lead  & ~0xF8) << 18) |
-                         ((uint32_t)(cont1 & ~0xC0) << 12) |
-                         ((uint32_t)(cont2 & ~0xC0) <<  6) |
-                          (uint32_t)(cont3 & ~0xC0);
-
-            if (z < 0x10000) // overlong sequence
-                return false;
-            if (z > 0x10FFFF) // codepoint limit
-                return false;
-
-        } else {
-            return false; // continuation byte without a lead, or lead for a 5-byte sequence or longer
-        }
-    }
-    return true;
-}
-
-bool mpack_utf8_check(const char* str, size_t bytes) {
-    return mpack_utf8_check_impl((const uint8_t*)str, bytes, true);
-}
-
-bool mpack_utf8_check_no_null(const char* str, size_t bytes) {
-    return mpack_utf8_check_impl((const uint8_t*)str, bytes, false);
-}
-
-bool mpack_str_check_no_null(const char* str, size_t bytes) {
-    for (size_t i = 0; i < bytes; ++i)
-        if (str[i] == '\0')
-            return false;
-    return true;
-}
-
-#if MPACK_DEBUG && MPACK_STDIO
-void mpack_print_append(mpack_print_t* print, const char* data, size_t count) {
-
-    // copy whatever fits into the buffer
-    size_t copy = print->size - print->count;
-    if (copy > count)
-        copy = count;
-    mpack_memcpy(print->buffer + print->count, data, copy);
-    print->count += copy;
-    data += copy;
-    count -= copy;
-
-    // if we don't need to flush or can't flush there's nothing else to do
-    if (count == 0 || print->callback == NULL)
-        return;
-
-    // flush the buffer
-    print->callback(print->context, print->buffer, print->count);
-
-    if (count > print->size / 2) {
-        // flush the rest of the data
-        print->count = 0;
-        print->callback(print->context, data, count);
-    } else {
-        // copy the rest of the data into the buffer
-        mpack_memcpy(print->buffer, data, count);
-        print->count = count;
-    }
-
-}
-
-void mpack_print_flush(mpack_print_t* print) {
-    if (print->count > 0 && print->callback != NULL) {
-        print->callback(print->context, print->buffer, print->count);
-        print->count = 0;
-    }
-}
-
-void mpack_print_file_callback(void* context, const char* data, size_t count) {
-    FILE* file = (FILE*)context;
-    fwrite(data, 1, count, file);
-}
-#endif
-
-/* mpack/mpack-writer.c.c */
-
-#define MPACK_INTERNAL 1
-
-/* #include "mpack-writer.h" */
-
-#if MPACK_WRITER
-
-#if MPACK_WRITE_TRACKING
-static void mpack_writer_flag_if_error(mpack_writer_t* writer, mpack_error_t error) {
-    if (error != mpack_ok)
-        mpack_writer_flag_error(writer, error);
-}
-
-void mpack_writer_track_push(mpack_writer_t* writer, mpack_type_t type, uint64_t count) {
-    if (writer->error == mpack_ok)
-        mpack_writer_flag_if_error(writer, mpack_track_push(&writer->track, type, count));
-}
-
-void mpack_writer_track_pop(mpack_writer_t* writer, mpack_type_t type) {
-    if (writer->error == mpack_ok)
-        mpack_writer_flag_if_error(writer, mpack_track_pop(&writer->track, type));
-}
-
-void mpack_writer_track_element(mpack_writer_t* writer) {
-    if (writer->error == mpack_ok)
-        mpack_writer_flag_if_error(writer, mpack_track_element(&writer->track, false));
-}
-
-void mpack_writer_track_bytes(mpack_writer_t* writer, size_t count) {
-    if (writer->error == mpack_ok)
-        mpack_writer_flag_if_error(writer, mpack_track_bytes(&writer->track, false, count));
-}
-#endif
-
-static void mpack_writer_clear(mpack_writer_t* writer) {
-    #if MPACK_COMPATIBILITY
-    writer->version = mpack_version_current;
-    #endif
-    writer->flush = NULL;
-    writer->error_fn = NULL;
-    writer->teardown = NULL;
-    writer->context = NULL;
-
-    writer->buffer = NULL;
-    writer->current = NULL;
-    writer->end = NULL;
-    writer->error = mpack_ok;
-
-    #if MPACK_WRITE_TRACKING
-    mpack_memset(&writer->track, 0, sizeof(writer->track));
-    #endif
-}
-
-void mpack_writer_init(mpack_writer_t* writer, char* buffer, size_t size) {
-    mpack_assert(buffer != NULL, "cannot initialize writer with empty buffer");
-    mpack_writer_clear(writer);
-    writer->buffer = buffer;
-    writer->current = buffer;
-    writer->end = writer->buffer + size;
-
-    #if MPACK_WRITE_TRACKING
-    mpack_writer_flag_if_error(writer, mpack_track_init(&writer->track));
-    #endif
-
-    mpack_log("===========================\n");
-    mpack_log("initializing writer with buffer size %i\n", (int)size);
-}
-
-void mpack_writer_init_error(mpack_writer_t* writer, mpack_error_t error) {
-    mpack_writer_clear(writer);
-    writer->error = error;
-
-    mpack_log("===========================\n");
-    mpack_log("initializing writer in error state %i\n", (int)error);
-}
-
-void mpack_writer_set_flush(mpack_writer_t* writer, mpack_writer_flush_t flush) {
-    MPACK_STATIC_ASSERT(MPACK_WRITER_MINIMUM_BUFFER_SIZE >= MPACK_MAXIMUM_TAG_SIZE,
-            "minimum buffer size must fit any tag!");
-    MPACK_STATIC_ASSERT(31 + MPACK_TAG_SIZE_FIXSTR >= MPACK_WRITER_MINIMUM_BUFFER_SIZE,
-            "minimum buffer size must fit the largest possible fixstr!");
-
-    if (mpack_writer_buffer_size(writer) < MPACK_WRITER_MINIMUM_BUFFER_SIZE) {
-        mpack_break("buffer size is %i, but minimum buffer size for flush is %i",
-                (int)mpack_writer_buffer_size(writer), MPACK_WRITER_MINIMUM_BUFFER_SIZE);
-        mpack_writer_flag_error(writer, mpack_error_bug);
-        return;
-    }
-
-    writer->flush = flush;
-}
-
-#ifdef MPACK_MALLOC
-typedef struct mpack_growable_writer_t {
-    char** target_data;
-    size_t* target_size;
-} mpack_growable_writer_t;
-
-static char* mpack_writer_get_reserved(mpack_writer_t* writer) {
-    // This is in a separate function in order to avoid false strict aliasing
-    // warnings. We aren't actually violating strict aliasing (the reserved
-    // space is only ever dereferenced as an mpack_growable_writer_t.)
-    return (char*)writer->reserved;
-}
-
-static void mpack_growable_writer_flush(mpack_writer_t* writer, const char* data, size_t count) {
-
-    // This is an intrusive flush function which modifies the writer's buffer
-    // in response to a flush instead of emptying it in order to add more
-    // capacity for data. This removes the need to copy data from a fixed buffer
-    // into a growable one, improving performance.
-    //
-    // There are three ways flush can be called:
-    //   - flushing the buffer during writing (used is zero, count is all data, data is buffer)
-    //   - flushing extra data during writing (used is all flushed data, count is extra data, data is not buffer)
-    //   - flushing during teardown (used and count are both all flushed data, data is buffer)
-    //
-    // In the first two cases, we grow the buffer by at least double, enough
-    // to ensure that new data will fit. We ignore the teardown flush.
-
-    if (data == writer->buffer) {
-
-        // teardown, do nothing
-        if (mpack_writer_buffer_used(writer) == count)
-            return;
-
-        // otherwise leave the data in the buffer and just grow
-        writer->current = writer->buffer + count;
-        count = 0;
-    }
-
-    size_t used = mpack_writer_buffer_used(writer);
-    size_t size = mpack_writer_buffer_size(writer);
-
-    mpack_log("flush size %i used %i data %p buffer %p\n",
-            (int)count, (int)used, data, writer->buffer);
-
-    mpack_assert(data == writer->buffer || used + count > size,
-            "extra flush for %i but there is %i space left in the buffer! (%i/%i)",
-            (int)count, (int)mpack_writer_buffer_left(writer), (int)used, (int)size);
-
-    // grow to fit the data
-    // TODO: this really needs to correctly test for overflow
-    size_t new_size = size * 2;
-    while (new_size < used + count)
-        new_size *= 2;
-
-    mpack_log("flush growing buffer size from %i to %i\n", (int)size, (int)new_size);
-
-    // grow the buffer
-    char* new_buffer = (char*)mpack_realloc(writer->buffer, used, new_size);
-    if (new_buffer == NULL) {
-        mpack_writer_flag_error(writer, mpack_error_memory);
-        return;
-    }
-    writer->current = new_buffer + used;
-    writer->buffer = new_buffer;
-    writer->end = writer->buffer + new_size;
-
-    // append the extra data
-    if (count > 0) {
-        mpack_memcpy(writer->current, data, count);
-        writer->current += count;
-    }
-
-    mpack_log("new buffer %p, used %i\n", new_buffer, (int)mpack_writer_buffer_used(writer));
-}
-
-static void mpack_growable_writer_teardown(mpack_writer_t* writer) {
-    mpack_growable_writer_t* growable_writer = (mpack_growable_writer_t*)mpack_writer_get_reserved(writer);
-
-    if (mpack_writer_error(writer) == mpack_ok) {
-
-        // shrink the buffer to an appropriate size if the data is
-        // much smaller than the buffer
-        if (mpack_writer_buffer_used(writer) < mpack_writer_buffer_size(writer) / 2) {
-            size_t used = mpack_writer_buffer_used(writer);
-
-            // We always return a non-null pointer that must be freed, even if
-            // nothing was written. malloc() and realloc() do not necessarily
-            // do this so we enforce it ourselves.
-            size_t size = (used != 0) ? used : 1;
-
-            char* buffer = (char*)mpack_realloc(writer->buffer, used, size);
-            if (!buffer) {
-                MPACK_FREE(writer->buffer);
-                mpack_writer_flag_error(writer, mpack_error_memory);
-                return;
-            }
-            writer->buffer = buffer;
-            writer->end = (writer->current = writer->buffer + used);
-        }
-
-        *growable_writer->target_data = writer->buffer;
-        *growable_writer->target_size = mpack_writer_buffer_used(writer);
-        writer->buffer = NULL;
-
-    } else if (writer->buffer) {
-        MPACK_FREE(writer->buffer);
-        writer->buffer = NULL;
-    }
-
-    writer->context = NULL;
-}
-
-void mpack_writer_init_growable(mpack_writer_t* writer, char** target_data, size_t* target_size) {
-    mpack_assert(target_data != NULL, "cannot initialize writer without a destination for the data");
-    mpack_assert(target_size != NULL, "cannot initialize writer without a destination for the size");
-
-    *target_data = NULL;
-    *target_size = 0;
-
-    MPACK_STATIC_ASSERT(sizeof(mpack_growable_writer_t) <= sizeof(writer->reserved),
-            "not enough reserved space for growable writer!");
-    mpack_growable_writer_t* growable_writer = (mpack_growable_writer_t*)mpack_writer_get_reserved(writer);
-
-    growable_writer->target_data = target_data;
-    growable_writer->target_size = target_size;
-
-    size_t capacity = MPACK_BUFFER_SIZE;
-    char* buffer = (char*)MPACK_MALLOC(capacity);
-    if (buffer == NULL) {
-        mpack_writer_init_error(writer, mpack_error_memory);
-        return;
-    }
-
-    mpack_writer_init(writer, buffer, capacity);
-    mpack_writer_set_flush(writer, mpack_growable_writer_flush);
-    mpack_writer_set_teardown(writer, mpack_growable_writer_teardown);
-}
-#endif
-
-#if MPACK_STDIO
-static void mpack_file_writer_flush(mpack_writer_t* writer, const char* buffer, size_t count) {
-    FILE* file = (FILE*)writer->context;
-    size_t written = fwrite((const void*)buffer, 1, count, file);
-    if (written != count)
-        mpack_writer_flag_error(writer, mpack_error_io);
-}
-
-static void mpack_file_writer_teardown(mpack_writer_t* writer) {
-    MPACK_FREE(writer->buffer);
-    writer->buffer = NULL;
-    writer->context = NULL;
-}
-
-static void mpack_file_writer_teardown_close(mpack_writer_t* writer) {
-    FILE* file = (FILE*)writer->context;
-
-    if (file) {
-        int ret = fclose(file);
-        if (ret != 0)
-            mpack_writer_flag_error(writer, mpack_error_io);
-    }
-
-    mpack_file_writer_teardown(writer);
-}
-
-void mpack_writer_init_stdfile(mpack_writer_t* writer, FILE* file, bool close_when_done) {
-    mpack_assert(file != NULL, "file is NULL");
-
-    size_t capacity = MPACK_BUFFER_SIZE;
-    char* buffer = (char*)MPACK_MALLOC(capacity);
-    if (buffer == NULL) {
-        mpack_writer_init_error(writer, mpack_error_memory);
-        if (close_when_done) {
-            fclose(file);
-        }
-        return;
-    }
-
-    mpack_writer_init(writer, buffer, capacity);
-    mpack_writer_set_context(writer, file);
-    mpack_writer_set_flush(writer, mpack_file_writer_flush);
-    mpack_writer_set_teardown(writer, close_when_done ?
-            mpack_file_writer_teardown_close :
-            mpack_file_writer_teardown);
-}
-
-void mpack_writer_init_filename(mpack_writer_t* writer, const char* filename) {
-    mpack_assert(filename != NULL, "filename is NULL");
-
-    FILE* file = fopen(filename, "wb");
-    if (file == NULL) {
-        mpack_writer_init_error(writer, mpack_error_io);
-        return;
-    }
-
-    mpack_writer_init_stdfile(writer, file, true);
-}
-#endif
-
-void mpack_writer_flag_error(mpack_writer_t* writer, mpack_error_t error) {
-    mpack_log("writer %p setting error %i: %s\n", writer, (int)error, mpack_error_to_string(error));
-
-    if (writer->error == mpack_ok) {
-        writer->error = error;
-        if (writer->error_fn)
-            writer->error_fn(writer, writer->error);
-    }
-}
-
-MPACK_STATIC_INLINE void mpack_writer_flush_unchecked(mpack_writer_t* writer) {
-    // This is a bit ugly; we reset used before calling flush so that
-    // a flush function can distinguish between flushing the buffer
-    // versus flushing external data. see mpack_growable_writer_flush()
-    size_t used = mpack_writer_buffer_used(writer);
-    writer->current = writer->buffer;
-    writer->flush(writer, writer->buffer, used);
-}
-
-void mpack_writer_flush_message(mpack_writer_t* writer) {
-    if (writer->error != mpack_ok)
-        return;
-
-    #if MPACK_WRITE_TRACKING
-    mpack_writer_flag_if_error(writer, mpack_track_check_empty(&writer->track));
-    if (writer->error != mpack_ok)
-        return;
-    #endif
-
-    if (writer->flush == NULL) {
-        mpack_break("cannot call mpack_writer_flush_message() without a flush function!");
-        mpack_writer_flag_error(writer, mpack_error_bug);
-        return;
-    }
-
-    if (mpack_writer_buffer_used(writer) > 0)
-        mpack_writer_flush_unchecked(writer);
-}
-
-// Ensures there are at least count bytes free in the buffer. This
-// will flag an error if the flush function fails to make enough
-// room in the buffer.
-MPACK_NOINLINE static bool mpack_writer_ensure(mpack_writer_t* writer, size_t count) {
-    mpack_assert(count != 0, "cannot ensure zero bytes!");
-    mpack_assert(count <= MPACK_WRITER_MINIMUM_BUFFER_SIZE,
-            "cannot ensure %i bytes, this is more than the minimum buffer size %i!",
-            (int)count, (int)MPACK_WRITER_MINIMUM_BUFFER_SIZE);
-    mpack_assert(count > mpack_writer_buffer_left(writer),
-            "request to ensure %i bytes but there are already %i left in the buffer!",
-            (int)count, (int)mpack_writer_buffer_left(writer));
-
-    mpack_log("ensuring %i bytes, %i left\n", (int)count, (int)mpack_writer_buffer_left(writer));
-
-    if (mpack_writer_error(writer) != mpack_ok)
-        return false;
-
-    if (writer->flush == NULL) {
-        mpack_writer_flag_error(writer, mpack_error_too_big);
-        return false;
-    }
-
-    mpack_writer_flush_unchecked(writer);
-    if (mpack_writer_error(writer) != mpack_ok)
-        return false;
-
-    if (mpack_writer_buffer_left(writer) >= count)
-        return true;
-
-    mpack_writer_flag_error(writer, mpack_error_io);
-    return false;
-}
-
-// Writes encoded bytes to the buffer when we already know the data
-// does not fit in the buffer (i.e. it straddles the edge of the
-// buffer.) If there is a flush function, it is guaranteed to be
-// called; otherwise mpack_error_too_big is raised.
-MPACK_NOINLINE static void mpack_write_native_straddle(mpack_writer_t* writer, const char* p, size_t count) {
-    mpack_assert(count == 0 || p != NULL, "data pointer for %i bytes is NULL", (int)count);
-
-    if (mpack_writer_error(writer) != mpack_ok)
-        return;
-    mpack_log("big write for %i bytes from %p, %i space left in buffer\n",
-            (int)count, p, (int)mpack_writer_buffer_left(writer));
-    mpack_assert(count > mpack_writer_buffer_left(writer),
-            "big write requested for %i bytes, but there is %i available "
-            "space in buffer. should have called mpack_write_native() instead",
-            (int)count, (int)(mpack_writer_buffer_left(writer)));
-
-    // we'll need a flush function
-    if (!writer->flush) {
-        mpack_writer_flag_error(writer, mpack_error_too_big);
-        return;
-    }
-
-    // flush the buffer
-    mpack_writer_flush_unchecked(writer);
-    if (mpack_writer_error(writer) != mpack_ok)
-        return;
-
-    // note that an intrusive flush function (such as mpack_growable_writer_flush())
-    // may have changed size and/or reset used to a non-zero value. we treat both as
-    // though they may have changed, and there may still be data in the buffer.
-
-    // flush the extra data directly if it doesn't fit in the buffer
-    if (count > mpack_writer_buffer_left(writer)) {
-        writer->flush(writer, p, count);
-        if (mpack_writer_error(writer) != mpack_ok)
-            return;
-    } else {
-        mpack_memcpy(writer->current, p, count);
-        writer->current += count;
-    }
-}
-
-// Writes encoded bytes to the buffer, flushing if necessary.
-MPACK_STATIC_INLINE void mpack_write_native(mpack_writer_t* writer, const char* p, size_t count) {
-    mpack_assert(count == 0 || p != NULL, "data pointer for %i bytes is NULL", (int)count);
-
-    if (mpack_writer_buffer_left(writer) < count) {
-        mpack_write_native_straddle(writer, p, count);
-    } else {
-        mpack_memcpy(writer->current, p, count);
-        writer->current += count;
-    }
-}
-
-mpack_error_t mpack_writer_destroy(mpack_writer_t* writer) {
-
-    // clean up tracking, asserting if we're not already in an error state
-    #if MPACK_WRITE_TRACKING
-    mpack_track_destroy(&writer->track, writer->error != mpack_ok);
-    #endif
-
-    // flush any outstanding data
-    if (mpack_writer_error(writer) == mpack_ok && mpack_writer_buffer_used(writer) != 0 && writer->flush != NULL) {
-        writer->flush(writer, writer->buffer, mpack_writer_buffer_used(writer));
-        writer->flush = NULL;
-    }
-
-    if (writer->teardown) {
-        writer->teardown(writer);
-        writer->teardown = NULL;
-    }
-
-    return writer->error;
-}
-
-void mpack_write_tag(mpack_writer_t* writer, mpack_tag_t value) {
-    switch (value.type) {
-        case mpack_type_missing:
-            mpack_break("cannot write a missing value!");
-            mpack_writer_flag_error(writer, mpack_error_bug);
-            return;
-
-        case mpack_type_nil:    mpack_write_nil   (writer);            return;
-        case mpack_type_bool:   mpack_write_bool  (writer, value.v.b); return;
-        case mpack_type_float:  mpack_write_float (writer, value.v.f); return;
-        case mpack_type_double: mpack_write_double(writer, value.v.d); return;
-        case mpack_type_int:    mpack_write_int   (writer, value.v.i); return;
-        case mpack_type_uint:   mpack_write_uint  (writer, value.v.u); return;
-
-        case mpack_type_str: mpack_start_str(writer, value.v.l); return;
-        case mpack_type_bin: mpack_start_bin(writer, value.v.l); return;
-
-        #if MPACK_EXTENSIONS
-        case mpack_type_ext:
-            mpack_start_ext(writer, mpack_tag_ext_exttype(&value), mpack_tag_ext_length(&value));
-            return;
-        #endif
-
-        case mpack_type_array: mpack_start_array(writer, value.v.n); return;
-        case mpack_type_map:   mpack_start_map(writer, value.v.n);   return;
-    }
-
-    mpack_break("unrecognized type %i", (int)value.type);
-    mpack_writer_flag_error(writer, mpack_error_bug);
-}
-
-MPACK_STATIC_INLINE void mpack_write_byte_element(mpack_writer_t* writer, char value) {
-    mpack_writer_track_element(writer);
-    if (MPACK_LIKELY(mpack_writer_buffer_left(writer) >= 1) || mpack_writer_ensure(writer, 1))
-        *(writer->current++) = value;
-}
-
-void mpack_write_nil(mpack_writer_t* writer) {
-    mpack_write_byte_element(writer, (char)0xc0);
-}
-
-void mpack_write_bool(mpack_writer_t* writer, bool value) {
-    mpack_write_byte_element(writer, (char)(0xc2 | (value ? 1 : 0)));
-}
-
-void mpack_write_true(mpack_writer_t* writer) {
-    mpack_write_byte_element(writer, (char)0xc3);
-}
-
-void mpack_write_false(mpack_writer_t* writer) {
-    mpack_write_byte_element(writer, (char)0xc2);
-}
-
-void mpack_write_object_bytes(mpack_writer_t* writer, const char* data, size_t bytes) {
-    mpack_writer_track_element(writer);
-    mpack_write_native(writer, data, bytes);
-}
-
-/*
- * Encode functions
- */
-
-MPACK_STATIC_INLINE void mpack_encode_fixuint(char* p, uint8_t value) {
-    mpack_assert(value <= 127);
-    mpack_store_u8(p, value);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_u8(char* p, uint8_t value) {
-    mpack_assert(value > 127);
-    mpack_store_u8(p, 0xcc);
-    mpack_store_u8(p + 1, value);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_u16(char* p, uint16_t value) {
-    mpack_assert(value > UINT8_MAX);
-    mpack_store_u8(p, 0xcd);
-    mpack_store_u16(p + 1, value);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_u32(char* p, uint32_t value) {
-    mpack_assert(value > UINT16_MAX);
-    mpack_store_u8(p, 0xce);
-    mpack_store_u32(p + 1, value);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_u64(char* p, uint64_t value) {
-    mpack_assert(value > UINT32_MAX);
-    mpack_store_u8(p, 0xcf);
-    mpack_store_u64(p + 1, value);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_fixint(char* p, int8_t value) {
-    // this can encode positive or negative fixints
-    mpack_assert(value >= -32);
-    mpack_store_i8(p, value);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_i8(char* p, int8_t value) {
-    mpack_assert(value < -32);
-    mpack_store_u8(p, 0xd0);
-    mpack_store_i8(p + 1, value);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_i16(char* p, int16_t value) {
-    mpack_assert(value < INT8_MIN);
-    mpack_store_u8(p, 0xd1);
-    mpack_store_i16(p + 1, value);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_i32(char* p, int32_t value) {
-    mpack_assert(value < INT16_MIN);
-    mpack_store_u8(p, 0xd2);
-    mpack_store_i32(p + 1, value);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_i64(char* p, int64_t value) {
-    mpack_assert(value < INT32_MIN);
-    mpack_store_u8(p, 0xd3);
-    mpack_store_i64(p + 1, value);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_float(char* p, float value) {
-    mpack_store_u8(p, 0xca);
-    mpack_store_float(p + 1, value);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_double(char* p, double value) {
-    mpack_store_u8(p, 0xcb);
-    mpack_store_double(p + 1, value);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_fixarray(char* p, uint8_t count) {
-    mpack_assert(count <= 15);
-    mpack_store_u8(p, (uint8_t)(0x90 | count));
-}
-
-MPACK_STATIC_INLINE void mpack_encode_array16(char* p, uint16_t count) {
-    mpack_assert(count > 15);
-    mpack_store_u8(p, 0xdc);
-    mpack_store_u16(p + 1, count);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_array32(char* p, uint32_t count) {
-    mpack_assert(count > UINT16_MAX);
-    mpack_store_u8(p, 0xdd);
-    mpack_store_u32(p + 1, count);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_fixmap(char* p, uint8_t count) {
-    mpack_assert(count <= 15);
-    mpack_store_u8(p, (uint8_t)(0x80 | count));
-}
-
-MPACK_STATIC_INLINE void mpack_encode_map16(char* p, uint16_t count) {
-    mpack_assert(count > 15);
-    mpack_store_u8(p, 0xde);
-    mpack_store_u16(p + 1, count);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_map32(char* p, uint32_t count) {
-    mpack_assert(count > UINT16_MAX);
-    mpack_store_u8(p, 0xdf);
-    mpack_store_u32(p + 1, count);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_fixstr(char* p, uint8_t count) {
-    mpack_assert(count <= 31);
-    mpack_store_u8(p, (uint8_t)(0xa0 | count));
-}
-
-MPACK_STATIC_INLINE void mpack_encode_str8(char* p, uint8_t count) {
-    mpack_assert(count > 31);
-    mpack_store_u8(p, 0xd9);
-    mpack_store_u8(p + 1, count);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_str16(char* p, uint16_t count) {
-    // we might be encoding a raw in compatibility mode, so we
-    // allow count to be in the range [32, UINT8_MAX].
-    mpack_assert(count > 31);
-    mpack_store_u8(p, 0xda);
-    mpack_store_u16(p + 1, count);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_str32(char* p, uint32_t count) {
-    mpack_assert(count > UINT16_MAX);
-    mpack_store_u8(p, 0xdb);
-    mpack_store_u32(p + 1, count);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_bin8(char* p, uint8_t count) {
-    mpack_store_u8(p, 0xc4);
-    mpack_store_u8(p + 1, count);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_bin16(char* p, uint16_t count) {
-    mpack_assert(count > UINT8_MAX);
-    mpack_store_u8(p, 0xc5);
-    mpack_store_u16(p + 1, count);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_bin32(char* p, uint32_t count) {
-    mpack_assert(count > UINT16_MAX);
-    mpack_store_u8(p, 0xc6);
-    mpack_store_u32(p + 1, count);
-}
-
-#if MPACK_EXTENSIONS
-MPACK_STATIC_INLINE void mpack_encode_fixext1(char* p, int8_t exttype) {
-    mpack_store_u8(p, 0xd4);
-    mpack_store_i8(p + 1, exttype);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_fixext2(char* p, int8_t exttype) {
-    mpack_store_u8(p, 0xd5);
-    mpack_store_i8(p + 1, exttype);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_fixext4(char* p, int8_t exttype) {
-    mpack_store_u8(p, 0xd6);
-    mpack_store_i8(p + 1, exttype);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_fixext8(char* p, int8_t exttype) {
-    mpack_store_u8(p, 0xd7);
-    mpack_store_i8(p + 1, exttype);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_fixext16(char* p, int8_t exttype) {
-    mpack_store_u8(p, 0xd8);
-    mpack_store_i8(p + 1, exttype);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_ext8(char* p, int8_t exttype, uint8_t count) {
-    mpack_assert(count != 1 && count != 2 && count != 4 && count != 8 && count != 16);
-    mpack_store_u8(p, 0xc7);
-    mpack_store_u8(p + 1, count);
-    mpack_store_i8(p + 2, exttype);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_ext16(char* p, int8_t exttype, uint16_t count) {
-    mpack_assert(count > UINT8_MAX);
-    mpack_store_u8(p, 0xc8);
-    mpack_store_u16(p + 1, count);
-    mpack_store_i8(p + 3, exttype);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_ext32(char* p, int8_t exttype, uint32_t count) {
-    mpack_assert(count > UINT16_MAX);
-    mpack_store_u8(p, 0xc9);
-    mpack_store_u32(p + 1, count);
-    mpack_store_i8(p + 5, exttype);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_timestamp_4(char* p, uint32_t seconds) {
-    mpack_encode_fixext4(p, MPACK_EXTTYPE_TIMESTAMP);
-    mpack_store_u32(p + MPACK_TAG_SIZE_FIXEXT4, seconds);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_timestamp_8(char* p, int64_t seconds, uint32_t nanoseconds) {
-    mpack_assert(nanoseconds <= MPACK_TIMESTAMP_NANOSECONDS_MAX);
-    mpack_encode_fixext8(p, MPACK_EXTTYPE_TIMESTAMP);
-    uint64_t encoded = ((uint64_t)nanoseconds << 34) | (uint64_t)seconds;
-    mpack_store_u64(p + MPACK_TAG_SIZE_FIXEXT8, encoded);
-}
-
-MPACK_STATIC_INLINE void mpack_encode_timestamp_12(char* p, int64_t seconds, uint32_t nanoseconds) {
-    mpack_assert(nanoseconds <= MPACK_TIMESTAMP_NANOSECONDS_MAX);
-    mpack_encode_ext8(p, MPACK_EXTTYPE_TIMESTAMP, 12);
-    mpack_store_u32(p + MPACK_TAG_SIZE_EXT8, nanoseconds);
-    mpack_store_i64(p + MPACK_TAG_SIZE_EXT8 + 4, seconds);
-}
-#endif
-
-
-
-/*
- * Write functions
- */
-
-// This is a macro wrapper to the encode functions to encode
-// directly into the buffer. If mpack_writer_ensure() fails
-// it will flag an error so we don't have to do anything.
-#define MPACK_WRITE_ENCODED(encode_fn, size, ...) do {                                                 \
-    if (MPACK_LIKELY(mpack_writer_buffer_left(writer) >= size) || mpack_writer_ensure(writer, size)) { \
-        MPACK_EXPAND(encode_fn(writer->current, __VA_ARGS__));                                         \
-        writer->current += size;                                                                       \
-    }                                                                                                  \
-} while (0)
-
-void mpack_write_u8(mpack_writer_t* writer, uint8_t value) {
-    #if MPACK_OPTIMIZE_FOR_SIZE
-    mpack_write_u64(writer, value);
-    #else
-    mpack_writer_track_element(writer);
-    if (value <= 127) {
-        MPACK_WRITE_ENCODED(mpack_encode_fixuint, MPACK_TAG_SIZE_FIXUINT, value);
-    } else {
-        MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, value);
-    }
-    #endif
-}
-
-void mpack_write_u16(mpack_writer_t* writer, uint16_t value) {
-    #if MPACK_OPTIMIZE_FOR_SIZE
-    mpack_write_u64(writer, value);
-    #else
-    mpack_writer_track_element(writer);
-    if (value <= 127) {
-        MPACK_WRITE_ENCODED(mpack_encode_fixuint, MPACK_TAG_SIZE_FIXUINT, (uint8_t)value);
-    } else if (value <= UINT8_MAX) {
-        MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value);
-    } else {
-        MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, value);
-    }
-    #endif
-}
-
-void mpack_write_u32(mpack_writer_t* writer, uint32_t value) {
-    #if MPACK_OPTIMIZE_FOR_SIZE
-    mpack_write_u64(writer, value);
-    #else
-    mpack_writer_track_element(writer);
-    if (value <= 127) {
-        MPACK_WRITE_ENCODED(mpack_encode_fixuint, MPACK_TAG_SIZE_FIXUINT, (uint8_t)value);
-    } else if (value <= UINT8_MAX) {
-        MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value);
-    } else if (value <= UINT16_MAX) {
-        MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, (uint16_t)value);
-    } else {
-        MPACK_WRITE_ENCODED(mpack_encode_u32, MPACK_TAG_SIZE_U32, value);
-    }
-    #endif
-}
-
-void mpack_write_u64(mpack_writer_t* writer, uint64_t value) {
-    mpack_writer_track_element(writer);
-
-    if (value <= 127) {
-        MPACK_WRITE_ENCODED(mpack_encode_fixuint, MPACK_TAG_SIZE_FIXUINT, (uint8_t)value);
-    } else if (value <= UINT8_MAX) {
-        MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value);
-    } else if (value <= UINT16_MAX) {
-        MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, (uint16_t)value);
-    } else if (value <= UINT32_MAX) {
-        MPACK_WRITE_ENCODED(mpack_encode_u32, MPACK_TAG_SIZE_U32, (uint32_t)value);
-    } else {
-        MPACK_WRITE_ENCODED(mpack_encode_u64, MPACK_TAG_SIZE_U64, value);
-    }
-}
-
-void mpack_write_i8(mpack_writer_t* writer, int8_t value) {
-    #if MPACK_OPTIMIZE_FOR_SIZE
-    mpack_write_i64(writer, value);
-    #else
-    mpack_writer_track_element(writer);
-    if (value >= -32) {
-        // we encode positive and negative fixints together
-        MPACK_WRITE_ENCODED(mpack_encode_fixint, MPACK_TAG_SIZE_FIXINT, (int8_t)value);
-    } else {
-        MPACK_WRITE_ENCODED(mpack_encode_i8, MPACK_TAG_SIZE_I8, (int8_t)value);
-    }
-    #endif
-}
-
-void mpack_write_i16(mpack_writer_t* writer, int16_t value) {
-    #if MPACK_OPTIMIZE_FOR_SIZE
-    mpack_write_i64(writer, value);
-    #else
-    mpack_writer_track_element(writer);
-    if (value >= -32) {
-        if (value <= 127) {
-            // we encode positive and negative fixints together
-            MPACK_WRITE_ENCODED(mpack_encode_fixint, MPACK_TAG_SIZE_FIXINT, (int8_t)value);
-        } else if (value <= UINT8_MAX) {
-            MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value);
-        } else {
-            MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, (uint16_t)value);
-        }
-    } else if (value >= INT8_MIN) {
-        MPACK_WRITE_ENCODED(mpack_encode_i8, MPACK_TAG_SIZE_I8, (int8_t)value);
-    } else {
-        MPACK_WRITE_ENCODED(mpack_encode_i16, MPACK_TAG_SIZE_I16, (int16_t)value);
-    }
-    #endif
-}
-
-void mpack_write_i32(mpack_writer_t* writer, int32_t value) {
-    #if MPACK_OPTIMIZE_FOR_SIZE
-    mpack_write_i64(writer, value);
-    #else
-    mpack_writer_track_element(writer);
-    if (value >= -32) {
-        if (value <= 127) {
-            // we encode positive and negative fixints together
-            MPACK_WRITE_ENCODED(mpack_encode_fixint, MPACK_TAG_SIZE_FIXINT, (int8_t)value);
-        } else if (value <= UINT8_MAX) {
-            MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value);
-        } else if (value <= UINT16_MAX) {
-            MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, (uint16_t)value);
-        } else {
-            MPACK_WRITE_ENCODED(mpack_encode_u32, MPACK_TAG_SIZE_U32, (uint32_t)value);
-        }
-    } else if (value >= INT8_MIN) {
-        MPACK_WRITE_ENCODED(mpack_encode_i8, MPACK_TAG_SIZE_I8, (int8_t)value);
-    } else if (value >= INT16_MIN) {
-        MPACK_WRITE_ENCODED(mpack_encode_i16, MPACK_TAG_SIZE_I16, (int16_t)value);
-    } else {
-        MPACK_WRITE_ENCODED(mpack_encode_i32, MPACK_TAG_SIZE_I32, value);
-    }
-    #endif
-}
-
-void mpack_write_i64(mpack_writer_t* writer, int64_t value) {
-    #if MPACK_OPTIMIZE_FOR_SIZE
-    if (value > 127) {
-        // for non-fix positive ints we call the u64 writer to save space
-        mpack_write_u64(writer, (uint64_t)value);
-        return;
-    }
-    #endif
-
-    mpack_writer_track_element(writer);
-    if (value >= -32) {
-        #if MPACK_OPTIMIZE_FOR_SIZE
-        MPACK_WRITE_ENCODED(mpack_encode_fixint, MPACK_TAG_SIZE_FIXINT, (int8_t)value);
-        #else
-        if (value <= 127) {
-            MPACK_WRITE_ENCODED(mpack_encode_fixint, MPACK_TAG_SIZE_FIXINT, (int8_t)value);
-        } else if (value <= UINT8_MAX) {
-            MPACK_WRITE_ENCODED(mpack_encode_u8, MPACK_TAG_SIZE_U8, (uint8_t)value);
-        } else if (value <= UINT16_MAX) {
-            MPACK_WRITE_ENCODED(mpack_encode_u16, MPACK_TAG_SIZE_U16, (uint16_t)value);
-        } else if (value <= UINT32_MAX) {
-            MPACK_WRITE_ENCODED(mpack_encode_u32, MPACK_TAG_SIZE_U32, (uint32_t)value);
-        } else {
-            MPACK_WRITE_ENCODED(mpack_encode_u64, MPACK_TAG_SIZE_U64, (uint64_t)value);
-        }
-        #endif
-    } else if (value >= INT8_MIN) {
-        MPACK_WRITE_ENCODED(mpack_encode_i8, MPACK_TAG_SIZE_I8, (int8_t)value);
-    } else if (value >= INT16_MIN) {
-        MPACK_WRITE_ENCODED(mpack_encode_i16, MPACK_TAG_SIZE_I16, (int16_t)value);
-    } else if (value >= INT32_MIN) {
-        MPACK_WRITE_ENCODED(mpack_encode_i32, MPACK_TAG_SIZE_I32, (int32_t)value);
-    } else {
-        MPACK_WRITE_ENCODED(mpack_encode_i64, MPACK_TAG_SIZE_I64, value);
-    }
-}
-
-void mpack_write_float(mpack_writer_t* writer, float value) {
-    mpack_writer_track_element(writer);
-    MPACK_WRITE_ENCODED(mpack_encode_float, MPACK_TAG_SIZE_FLOAT, value);
-}
-
-void mpack_write_double(mpack_writer_t* writer, double value) {
-    mpack_writer_track_element(writer);
-    MPACK_WRITE_ENCODED(mpack_encode_double, MPACK_TAG_SIZE_DOUBLE, value);
-}
-
-#if MPACK_EXTENSIONS
-void mpack_write_timestamp(mpack_writer_t* writer, int64_t seconds, uint32_t nanoseconds) {
-    #if MPACK_COMPATIBILITY
-    if (writer->version <= mpack_version_v4) {
-        mpack_break("Timestamps require spec version v5 or later. This writer is in v%i mode.", (int)writer->version);
-        mpack_writer_flag_error(writer, mpack_error_bug);
-        return;
-    }
-    #endif
-
-    if (nanoseconds > MPACK_TIMESTAMP_NANOSECONDS_MAX) {
-        mpack_break("timestamp nanoseconds out of bounds: %u", nanoseconds);
-        mpack_writer_flag_error(writer, mpack_error_bug);
-        return;
-    }
-
-    mpack_writer_track_element(writer);
-
-    if (seconds < 0 || seconds >= (INT64_C(1) << 34)) {
-        MPACK_WRITE_ENCODED(mpack_encode_timestamp_12, MPACK_EXT_SIZE_TIMESTAMP12, seconds, nanoseconds);
-    } else if (seconds > UINT32_MAX || nanoseconds > 0) {
-        MPACK_WRITE_ENCODED(mpack_encode_timestamp_8, MPACK_EXT_SIZE_TIMESTAMP8, seconds, nanoseconds);
-    } else {
-        MPACK_WRITE_ENCODED(mpack_encode_timestamp_4, MPACK_EXT_SIZE_TIMESTAMP4, (uint32_t)seconds);
-    }
-}
-#endif
-
-void mpack_start_array(mpack_writer_t* writer, uint32_t count) {
-    mpack_writer_track_element(writer);
-
-    if (count <= 15) {
-        MPACK_WRITE_ENCODED(mpack_encode_fixarray, MPACK_TAG_SIZE_FIXARRAY, (uint8_t)count);
-    } else if (count <= UINT16_MAX) {
-        MPACK_WRITE_ENCODED(mpack_encode_array16, MPACK_TAG_SIZE_ARRAY16, (uint16_t)count);
-    } else {
-        MPACK_WRITE_ENCODED(mpack_encode_array32, MPACK_TAG_SIZE_ARRAY32, (uint32_t)count);
-    }
-
-    mpack_writer_track_push(writer, mpack_type_array, count);
-}
-
-void mpack_start_map(mpack_writer_t* writer, uint32_t count) {
-    mpack_writer_track_element(writer);
-
-    if (count <= 15) {
-        MPACK_WRITE_ENCODED(mpack_encode_fixmap, MPACK_TAG_SIZE_FIXMAP, (uint8_t)count);
-    } else if (count <= UINT16_MAX) {
-        MPACK_WRITE_ENCODED(mpack_encode_map16, MPACK_TAG_SIZE_MAP16, (uint16_t)count);
-    } else {
-        MPACK_WRITE_ENCODED(mpack_encode_map32, MPACK_TAG_SIZE_MAP32, (uint32_t)count);
-    }
-
-    mpack_writer_track_push(writer, mpack_type_map, count);
-}
-
-static void mpack_start_str_notrack(mpack_writer_t* writer, uint32_t count) {
-    if (count <= 31) {
-        MPACK_WRITE_ENCODED(mpack_encode_fixstr, MPACK_TAG_SIZE_FIXSTR, (uint8_t)count);
-
-    // str8 is only supported in v5 or later.
-    } else if (count <= UINT8_MAX
-            #if MPACK_COMPATIBILITY
-            && writer->version >= mpack_version_v5
-            #endif
-            ) {
-        MPACK_WRITE_ENCODED(mpack_encode_str8, MPACK_TAG_SIZE_STR8, (uint8_t)count);
-
-    } else if (count <= UINT16_MAX) {
-        MPACK_WRITE_ENCODED(mpack_encode_str16, MPACK_TAG_SIZE_STR16, (uint16_t)count);
-    } else {
-        MPACK_WRITE_ENCODED(mpack_encode_str32, MPACK_TAG_SIZE_STR32, (uint32_t)count);
-    }
-}
-
-static void mpack_start_bin_notrack(mpack_writer_t* writer, uint32_t count) {
-    #if MPACK_COMPATIBILITY
-    // In the v4 spec, there was only the raw type for any kind of
-    // variable-length data. In v4 mode, we support the bin functions,
-    // but we produce an old-style raw.
-    if (writer->version <= mpack_version_v4) {
-        mpack_start_str_notrack(writer, count);
-        return;
-    }
-    #endif
-
-    if (count <= UINT8_MAX) {
-        MPACK_WRITE_ENCODED(mpack_encode_bin8, MPACK_TAG_SIZE_BIN8, (uint8_t)count);
-    } else if (count <= UINT16_MAX) {
-        MPACK_WRITE_ENCODED(mpack_encode_bin16, MPACK_TAG_SIZE_BIN16, (uint16_t)count);
-    } else {
-        MPACK_WRITE_ENCODED(mpack_encode_bin32, MPACK_TAG_SIZE_BIN32, (uint32_t)count);
-    }
-}
-
-void mpack_start_str(mpack_writer_t* writer, uint32_t count) {
-    mpack_writer_track_element(writer);
-    mpack_start_str_notrack(writer, count);
-    mpack_writer_track_push(writer, mpack_type_str, count);
-}
-
-void mpack_start_bin(mpack_writer_t* writer, uint32_t count) {
-    mpack_writer_track_element(writer);
-    mpack_start_bin_notrack(writer, count);
-    mpack_writer_track_push(writer, mpack_type_bin, count);
-}
-
-#if MPACK_EXTENSIONS
-void mpack_start_ext(mpack_writer_t* writer, int8_t exttype, uint32_t count) {
-    #if MPACK_COMPATIBILITY
-    if (writer->version <= mpack_version_v4) {
-        mpack_break("Ext types require spec version v5 or later. This writer is in v%i mode.", (int)writer->version);
-        mpack_writer_flag_error(writer, mpack_error_bug);
-        return;
-    }
-    #endif
-
-    mpack_writer_track_element(writer);
-
-    if (count == 1) {
-        MPACK_WRITE_ENCODED(mpack_encode_fixext1, MPACK_TAG_SIZE_FIXEXT1, exttype);
-    } else if (count == 2) {
-        MPACK_WRITE_ENCODED(mpack_encode_fixext2, MPACK_TAG_SIZE_FIXEXT2, exttype);
-    } else if (count == 4) {
-        MPACK_WRITE_ENCODED(mpack_encode_fixext4, MPACK_TAG_SIZE_FIXEXT4, exttype);
-    } else if (count == 8) {
-        MPACK_WRITE_ENCODED(mpack_encode_fixext8, MPACK_TAG_SIZE_FIXEXT8, exttype);
-    } else if (count == 16) {
-        MPACK_WRITE_ENCODED(mpack_encode_fixext16, MPACK_TAG_SIZE_FIXEXT16, exttype);
-    } else if (count <= UINT8_MAX) {
-        MPACK_WRITE_ENCODED(mpack_encode_ext8, MPACK_TAG_SIZE_EXT8, exttype, (uint8_t)count);
-    } else if (count <= UINT16_MAX) {
-        MPACK_WRITE_ENCODED(mpack_encode_ext16, MPACK_TAG_SIZE_EXT16, exttype, (uint16_t)count);
-    } else {
-        MPACK_WRITE_ENCODED(mpack_encode_ext32, MPACK_TAG_SIZE_EXT32, exttype, (uint32_t)count);
-    }
-
-    mpack_writer_track_push(writer, mpack_type_ext, count);
-}
-#endif
-
-
-
-/*
- * Compound helpers and other functions
- */
-
-void mpack_write_str(mpack_writer_t* writer, const char* data, uint32_t count) {
-    mpack_assert(data != NULL, "data for string of length %i is NULL", (int)count);
-
-    #if MPACK_OPTIMIZE_FOR_SIZE
-    mpack_writer_track_element(writer);
-    mpack_start_str_notrack(writer, count);
-    mpack_write_native(writer, data, count);
-    #else
-
-    mpack_writer_track_element(writer);
-
-    if (count <= 31) {
-        // The minimum buffer size when using a flush function is guaranteed to
-        // fit the largest possible fixstr.
-        size_t size = count + MPACK_TAG_SIZE_FIXSTR;
-        if (MPACK_LIKELY(mpack_writer_buffer_left(writer) >= size) || mpack_writer_ensure(writer, size)) {
-            char* MPACK_RESTRICT p = writer->current;
-            mpack_encode_fixstr(p, (uint8_t)count);
-            mpack_memcpy(p + MPACK_TAG_SIZE_FIXSTR, data, count);
-            writer->current += count + MPACK_TAG_SIZE_FIXSTR;
-        }
-        return;
-    }
-
-    if (count <= UINT8_MAX
-            #if MPACK_COMPATIBILITY
-            && writer->version >= mpack_version_v5
-            #endif
-            ) {
-        if (count + MPACK_TAG_SIZE_STR8 <= mpack_writer_buffer_left(writer)) {
-            char* MPACK_RESTRICT p = writer->current;
-            mpack_encode_str8(p, (uint8_t)count);
-            mpack_memcpy(p + MPACK_TAG_SIZE_STR8, data, count);
-            writer->current += count + MPACK_TAG_SIZE_STR8;
-        } else {
-            MPACK_WRITE_ENCODED(mpack_encode_str8, MPACK_TAG_SIZE_STR8, (uint8_t)count);
-            mpack_write_native(writer, data, count);
-        }
-        return;
-    }
-
-    // str16 and str32 are likely to be a significant fraction of the buffer
-    // size, so we don't bother with a combined space check in order to
-    // minimize code size.
-    if (count <= UINT16_MAX) {
-        MPACK_WRITE_ENCODED(mpack_encode_str16, MPACK_TAG_SIZE_STR16, (uint16_t)count);
-        mpack_write_native(writer, data, count);
-    } else {
-        MPACK_WRITE_ENCODED(mpack_encode_str32, MPACK_TAG_SIZE_STR32, (uint32_t)count);
-        mpack_write_native(writer, data, count);
-    }
-
-    #endif
-}
-
-void mpack_write_bin(mpack_writer_t* writer, const char* data, uint32_t count) {
-    mpack_assert(data != NULL, "data pointer for bin of %i bytes is NULL", (int)count);
-    mpack_start_bin(writer, count);
-    mpack_write_bytes(writer, data, count);
-    mpack_finish_bin(writer);
-}
-
-#if MPACK_EXTENSIONS
-void mpack_write_ext(mpack_writer_t* writer, int8_t exttype, const char* data, uint32_t count) {
-    mpack_assert(data != NULL, "data pointer for ext of type %i and %i bytes is NULL", exttype, (int)count);
-    mpack_start_ext(writer, exttype, count);
-    mpack_write_bytes(writer, data, count);
-    mpack_finish_ext(writer);
-}
-#endif
-
-void mpack_write_bytes(mpack_writer_t* writer, const char* data, size_t count) {
-    mpack_assert(data != NULL, "data pointer for %i bytes is NULL", (int)count);
-    mpack_writer_track_bytes(writer, count);
-    mpack_write_native(writer, data, count);
-}
-
-void mpack_write_cstr(mpack_writer_t* writer, const char* cstr) {
-    mpack_assert(cstr != NULL, "cstr pointer is NULL");
-    size_t length = mpack_strlen(cstr);
-    if (length > UINT32_MAX)
-        mpack_writer_flag_error(writer, mpack_error_invalid);
-    mpack_write_str(writer, cstr, (uint32_t)length);
-}
-
-void mpack_write_cstr_or_nil(mpack_writer_t* writer, const char* cstr) {
-    if (cstr)
-        mpack_write_cstr(writer, cstr);
-    else
-        mpack_write_nil(writer);
-}
-
-void mpack_write_utf8(mpack_writer_t* writer, const char* str, uint32_t length) {
-    mpack_assert(str != NULL, "data for string of length %i is NULL", (int)length);
-    if (!mpack_utf8_check(str, length)) {
-        mpack_writer_flag_error(writer, mpack_error_invalid);
-        return;
-    }
-    mpack_write_str(writer, str, length);
-}
-
-void mpack_write_utf8_cstr(mpack_writer_t* writer, const char* cstr) {
-    mpack_assert(cstr != NULL, "cstr pointer is NULL");
-    size_t length = mpack_strlen(cstr);
-    if (length > UINT32_MAX) {
-        mpack_writer_flag_error(writer, mpack_error_invalid);
-        return;
-    }
-    mpack_write_utf8(writer, cstr, (uint32_t)length);
-}
-
-void mpack_write_utf8_cstr_or_nil(mpack_writer_t* writer, const char* cstr) {
-    if (cstr)
-        mpack_write_utf8_cstr(writer, cstr);
-    else
-        mpack_write_nil(writer);
-}
-
-#endif
-
-
-/* mpack/mpack-reader.c.c */
-
-#define MPACK_INTERNAL 1
-
-/* #include "mpack-reader.h" */
-
-#if MPACK_READER
-
-static void mpack_reader_skip_using_fill(mpack_reader_t* reader, size_t count);
-
-void mpack_reader_init(mpack_reader_t* reader, char* buffer, size_t size, size_t count) {
-    mpack_assert(buffer != NULL, "buffer is NULL");
-
-    mpack_memset(reader, 0, sizeof(*reader));
-    reader->buffer = buffer;
-    reader->size = size;
-    reader->data = buffer;
-    reader->end = buffer + count;
-
-    #if MPACK_READ_TRACKING
-    mpack_reader_flag_if_error(reader, mpack_track_init(&reader->track));
-    #endif
-
-    mpack_log("===========================\n");
-    mpack_log("initializing reader with buffer size %i\n", (int)size);
-}
-
-void mpack_reader_init_error(mpack_reader_t* reader, mpack_error_t error) {
-    mpack_memset(reader, 0, sizeof(*reader));
-    reader->error = error;
-
-    mpack_log("===========================\n");
-    mpack_log("initializing reader error state %i\n", (int)error);
-}
-
-void mpack_reader_init_data(mpack_reader_t* reader, const char* data, size_t count) {
-    mpack_assert(data != NULL, "data is NULL");
-
-    mpack_memset(reader, 0, sizeof(*reader));
-    reader->data = data;
-    reader->end = data + count;
-
-    #if MPACK_READ_TRACKING
-    mpack_reader_flag_if_error(reader, mpack_track_init(&reader->track));
-    #endif
-
-    mpack_log("===========================\n");
-    mpack_log("initializing reader with data size %i\n", (int)count);
-}
-
-void mpack_reader_set_fill(mpack_reader_t* reader, mpack_reader_fill_t fill) {
-    MPACK_STATIC_ASSERT(MPACK_READER_MINIMUM_BUFFER_SIZE >= MPACK_MAXIMUM_TAG_SIZE,
-            "minimum buffer size must fit any tag!");
-
-    if (reader->size == 0) {
-        mpack_break("cannot use fill function without a writeable buffer!");
-        mpack_reader_flag_error(reader, mpack_error_bug);
-        return;
-    }
-
-    if (reader->size < MPACK_READER_MINIMUM_BUFFER_SIZE) {
-        mpack_break("buffer size is %i, but minimum buffer size for fill is %i",
-                (int)reader->size, MPACK_READER_MINIMUM_BUFFER_SIZE);
-        mpack_reader_flag_error(reader, mpack_error_bug);
-        return;
-    }
-
-    reader->fill = fill;
-}
-
-void mpack_reader_set_skip(mpack_reader_t* reader, mpack_reader_skip_t skip) {
-    mpack_assert(reader->size != 0, "cannot use skip function without a writeable buffer!");
-    reader->skip = skip;
-}
-
-#if MPACK_STDIO
-static size_t mpack_file_reader_fill(mpack_reader_t* reader, char* buffer, size_t count) {
-    if (feof((FILE *)reader->context)) {
-       mpack_reader_flag_error(reader, mpack_error_eof);
-       return 0;
-    }
-    return fread((void*)buffer, 1, count, (FILE*)reader->context);
-}
-
-static void mpack_file_reader_skip(mpack_reader_t* reader, size_t count) {
-    if (mpack_reader_error(reader) != mpack_ok)
-        return;
-    FILE* file = (FILE*)reader->context;
-
-    // We call ftell() to test whether the stream is seekable
-    // without causing a file error.
-    if (ftell(file) >= 0) {
-        mpack_log("seeking forward %i bytes\n", (int)count);
-        if (fseek(file, (long int)count, SEEK_CUR) == 0)
-            return;
-        mpack_log("fseek() didn't return zero!\n");
-        if (ferror(file)) {
-            mpack_reader_flag_error(reader, mpack_error_io);
-            return;
-        }
-    }
-
-    // If the stream is not seekable, fall back to the fill function.
-    mpack_reader_skip_using_fill(reader, count);
-}
-
-static void mpack_file_reader_teardown(mpack_reader_t* reader) {
-    MPACK_FREE(reader->buffer);
-    reader->buffer = NULL;
-    reader->context = NULL;
-    reader->size = 0;
-    reader->fill = NULL;
-    reader->skip = NULL;
-    reader->teardown = NULL;
-}
-
-static void mpack_file_reader_teardown_close(mpack_reader_t* reader) {
-    FILE* file = (FILE*)reader->context;
-
-    if (file) {
-        int ret = fclose(file);
-        if (ret != 0)
-            mpack_reader_flag_error(reader, mpack_error_io);
-    }
-
-    mpack_file_reader_teardown(reader);
-}
-
-void mpack_reader_init_stdfile(mpack_reader_t* reader, FILE* file, bool close_when_done) {
-    mpack_assert(file != NULL, "file is NULL");
-
-    size_t capacity = MPACK_BUFFER_SIZE;
-    char* buffer = (char*)MPACK_MALLOC(capacity);
-    if (buffer == NULL) {
-        mpack_reader_init_error(reader, mpack_error_memory);
-        if (close_when_done) {
-            fclose(file);
-        }
-        return;
-    }
-
-    mpack_reader_init(reader, buffer, capacity, 0);
-    mpack_reader_set_context(reader, file);
-    mpack_reader_set_fill(reader, mpack_file_reader_fill);
-    mpack_reader_set_skip(reader, mpack_file_reader_skip);
-    mpack_reader_set_teardown(reader, close_when_done ?
-            mpack_file_reader_teardown_close :
-            mpack_file_reader_teardown);
-}
-
-void mpack_reader_init_filename(mpack_reader_t* reader, const char* filename) {
-    mpack_assert(filename != NULL, "filename is NULL");
-
-    FILE* file = fopen(filename, "rb");
-    if (file == NULL) {
-        mpack_reader_init_error(reader, mpack_error_io);
-        return;
-    }
-
-    mpack_reader_init_stdfile(reader, file, true);
-}
-#endif
-
-mpack_error_t mpack_reader_destroy(mpack_reader_t* reader) {
-
-    // clean up tracking, asserting if we're not already in an error state
-    #if MPACK_READ_TRACKING
-    mpack_reader_flag_if_error(reader, mpack_track_destroy(&reader->track, mpack_reader_error(reader) != mpack_ok));
-    #endif
-
-    if (reader->teardown)
-        reader->teardown(reader);
-    reader->teardown = NULL;
-
-    return reader->error;
-}
-
-size_t mpack_reader_remaining(mpack_reader_t* reader, const char** data) {
-    if (mpack_reader_error(reader) != mpack_ok)
-        return 0;
-
-    #if MPACK_READ_TRACKING
-    if (mpack_reader_flag_if_error(reader, mpack_track_check_empty(&reader->track)) != mpack_ok)
-        return 0;
-    #endif
-
-    if (data)
-        *data = reader->data;
-    return (size_t)(reader->end - reader->data);
-}
-
-void mpack_reader_flag_error(mpack_reader_t* reader, mpack_error_t error) {
-    mpack_log("reader %p setting error %i: %s\n", reader, (int)error, mpack_error_to_string(error));
-
-    if (reader->error == mpack_ok) {
-        reader->error = error;
-        reader->end = reader->data;
-        if (reader->error_fn)
-            reader->error_fn(reader, error);
-    }
-}
-
-// Loops on the fill function, reading between the minimum and
-// maximum number of bytes and flagging an error if it fails.
-MPACK_NOINLINE static size_t mpack_fill_range(mpack_reader_t* reader, char* p, size_t min_bytes, size_t max_bytes) {
-    mpack_assert(reader->fill != NULL, "mpack_fill_range() called with no fill function?");
-    mpack_assert(min_bytes > 0, "cannot fill zero bytes!");
-    mpack_assert(max_bytes >= min_bytes, "min_bytes %i cannot be larger than max_bytes %i!",
-            (int)min_bytes, (int)max_bytes);
-
-    size_t count = 0;
-    while (count < min_bytes) {
-        size_t read = reader->fill(reader, p + count, max_bytes - count);
-
-        // Reader fill functions can flag an error or return 0 on failure. We
-        // also guard against functions that -1 just in case.
-        if (mpack_reader_error(reader) != mpack_ok)
-            return 0;
-        if (read == 0 || read == ((size_t)(-1))) {
-            mpack_reader_flag_error(reader, mpack_error_io);
-            return 0;
-        }
-
-        count += read;
-    }
-    return count;
-}
-
-MPACK_NOINLINE bool mpack_reader_ensure_straddle(mpack_reader_t* reader, size_t count) {
-    mpack_assert(count != 0, "cannot ensure zero bytes!");
-    mpack_assert(reader->error == mpack_ok, "reader cannot be in an error state!");
-
-    mpack_assert(count > (size_t)(reader->end - reader->data),
-            "straddling ensure requested for %i bytes, but there are %i bytes "
-            "left in buffer. call mpack_reader_ensure() instead",
-            (int)count, (int)(reader->end - reader->data));
-
-    // we'll need a fill function to get more data. if there's no
-    // fill function, the buffer should contain an entire MessagePack
-    // object, so we raise mpack_error_invalid instead of mpack_error_io
-    // on truncated data.
-    if (reader->fill == NULL) {
-        mpack_reader_flag_error(reader, mpack_error_invalid);
-        return false;
-    }
-
-    // we need enough space in the buffer. if the buffer is not
-    // big enough, we return mpack_error_too_big (since this is
-    // for an in-place read larger than the buffer size.)
-    if (count > reader->size) {
-        mpack_reader_flag_error(reader, mpack_error_too_big);
-        return false;
-    }
-
-    // move the existing data to the start of the buffer
-    size_t left = (size_t)(reader->end - reader->data);
-    mpack_memmove(reader->buffer, reader->data, left);
-    reader->end -= reader->data - reader->buffer;
-    reader->data = reader->buffer;
-
-    // read at least the necessary number of bytes, accepting up to the
-    // buffer size
-    size_t read = mpack_fill_range(reader, reader->buffer + left,
-            count - left, reader->size - left);
-    if (mpack_reader_error(reader) != mpack_ok)
-        return false;
-    reader->end += read;
-    return true;
-}
-
-// Reads count bytes into p. Used when there are not enough bytes
-// left in the buffer to satisfy a read.
-MPACK_NOINLINE void mpack_read_native_straddle(mpack_reader_t* reader, char* p, size_t count) {
-    mpack_assert(count == 0 || p != NULL, "data pointer for %i bytes is NULL", (int)count);
-
-    if (mpack_reader_error(reader) != mpack_ok) {
-        mpack_memset(p, 0, count);
-        return;
-    }
-
-    size_t left = (size_t)(reader->end - reader->data);
-    mpack_log("big read for %i bytes into %p, %i left in buffer, buffer size %i\n",
-            (int)count, p, (int)left, (int)reader->size);
-
-    if (count <= left) {
-        mpack_assert(0,
-                "big read requested for %i bytes, but there are %i bytes "
-                "left in buffer. call mpack_read_native() instead",
-                (int)count, (int)left);
-        mpack_reader_flag_error(reader, mpack_error_bug);
-        mpack_memset(p, 0, count);
-        return;
-    }
-
-    // we'll need a fill function to get more data. if there's no
-    // fill function, the buffer should contain an entire MessagePack
-    // object, so we raise mpack_error_invalid instead of mpack_error_io
-    // on truncated data.
-    if (reader->fill == NULL) {
-        mpack_reader_flag_error(reader, mpack_error_invalid);
-        mpack_memset(p, 0, count);
-        return;
-    }
-
-    if (reader->size == 0) {
-        // somewhat debatable what error should be returned here. when
-        // initializing a reader with an in-memory buffer it's not
-        // necessarily a bug if the data is blank; it might just have
-        // been truncated to zero. for this reason we return the same
-        // error as if the data was truncated.
-        mpack_reader_flag_error(reader, mpack_error_io);
-        mpack_memset(p, 0, count);
-        return;
-    }
-
-    // flush what's left of the buffer
-    if (left > 0) {
-        mpack_log("flushing %i bytes remaining in buffer\n", (int)left);
-        mpack_memcpy(p, reader->data, left);
-        count -= left;
-        p += left;
-        reader->data += left;
-    }
-
-    // if the remaining data needed is some small fraction of the
-    // buffer size, we'll try to fill the buffer as much as possible
-    // and copy the needed data out.
-    if (count <= reader->size / MPACK_READER_SMALL_FRACTION_DENOMINATOR) {
-        size_t read = mpack_fill_range(reader, reader->buffer, count, reader->size);
-        if (mpack_reader_error(reader) != mpack_ok)
-            return;
-        mpack_memcpy(p, reader->buffer, count);
-        reader->data = reader->buffer + count;
-        reader->end = reader->buffer + read;
-
-    // otherwise we read the remaining data directly into the target.
-    } else {
-        mpack_log("reading %i additional bytes\n", (int)count);
-        mpack_fill_range(reader, p, count, count);
-    }
-}
-
-MPACK_NOINLINE static void mpack_skip_bytes_straddle(mpack_reader_t* reader, size_t count) {
-
-    // we'll need at least a fill function to skip more data. if there's
-    // no fill function, the buffer should contain an entire MessagePack
-    // object, so we raise mpack_error_invalid instead of mpack_error_io
-    // on truncated data. (see mpack_read_native_straddle())
-    if (reader->fill == NULL) {
-        mpack_log("reader has no fill function!\n");
-        mpack_reader_flag_error(reader, mpack_error_invalid);
-        return;
-    }
-
-    // discard whatever's left in the buffer
-    size_t left = (size_t)(reader->end - reader->data);
-    mpack_log("discarding %i bytes still in buffer\n", (int)left);
-    count -= left;
-    reader->data = reader->end;
-
-    // use the skip function if we've got one, and if we're trying
-    // to skip a lot of data. if we only need to skip some tiny
-    // fraction of the buffer size, it's probably better to just
-    // fill the buffer and skip from it instead of trying to seek.
-    if (reader->skip && count > reader->size / 16) {
-        mpack_log("calling skip function for %i bytes\n", (int)count);
-        reader->skip(reader, count);
-        return;
-    }
-
-    mpack_reader_skip_using_fill(reader, count);
-}
-
-void mpack_skip_bytes(mpack_reader_t* reader, size_t count) {
-    if (mpack_reader_error(reader) != mpack_ok)
-        return;
-    mpack_log("skip requested for %i bytes\n", (int)count);
-    mpack_reader_track_bytes(reader, count);
-
-    // check if we have enough in the buffer already
-    size_t left = (size_t)(reader->end - reader->data);
-    if (left >= count) {
-        mpack_log("skipping %i bytes still in buffer\n", (int)count);
-        reader->data += count;
-        return;
-    }
-
-    mpack_skip_bytes_straddle(reader, count);
-}
-
-MPACK_NOINLINE static void mpack_reader_skip_using_fill(mpack_reader_t* reader, size_t count) {
-    mpack_assert(reader->fill != NULL, "missing fill function!");
-    mpack_assert(reader->data == reader->end, "there are bytes left in the buffer!");
-    mpack_assert(reader->error == mpack_ok, "should not have called this in an error state (%i)", reader->error);
-    mpack_log("skip using fill for %i bytes\n", (int)count);
-
-    // fill and discard multiples of the buffer size
-    while (count > reader->size) {
-        mpack_log("filling and discarding buffer of %i bytes\n", (int)reader->size);
-        if (mpack_fill_range(reader, reader->buffer, reader->size, reader->size) < reader->size) {
-            mpack_reader_flag_error(reader, mpack_error_io);
-            return;
-        }
-        count -= reader->size;
-    }
-
-    // fill the buffer as much as possible
-    reader->data = reader->buffer;
-    size_t read = mpack_fill_range(reader, reader->buffer, count, reader->size);
-    if (read < count) {
-        mpack_reader_flag_error(reader, mpack_error_io);
-        return;
-    }
-    reader->end = reader->data + read;
-    mpack_log("filled %i bytes into buffer; discarding %i bytes\n", (int)read, (int)count);
-    reader->data += count;
-}
-
-void mpack_read_bytes(mpack_reader_t* reader, char* p, size_t count) {
-    mpack_assert(p != NULL, "destination for read of %i bytes is NULL", (int)count);
-    mpack_reader_track_bytes(reader, count);
-    mpack_read_native(reader, p, count);
-}
-
-void mpack_read_utf8(mpack_reader_t* reader, char* p, size_t byte_count) {
-    mpack_assert(p != NULL, "destination for read of %i bytes is NULL", (int)byte_count);
-    mpack_reader_track_str_bytes_all(reader, byte_count);
-    mpack_read_native(reader, p, byte_count);
-
-    if (mpack_reader_error(reader) == mpack_ok && !mpack_utf8_check(p, byte_count))
-        mpack_reader_flag_error(reader, mpack_error_type);
-}
-
-static void mpack_read_cstr_unchecked(mpack_reader_t* reader, char* buf, size_t buffer_size, size_t byte_count) {
-    mpack_assert(buf != NULL, "destination for read of %i bytes is NULL", (int)byte_count);
-    mpack_assert(buffer_size >= 1, "buffer size is zero; you must have room for at least a null-terminator");
-
-    if (mpack_reader_error(reader)) {
-        buf[0] = 0;
-        return;
-    }
-
-    if (byte_count > buffer_size - 1) {
-        mpack_reader_flag_error(reader, mpack_error_too_big);
-        buf[0] = 0;
-        return;
-    }
-
-    mpack_reader_track_str_bytes_all(reader, byte_count);
-    mpack_read_native(reader, buf, byte_count);
-    buf[byte_count] = 0;
-}
-
-void mpack_read_cstr(mpack_reader_t* reader, char* buf, size_t buffer_size, size_t byte_count) {
-    mpack_read_cstr_unchecked(reader, buf, buffer_size, byte_count);
-
-    // check for null bytes
-    if (mpack_reader_error(reader) == mpack_ok && !mpack_str_check_no_null(buf, byte_count)) {
-        buf[0] = 0;
-        mpack_reader_flag_error(reader, mpack_error_type);
-    }
-}
-
-void mpack_read_utf8_cstr(mpack_reader_t* reader, char* buf, size_t buffer_size, size_t byte_count) {
-    mpack_read_cstr_unchecked(reader, buf, buffer_size, byte_count);
-
-    // check encoding
-    if (mpack_reader_error(reader) == mpack_ok && !mpack_utf8_check_no_null(buf, byte_count)) {
-        buf[0] = 0;
-        mpack_reader_flag_error(reader, mpack_error_type);
-    }
-}
-
-#ifdef MPACK_MALLOC
-// Reads native bytes with error callback disabled. This allows MPack reader functions
-// to hold an allocated buffer and read native data into it without leaking it in
-// case of a non-local jump (longjmp, throw) out of an error handler.
-static void mpack_read_native_noerrorfn(mpack_reader_t* reader, char* p, size_t count) {
-    mpack_assert(reader->error == mpack_ok, "cannot call if an error is already flagged!");
-    mpack_reader_error_t error_fn = reader->error_fn;
-    reader->error_fn = NULL;
-    mpack_read_native(reader, p, count);
-    reader->error_fn = error_fn;
-}
-
-char* mpack_read_bytes_alloc_impl(mpack_reader_t* reader, size_t count, bool null_terminated) {
-
-    // track the bytes first in case it jumps
-    mpack_reader_track_bytes(reader, count);
-    if (mpack_reader_error(reader) != mpack_ok)
-        return NULL;
-
-    // cannot allocate zero bytes. this is not an error.
-    if (count == 0 && null_terminated == false)
-        return NULL;
-
-    // allocate data
-    char* data = (char*)MPACK_MALLOC(count + (null_terminated ? 1 : 0)); // TODO: can this overflow?
-    if (data == NULL) {
-        mpack_reader_flag_error(reader, mpack_error_memory);
-        return NULL;
-    }
-
-    // read with error callback disabled so we don't leak our buffer
-    mpack_read_native_noerrorfn(reader, data, count);
-
-    // report flagged errors
-    if (mpack_reader_error(reader) != mpack_ok) {
-        MPACK_FREE(data);
-        if (reader->error_fn)
-            reader->error_fn(reader, mpack_reader_error(reader));
-        return NULL;
-    }
-
-    if (null_terminated)
-        data[count] = '\0';
-    return data;
-}
-#endif
-
-// read inplace without tracking (since there are different
-// tracking modes for different inplace readers)
-static const char* mpack_read_bytes_inplace_notrack(mpack_reader_t* reader, size_t count) {
-    if (mpack_reader_error(reader) != mpack_ok)
-        return NULL;
-
-    // if we have enough bytes already in the buffer, we can return it directly.
-    if ((size_t)(reader->end - reader->data) >= count) {
-        const char* bytes = reader->data;
-        reader->data += count;
-        return bytes;
-    }
-
-    if (!mpack_reader_ensure(reader, count))
-        return NULL;
-
-    const char* bytes = reader->data;
-    reader->data += count;
-    return bytes;
-}
-
-const char* mpack_read_bytes_inplace(mpack_reader_t* reader, size_t count) {
-    mpack_reader_track_bytes(reader, count);
-    return mpack_read_bytes_inplace_notrack(reader, count);
-}
-
-const char* mpack_read_utf8_inplace(mpack_reader_t* reader, size_t count) {
-    mpack_reader_track_str_bytes_all(reader, count);
-    const char* str = mpack_read_bytes_inplace_notrack(reader, count);
-
-    if (mpack_reader_error(reader) == mpack_ok && !mpack_utf8_check(str, count)) {
-        mpack_reader_flag_error(reader, mpack_error_type);
-        return NULL;
-    }
-
-    return str;
-}
-
-static size_t mpack_parse_tag(mpack_reader_t* reader, mpack_tag_t* tag) {
-    mpack_assert(reader->error == mpack_ok, "reader cannot be in an error state!");
-
-    if (!mpack_reader_ensure(reader, 1))
-        return 0;
-    uint8_t type = mpack_load_u8(reader->data);
-
-    // unfortunately, by far the fastest way to parse a tag is to switch
-    // on the first byte, and to explicitly list every possible byte. so for
-    // infix types, the list of cases is quite large.
-    //
-    // in size-optimized builds, we switch on the top four bits first to
-    // handle most infix types with a smaller jump table to save space.
-
-    #if MPACK_OPTIMIZE_FOR_SIZE
-    switch (type >> 4) {
-
-        // positive fixnum
-        case 0x0: case 0x1: case 0x2: case 0x3:
-        case 0x4: case 0x5: case 0x6: case 0x7:
-            *tag = mpack_tag_make_uint(type);
-            return 1;
-
-        // negative fixnum
-        case 0xe: case 0xf:
-            *tag = mpack_tag_make_int((int8_t)type);
-            return 1;
-
-        // fixmap
-        case 0x8:
-            *tag = mpack_tag_make_map(type & ~0xf0u);
-            return 1;
-
-        // fixarray
-        case 0x9:
-            *tag = mpack_tag_make_array(type & ~0xf0u);
-            return 1;
-
-        // fixstr
-        case 0xa: case 0xb:
-            *tag = mpack_tag_make_str(type & ~0xe0u);
-            return 1;
-
-        // not one of the common infix types
-        default:
-            break;
-
-    }
-    #endif
-
-    // handle individual type tags
-    switch (type) {
-
-        #if !MPACK_OPTIMIZE_FOR_SIZE
-        // positive fixnum
-        case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07:
-        case 0x08: case 0x09: case 0x0a: case 0x0b: case 0x0c: case 0x0d: case 0x0e: case 0x0f:
-        case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17:
-        case 0x18: case 0x19: case 0x1a: case 0x1b: case 0x1c: case 0x1d: case 0x1e: case 0x1f:
-        case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27:
-        case 0x28: case 0x29: case 0x2a: case 0x2b: case 0x2c: case 0x2d: case 0x2e: case 0x2f:
-        case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37:
-        case 0x38: case 0x39: case 0x3a: case 0x3b: case 0x3c: case 0x3d: case 0x3e: case 0x3f:
-        case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47:
-        case 0x48: case 0x49: case 0x4a: case 0x4b: case 0x4c: case 0x4d: case 0x4e: case 0x4f:
-        case 0x50: case 0x51: case 0x52: case 0x53: case 0x54: case 0x55: case 0x56: case 0x57:
-        case 0x58: case 0x59: case 0x5a: case 0x5b: case 0x5c: case 0x5d: case 0x5e: case 0x5f:
-        case 0x60: case 0x61: case 0x62: case 0x63: case 0x64: case 0x65: case 0x66: case 0x67:
-        case 0x68: case 0x69: case 0x6a: case 0x6b: case 0x6c: case 0x6d: case 0x6e: case 0x6f:
-        case 0x70: case 0x71: case 0x72: case 0x73: case 0x74: case 0x75: case 0x76: case 0x77:
-        case 0x78: case 0x79: case 0x7a: case 0x7b: case 0x7c: case 0x7d: case 0x7e: case 0x7f:
-            *tag = mpack_tag_make_uint(type);
-            return 1;
-
-        // negative fixnum
-        case 0xe0: case 0xe1: case 0xe2: case 0xe3: case 0xe4: case 0xe5: case 0xe6: case 0xe7:
-        case 0xe8: case 0xe9: case 0xea: case 0xeb: case 0xec: case 0xed: case 0xee: case 0xef:
-        case 0xf0: case 0xf1: case 0xf2: case 0xf3: case 0xf4: case 0xf5: case 0xf6: case 0xf7:
-        case 0xf8: case 0xf9: case 0xfa: case 0xfb: case 0xfc: case 0xfd: case 0xfe: case 0xff:
-            *tag = mpack_tag_make_int((int8_t)type);
-            return 1;
-
-        // fixmap
-        case 0x80: case 0x81: case 0x82: case 0x83: case 0x84: case 0x85: case 0x86: case 0x87:
-        case 0x88: case 0x89: case 0x8a: case 0x8b: case 0x8c: case 0x8d: case 0x8e: case 0x8f:
-            *tag = mpack_tag_make_map(type & ~0xf0u);
-            return 1;
-
-        // fixarray
-        case 0x90: case 0x91: case 0x92: case 0x93: case 0x94: case 0x95: case 0x96: case 0x97:
-        case 0x98: case 0x99: case 0x9a: case 0x9b: case 0x9c: case 0x9d: case 0x9e: case 0x9f:
-            *tag = mpack_tag_make_array(type & ~0xf0u);
-            return 1;
-
-        // fixstr
-        case 0xa0: case 0xa1: case 0xa2: case 0xa3: case 0xa4: case 0xa5: case 0xa6: case 0xa7:
-        case 0xa8: case 0xa9: case 0xaa: case 0xab: case 0xac: case 0xad: case 0xae: case 0xaf:
-        case 0xb0: case 0xb1: case 0xb2: case 0xb3: case 0xb4: case 0xb5: case 0xb6: case 0xb7:
-        case 0xb8: case 0xb9: case 0xba: case 0xbb: case 0xbc: case 0xbd: case 0xbe: case 0xbf:
-            *tag = mpack_tag_make_str(type & ~0xe0u);
-            return 1;
-        #endif
-
-        // nil
-        case 0xc0:
-            *tag = mpack_tag_make_nil();
-            return 1;
-
-        // bool
-        case 0xc2: case 0xc3:
-            *tag = mpack_tag_make_bool((bool)(type & 1));
-            return 1;
-
-        // bin8
-        case 0xc4:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_BIN8))
-                return 0;
-            *tag = mpack_tag_make_bin(mpack_load_u8(reader->data + 1));
-            return MPACK_TAG_SIZE_BIN8;
-
-        // bin16
-        case 0xc5:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_BIN16))
-                return 0;
-            *tag = mpack_tag_make_bin(mpack_load_u16(reader->data + 1));
-            return MPACK_TAG_SIZE_BIN16;
-
-        // bin32
-        case 0xc6:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_BIN32))
-                return 0;
-            *tag = mpack_tag_make_bin(mpack_load_u32(reader->data + 1));
-            return MPACK_TAG_SIZE_BIN32;
-
-        #if MPACK_EXTENSIONS
-        // ext8
-        case 0xc7:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_EXT8))
-                return 0;
-            *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 2), mpack_load_u8(reader->data + 1));
-            return MPACK_TAG_SIZE_EXT8;
-
-        // ext16
-        case 0xc8:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_EXT16))
-                return 0;
-            *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 3), mpack_load_u16(reader->data + 1));
-            return MPACK_TAG_SIZE_EXT16;
-
-        // ext32
-        case 0xc9:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_EXT32))
-                return 0;
-            *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 5), mpack_load_u32(reader->data + 1));
-            return MPACK_TAG_SIZE_EXT32;
-        #endif
-
-        // float
-        case 0xca:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_FLOAT))
-                return 0;
-            *tag = mpack_tag_make_float(mpack_load_float(reader->data + 1));
-            return MPACK_TAG_SIZE_FLOAT;
-
-        // double
-        case 0xcb:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_DOUBLE))
-                return 0;
-            *tag = mpack_tag_make_double(mpack_load_double(reader->data + 1));
-            return MPACK_TAG_SIZE_DOUBLE;
-
-        // uint8
-        case 0xcc:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_U8))
-                return 0;
-            *tag = mpack_tag_make_uint(mpack_load_u8(reader->data + 1));
-            return MPACK_TAG_SIZE_U8;
-
-        // uint16
-        case 0xcd:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_U16))
-                return 0;
-            *tag = mpack_tag_make_uint(mpack_load_u16(reader->data + 1));
-            return MPACK_TAG_SIZE_U16;
-
-        // uint32
-        case 0xce:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_U32))
-                return 0;
-            *tag = mpack_tag_make_uint(mpack_load_u32(reader->data + 1));
-            return MPACK_TAG_SIZE_U32;
-
-        // uint64
-        case 0xcf:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_U64))
-                return 0;
-            *tag = mpack_tag_make_uint(mpack_load_u64(reader->data + 1));
-            return MPACK_TAG_SIZE_U64;
-
-        // int8
-        case 0xd0:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_I8))
-                return 0;
-            *tag = mpack_tag_make_int(mpack_load_i8(reader->data + 1));
-            return MPACK_TAG_SIZE_I8;
-
-        // int16
-        case 0xd1:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_I16))
-                return 0;
-            *tag = mpack_tag_make_int(mpack_load_i16(reader->data + 1));
-            return MPACK_TAG_SIZE_I16;
-
-        // int32
-        case 0xd2:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_I32))
-                return 0;
-            *tag = mpack_tag_make_int(mpack_load_i32(reader->data + 1));
-            return MPACK_TAG_SIZE_I32;
-
-        // int64
-        case 0xd3:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_I64))
-                return 0;
-            *tag = mpack_tag_make_int(mpack_load_i64(reader->data + 1));
-            return MPACK_TAG_SIZE_I64;
-
-        #if MPACK_EXTENSIONS
-        // fixext1
-        case 0xd4:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_FIXEXT1))
-                return 0;
-            *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 1), 1);
-            return MPACK_TAG_SIZE_FIXEXT1;
-
-        // fixext2
-        case 0xd5:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_FIXEXT2))
-                return 0;
-            *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 1), 2);
-            return MPACK_TAG_SIZE_FIXEXT2;
-
-        // fixext4
-        case 0xd6:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_FIXEXT4))
-                return 0;
-            *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 1), 4);
-            return 2;
-
-        // fixext8
-        case 0xd7:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_FIXEXT8))
-                return 0;
-            *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 1), 8);
-            return MPACK_TAG_SIZE_FIXEXT8;
-
-        // fixext16
-        case 0xd8:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_FIXEXT16))
-                return 0;
-            *tag = mpack_tag_make_ext(mpack_load_i8(reader->data + 1), 16);
-            return MPACK_TAG_SIZE_FIXEXT16;
-        #endif
-
-        // str8
-        case 0xd9:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_STR8))
-                return 0;
-            *tag = mpack_tag_make_str(mpack_load_u8(reader->data + 1));
-            return MPACK_TAG_SIZE_STR8;
-
-        // str16
-        case 0xda:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_STR16))
-                return 0;
-            *tag = mpack_tag_make_str(mpack_load_u16(reader->data + 1));
-            return MPACK_TAG_SIZE_STR16;
-
-        // str32
-        case 0xdb:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_STR32))
-                return 0;
-            *tag = mpack_tag_make_str(mpack_load_u32(reader->data + 1));
-            return MPACK_TAG_SIZE_STR32;
-
-        // array16
-        case 0xdc:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_ARRAY16))
-                return 0;
-            *tag = mpack_tag_make_array(mpack_load_u16(reader->data + 1));
-            return MPACK_TAG_SIZE_ARRAY16;
-
-        // array32
-        case 0xdd:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_ARRAY32))
-                return 0;
-            *tag = mpack_tag_make_array(mpack_load_u32(reader->data + 1));
-            return MPACK_TAG_SIZE_ARRAY32;
-
-        // map16
-        case 0xde:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_MAP16))
-                return 0;
-            *tag = mpack_tag_make_map(mpack_load_u16(reader->data + 1));
-            return MPACK_TAG_SIZE_MAP16;
-
-        // map32
-        case 0xdf:
-            if (!mpack_reader_ensure(reader, MPACK_TAG_SIZE_MAP32))
-                return 0;
-            *tag = mpack_tag_make_map(mpack_load_u32(reader->data + 1));
-            return MPACK_TAG_SIZE_MAP32;
-
-        // reserved
-        case 0xc1:
-            mpack_reader_flag_error(reader, mpack_error_invalid);
-            return 0;
-
-        #if !MPACK_EXTENSIONS
-        // ext
-        case 0xc7: // fallthrough
-        case 0xc8: // fallthrough
-        case 0xc9: // fallthrough
-        // fixext
-        case 0xd4: // fallthrough
-        case 0xd5: // fallthrough
-        case 0xd6: // fallthrough
-        case 0xd7: // fallthrough
-        case 0xd8:
-            mpack_reader_flag_error(reader, mpack_error_unsupported);
-            return 0;
-        #endif
-
-        #if MPACK_OPTIMIZE_FOR_SIZE
-        // any other bytes should have been handled by the infix switch
-        default:
-            break;
-        #endif
-    }
-
-    mpack_assert(0, "unreachable");
-    return 0;
-}
-
-mpack_tag_t mpack_read_tag(mpack_reader_t* reader) {
-    mpack_log("reading tag\n");
-
-    // make sure we can read a tag
-    if (mpack_reader_error(reader) != mpack_ok)
-        return mpack_tag_nil();
-    if (mpack_reader_track_element(reader) != mpack_ok)
-        return mpack_tag_nil();
-
-    mpack_tag_t tag = MPACK_TAG_ZERO;
-    size_t count = mpack_parse_tag(reader, &tag);
-    if (count == 0)
-        return mpack_tag_nil();
-
-    #if MPACK_READ_TRACKING
-    mpack_error_t track_error = mpack_ok;
-
-    switch (tag.type) {
-        case mpack_type_map:
-        case mpack_type_array:
-            track_error = mpack_track_push(&reader->track, tag.type, tag.v.n);
-            break;
-        #if MPACK_EXTENSIONS
-        case mpack_type_ext:
-        #endif
-        case mpack_type_str:
-        case mpack_type_bin:
-            track_error = mpack_track_push(&reader->track, tag.type, tag.v.l);
-            break;
-        default:
-            break;
-    }
-
-    if (track_error != mpack_ok) {
-        mpack_reader_flag_error(reader, track_error);
-        return mpack_tag_nil();
-    }
-    #endif
-
-    reader->data += count;
-    return tag;
-}
-
-mpack_tag_t mpack_peek_tag(mpack_reader_t* reader) {
-    mpack_log("peeking tag\n");
-
-    // make sure we can peek a tag
-    if (mpack_reader_error(reader) != mpack_ok)
-        return mpack_tag_nil();
-    if (mpack_reader_track_peek_element(reader) != mpack_ok)
-        return mpack_tag_nil();
-
-    mpack_tag_t tag = MPACK_TAG_ZERO;
-    if (mpack_parse_tag(reader, &tag) == 0)
-        return mpack_tag_nil();
-    return tag;
-}
-
-void mpack_discard(mpack_reader_t* reader) {
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (mpack_reader_error(reader))
-        return;
-    switch (var.type) {
-        case mpack_type_str:
-            mpack_skip_bytes(reader, var.v.l);
-            mpack_done_str(reader);
-            break;
-        case mpack_type_bin:
-            mpack_skip_bytes(reader, var.v.l);
-            mpack_done_bin(reader);
-            break;
-        #if MPACK_EXTENSIONS
-        case mpack_type_ext:
-            mpack_skip_bytes(reader, var.v.l);
-            mpack_done_ext(reader);
-            break;
-        #endif
-        case mpack_type_array: {
-            for (; var.v.n > 0; --var.v.n) {
-                mpack_discard(reader);
-                if (mpack_reader_error(reader))
-                    break;
-            }
-            mpack_done_array(reader);
-            break;
-        }
-        case mpack_type_map: {
-            for (; var.v.n > 0; --var.v.n) {
-                mpack_discard(reader);
-                mpack_discard(reader);
-                if (mpack_reader_error(reader))
-                    break;
-            }
-            mpack_done_map(reader);
-            break;
-        }
-        default:
-            break;
-    }
-}
-
-#if MPACK_EXTENSIONS
-mpack_timestamp_t mpack_read_timestamp(mpack_reader_t* reader, size_t size) {
-    mpack_timestamp_t timestamp = {0, 0};
-
-    if (size != 4 && size != 8 && size != 12) {
-        mpack_reader_flag_error(reader, mpack_error_invalid);
-        return timestamp;
-    }
-
-    char buf[12];
-    mpack_read_bytes(reader, buf, size);
-    mpack_done_ext(reader);
-    if (mpack_reader_error(reader) != mpack_ok)
-        return timestamp;
-
-    switch (size) {
-        case 4:
-            timestamp.seconds = (int64_t)(uint64_t)mpack_load_u32(buf);
-            break;
-
-        case 8: {
-            uint64_t packed = mpack_load_u64(buf);
-            timestamp.seconds = (int64_t)(packed & ((UINT64_C(1) << 34) - 1));
-            timestamp.nanoseconds = (uint32_t)(packed >> 34);
-            break;
-        }
-
-        case 12:
-            timestamp.nanoseconds = mpack_load_u32(buf);
-            timestamp.seconds = mpack_load_i64(buf + 4);
-            break;
-
-        default:
-            mpack_assert(false, "unreachable");
-            break;
-    }
-
-    if (timestamp.nanoseconds > MPACK_TIMESTAMP_NANOSECONDS_MAX) {
-        mpack_reader_flag_error(reader, mpack_error_invalid);
-        mpack_timestamp_t zero = {0, 0};
-        return zero;
-    }
-
-    return timestamp;
-}
-#endif
-
-#if MPACK_READ_TRACKING
-void mpack_done_type(mpack_reader_t* reader, mpack_type_t type) {
-    if (mpack_reader_error(reader) == mpack_ok)
-        mpack_reader_flag_if_error(reader, mpack_track_pop(&reader->track, type));
-}
-#endif
-
-#if MPACK_DEBUG && MPACK_STDIO
-static size_t mpack_print_read_prefix(mpack_reader_t* reader, size_t length, char* buffer, size_t buffer_size) {
-    if (length == 0)
-        return 0;
-
-    size_t read = (length < buffer_size) ? length : buffer_size;
-    mpack_read_bytes(reader, buffer, read);
-    if (mpack_reader_error(reader) != mpack_ok)
-        return 0;
-
-    mpack_skip_bytes(reader, length - read);
-    return read;
-}
-
-static void mpack_print_element(mpack_reader_t* reader, mpack_print_t* print, size_t depth) {
-    mpack_tag_t val = mpack_read_tag(reader);
-    if (mpack_reader_error(reader) != mpack_ok)
-        return;
-
-    // We read some bytes from bin and ext so we can print its prefix in hex.
-    char buffer[MPACK_PRINT_BYTE_COUNT];
-    size_t count = 0;
-
-    switch (val.type) {
-        case mpack_type_str:
-            mpack_print_append_cstr(print, "\"");
-            for (size_t i = 0; i < val.v.l; ++i) {
-                char c;
-                mpack_read_bytes(reader, &c, 1);
-                if (mpack_reader_error(reader) != mpack_ok)
-                    return;
-                switch (c) {
-                    case '\n': mpack_print_append_cstr(print, "\\n"); break;
-                    case '\\': mpack_print_append_cstr(print, "\\\\"); break;
-                    case '"': mpack_print_append_cstr(print, "\\\""); break;
-                    default: mpack_print_append(print, &c, 1); break;
-                }
-            }
-            mpack_print_append_cstr(print, "\"");
-            mpack_done_str(reader);
-            return;
-
-        case mpack_type_array:
-            mpack_print_append_cstr(print, "[\n");
-            for (size_t i = 0; i < val.v.n; ++i) {
-                for (size_t j = 0; j < depth + 1; ++j)
-                    mpack_print_append_cstr(print, "    ");
-                mpack_print_element(reader, print, depth + 1);
-                if (mpack_reader_error(reader) != mpack_ok)
-                    return;
-                if (i != val.v.n - 1)
-                    mpack_print_append_cstr(print, ",");
-                mpack_print_append_cstr(print, "\n");
-            }
-            for (size_t i = 0; i < depth; ++i)
-                mpack_print_append_cstr(print, "    ");
-            mpack_print_append_cstr(print, "]");
-            mpack_done_array(reader);
-            return;
-
-        case mpack_type_map:
-            mpack_print_append_cstr(print, "{\n");
-            for (size_t i = 0; i < val.v.n; ++i) {
-                for (size_t j = 0; j < depth + 1; ++j)
-                    mpack_print_append_cstr(print, "    ");
-                mpack_print_element(reader, print, depth + 1);
-                if (mpack_reader_error(reader) != mpack_ok)
-                    return;
-                mpack_print_append_cstr(print, ": ");
-                mpack_print_element(reader, print, depth + 1);
-                if (mpack_reader_error(reader) != mpack_ok)
-                    return;
-                if (i != val.v.n - 1)
-                    mpack_print_append_cstr(print, ",");
-                mpack_print_append_cstr(print, "\n");
-            }
-            for (size_t i = 0; i < depth; ++i)
-                mpack_print_append_cstr(print, "    ");
-            mpack_print_append_cstr(print, "}");
-            mpack_done_map(reader);
-            return;
-
-        // The above cases return so as not to print a pseudo-json value. The
-        // below cases break and print pseudo-json.
-
-        case mpack_type_bin:
-            count = mpack_print_read_prefix(reader, mpack_tag_bin_length(&val), buffer, sizeof(buffer));
-            mpack_done_bin(reader);
-            break;
-
-        #if MPACK_EXTENSIONS
-        case mpack_type_ext:
-            count = mpack_print_read_prefix(reader, mpack_tag_ext_length(&val), buffer, sizeof(buffer));
-            mpack_done_ext(reader);
-            break;
-        #endif
-
-        default:
-            break;
-    }
-
-    char buf[256];
-    mpack_tag_debug_pseudo_json(val, buf, sizeof(buf), buffer, count);
-    mpack_print_append_cstr(print, buf);
-}
-
-static void mpack_print_and_destroy(mpack_reader_t* reader, mpack_print_t* print, size_t depth) {
-    for (size_t i = 0; i < depth; ++i)
-        mpack_print_append_cstr(print, "    ");
-    mpack_print_element(reader, print, depth);
-
-    size_t remaining = mpack_reader_remaining(reader, NULL);
-
-    char buf[256];
-    if (mpack_reader_destroy(reader) != mpack_ok) {
-        mpack_snprintf(buf, sizeof(buf), "\n<mpack parsing error %s>", mpack_error_to_string(mpack_reader_error(reader)));
-        buf[sizeof(buf) - 1] = '\0';
-        mpack_print_append_cstr(print, buf);
-    } else if (remaining > 0) {
-        mpack_snprintf(buf, sizeof(buf), "\n<%i extra bytes at end of message>", (int)remaining);
-        buf[sizeof(buf) - 1] = '\0';
-        mpack_print_append_cstr(print, buf);
-    }
-}
-
-static void mpack_print_data(const char* data, size_t len, mpack_print_t* print, size_t depth) {
-    mpack_reader_t reader;
-    mpack_reader_init_data(&reader, data, len);
-    mpack_print_and_destroy(&reader, print, depth);
-}
-
-void mpack_print_data_to_buffer(const char* data, size_t data_size, char* buffer, size_t buffer_size) {
-    if (buffer_size == 0) {
-        mpack_assert(false, "buffer size is zero!");
-        return;
-    }
-
-    mpack_print_t print;
-    mpack_memset(&print, 0, sizeof(print));
-    print.buffer = buffer;
-    print.size = buffer_size;
-    mpack_print_data(data, data_size, &print, 0);
-    mpack_print_append(&print, "",  1); // null-terminator
-    mpack_print_flush(&print);
-
-    // we always make sure there's a null-terminator at the end of the buffer
-    // in case we ran out of space.
-    print.buffer[print.size - 1] = '\0';
-}
-
-void mpack_print_data_to_callback(const char* data, size_t size, mpack_print_callback_t callback, void* context) {
-    char buffer[1024];
-    mpack_print_t print;
-    mpack_memset(&print, 0, sizeof(print));
-    print.buffer = buffer;
-    print.size = sizeof(buffer);
-    print.callback = callback;
-    print.context = context;
-    mpack_print_data(data, size, &print, 0);
-    mpack_print_flush(&print);
-}
-
-void mpack_print_data_to_file(const char* data, size_t len, FILE* file) {
-    mpack_assert(data != NULL, "data is NULL");
-    mpack_assert(file != NULL, "file is NULL");
-
-    char buffer[1024];
-    mpack_print_t print;
-    mpack_memset(&print, 0, sizeof(print));
-    print.buffer = buffer;
-    print.size = sizeof(buffer);
-    print.callback = &mpack_print_file_callback;
-    print.context = file;
-
-    mpack_print_data(data, len, &print, 2);
-    mpack_print_append_cstr(&print, "\n");
-    mpack_print_flush(&print);
-}
-
-void mpack_print_stdfile_to_callback(FILE* file, mpack_print_callback_t callback, void* context) {
-    char buffer[1024];
-    mpack_print_t print;
-    mpack_memset(&print, 0, sizeof(print));
-    print.buffer = buffer;
-    print.size = sizeof(buffer);
-    print.callback = callback;
-    print.context = context;
-
-    mpack_reader_t reader;
-    mpack_reader_init_stdfile(&reader, file, false);
-    mpack_print_and_destroy(&reader, &print, 0);
-    mpack_print_flush(&print);
-}
-#endif
-
-#endif
-
-/* mpack/mpack-expect.c.c */
-
-#define MPACK_INTERNAL 1
-
-/* #include "mpack-expect.h" */
-
-#if MPACK_EXPECT
-
-
-// Helpers
-
-MPACK_STATIC_INLINE uint8_t mpack_expect_native_u8(mpack_reader_t* reader) {
-    if (mpack_reader_error(reader) != mpack_ok)
-        return 0;
-    uint8_t type;
-    if (!mpack_reader_ensure(reader, sizeof(type)))
-        return 0;
-    type = mpack_load_u8(reader->data);
-    reader->data += sizeof(type);
-    return type;
-}
-
-#if !MPACK_OPTIMIZE_FOR_SIZE
-MPACK_STATIC_INLINE uint16_t mpack_expect_native_u16(mpack_reader_t* reader) {
-    if (mpack_reader_error(reader) != mpack_ok)
-        return 0;
-    uint16_t type;
-    if (!mpack_reader_ensure(reader, sizeof(type)))
-        return 0;
-    type = mpack_load_u16(reader->data);
-    reader->data += sizeof(type);
-    return type;
-}
-
-MPACK_STATIC_INLINE uint32_t mpack_expect_native_u32(mpack_reader_t* reader) {
-    if (mpack_reader_error(reader) != mpack_ok)
-        return 0;
-    uint32_t type;
-    if (!mpack_reader_ensure(reader, sizeof(type)))
-        return 0;
-    type = mpack_load_u32(reader->data);
-    reader->data += sizeof(type);
-    return type;
-}
-#endif
-
-MPACK_STATIC_INLINE uint8_t mpack_expect_type_byte(mpack_reader_t* reader) {
-    mpack_reader_track_element(reader);
-    return mpack_expect_native_u8(reader);
-}
-
-
-// Basic Number Functions
-
-uint8_t mpack_expect_u8(mpack_reader_t* reader) {
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_uint) {
-        if (var.v.u <= UINT8_MAX)
-            return (uint8_t)var.v.u;
-    } else if (var.type == mpack_type_int) {
-        if (var.v.i >= 0 && var.v.i <= UINT8_MAX)
-            return (uint8_t)var.v.i;
-    }
-    mpack_reader_flag_error(reader, mpack_error_type);
-    return 0;
-}
-
-uint16_t mpack_expect_u16(mpack_reader_t* reader) {
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_uint) {
-        if (var.v.u <= UINT16_MAX)
-            return (uint16_t)var.v.u;
-    } else if (var.type == mpack_type_int) {
-        if (var.v.i >= 0 && var.v.i <= UINT16_MAX)
-            return (uint16_t)var.v.i;
-    }
-    mpack_reader_flag_error(reader, mpack_error_type);
-    return 0;
-}
-
-uint32_t mpack_expect_u32(mpack_reader_t* reader) {
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_uint) {
-        if (var.v.u <= UINT32_MAX)
-            return (uint32_t)var.v.u;
-    } else if (var.type == mpack_type_int) {
-        if (var.v.i >= 0 && var.v.i <= UINT32_MAX)
-            return (uint32_t)var.v.i;
-    }
-    mpack_reader_flag_error(reader, mpack_error_type);
-    return 0;
-}
-
-uint64_t mpack_expect_u64(mpack_reader_t* reader) {
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_uint) {
-        return var.v.u;
-    } else if (var.type == mpack_type_int) {
-        if (var.v.i >= 0)
-            return (uint64_t)var.v.i;
-    }
-    mpack_reader_flag_error(reader, mpack_error_type);
-    return 0;
-}
-
-int8_t mpack_expect_i8(mpack_reader_t* reader) {
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_uint) {
-        if (var.v.u <= INT8_MAX)
-            return (int8_t)var.v.u;
-    } else if (var.type == mpack_type_int) {
-        if (var.v.i >= INT8_MIN && var.v.i <= INT8_MAX)
-            return (int8_t)var.v.i;
-    }
-    mpack_reader_flag_error(reader, mpack_error_type);
-    return 0;
-}
-
-int16_t mpack_expect_i16(mpack_reader_t* reader) {
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_uint) {
-        if (var.v.u <= INT16_MAX)
-            return (int16_t)var.v.u;
-    } else if (var.type == mpack_type_int) {
-        if (var.v.i >= INT16_MIN && var.v.i <= INT16_MAX)
-            return (int16_t)var.v.i;
-    }
-    mpack_reader_flag_error(reader, mpack_error_type);
-    return 0;
-}
-
-int32_t mpack_expect_i32(mpack_reader_t* reader) {
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_uint) {
-        if (var.v.u <= INT32_MAX)
-            return (int32_t)var.v.u;
-    } else if (var.type == mpack_type_int) {
-        if (var.v.i >= INT32_MIN && var.v.i <= INT32_MAX)
-            return (int32_t)var.v.i;
-    }
-    mpack_reader_flag_error(reader, mpack_error_type);
-    return 0;
-}
-
-int64_t mpack_expect_i64(mpack_reader_t* reader) {
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_uint) {
-        if (var.v.u <= INT64_MAX)
-            return (int64_t)var.v.u;
-    } else if (var.type == mpack_type_int) {
-        return var.v.i;
-    }
-    mpack_reader_flag_error(reader, mpack_error_type);
-    return 0;
-}
-
-float mpack_expect_float(mpack_reader_t* reader) {
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_uint)
-        return (float)var.v.u;
-    else if (var.type == mpack_type_int)
-        return (float)var.v.i;
-    else if (var.type == mpack_type_float)
-        return var.v.f;
-    else if (var.type == mpack_type_double)
-        return (float)var.v.d;
-    mpack_reader_flag_error(reader, mpack_error_type);
-    return 0.0f;
-}
-
-double mpack_expect_double(mpack_reader_t* reader) {
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_uint)
-        return (double)var.v.u;
-    else if (var.type == mpack_type_int)
-        return (double)var.v.i;
-    else if (var.type == mpack_type_float)
-        return (double)var.v.f;
-    else if (var.type == mpack_type_double)
-        return var.v.d;
-    mpack_reader_flag_error(reader, mpack_error_type);
-    return 0.0;
-}
-
-float mpack_expect_float_strict(mpack_reader_t* reader) {
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_float)
-        return var.v.f;
-    mpack_reader_flag_error(reader, mpack_error_type);
-    return 0.0f;
-}
-
-double mpack_expect_double_strict(mpack_reader_t* reader) {
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_float)
-        return (double)var.v.f;
-    else if (var.type == mpack_type_double)
-        return var.v.d;
-    mpack_reader_flag_error(reader, mpack_error_type);
-    return 0.0;
-}
-
-
-// Ranged Number Functions
-//
-// All ranged functions are identical other than the type, so we
-// define their content with a macro. The prototypes are still written
-// out in full to support ctags/IDE tools.
-
-#define MPACK_EXPECT_RANGE_IMPL(name, type_t)                           \
-                                                                        \
-    /* make sure the range is sensible */                               \
-    mpack_assert(min_value <= max_value,                                \
-            "min_value %i must be less than or equal to max_value %i",  \
-            min_value, max_value);                                      \
-                                                                        \
-    /* read the value */                                                \
-    type_t val = mpack_expect_##name(reader);                           \
-    if (mpack_reader_error(reader) != mpack_ok)                         \
-        return min_value;                                               \
-                                                                        \
-    /* make sure it fits */                                             \
-    if (val < min_value || val > max_value) {                           \
-        mpack_reader_flag_error(reader, mpack_error_type);              \
-        return min_value;                                               \
-    }                                                                   \
-                                                                        \
-    return val;
-
-uint8_t mpack_expect_u8_range(mpack_reader_t* reader, uint8_t min_value, uint8_t max_value) {MPACK_EXPECT_RANGE_IMPL(u8, uint8_t)}
-uint16_t mpack_expect_u16_range(mpack_reader_t* reader, uint16_t min_value, uint16_t max_value) {MPACK_EXPECT_RANGE_IMPL(u16, uint16_t)}
-uint32_t mpack_expect_u32_range(mpack_reader_t* reader, uint32_t min_value, uint32_t max_value) {MPACK_EXPECT_RANGE_IMPL(u32, uint32_t)}
-uint64_t mpack_expect_u64_range(mpack_reader_t* reader, uint64_t min_value, uint64_t max_value) {MPACK_EXPECT_RANGE_IMPL(u64, uint64_t)}
-
-int8_t mpack_expect_i8_range(mpack_reader_t* reader, int8_t min_value, int8_t max_value) {MPACK_EXPECT_RANGE_IMPL(i8, int8_t)}
-int16_t mpack_expect_i16_range(mpack_reader_t* reader, int16_t min_value, int16_t max_value) {MPACK_EXPECT_RANGE_IMPL(i16, int16_t)}
-int32_t mpack_expect_i32_range(mpack_reader_t* reader, int32_t min_value, int32_t max_value) {MPACK_EXPECT_RANGE_IMPL(i32, int32_t)}
-int64_t mpack_expect_i64_range(mpack_reader_t* reader, int64_t min_value, int64_t max_value) {MPACK_EXPECT_RANGE_IMPL(i64, int64_t)}
-
-float mpack_expect_float_range(mpack_reader_t* reader, float min_value, float max_value) {MPACK_EXPECT_RANGE_IMPL(float, float)}
-double mpack_expect_double_range(mpack_reader_t* reader, double min_value, double max_value) {MPACK_EXPECT_RANGE_IMPL(double, double)}
-
-uint32_t mpack_expect_map_range(mpack_reader_t* reader, uint32_t min_value, uint32_t max_value) {MPACK_EXPECT_RANGE_IMPL(map, uint32_t)}
-uint32_t mpack_expect_array_range(mpack_reader_t* reader, uint32_t min_value, uint32_t max_value) {MPACK_EXPECT_RANGE_IMPL(array, uint32_t)}
-
-
-// Matching Number Functions
-
-void mpack_expect_uint_match(mpack_reader_t* reader, uint64_t value) {
-    if (mpack_expect_u64(reader) != value)
-        mpack_reader_flag_error(reader, mpack_error_type);
-}
-
-void mpack_expect_int_match(mpack_reader_t* reader, int64_t value) {
-    if (mpack_expect_i64(reader) != value)
-        mpack_reader_flag_error(reader, mpack_error_type);
-}
-
-
-// Other Basic Types
-
-void mpack_expect_nil(mpack_reader_t* reader) {
-    if (mpack_expect_type_byte(reader) != 0xc0)
-        mpack_reader_flag_error(reader, mpack_error_type);
-}
-
-bool mpack_expect_bool(mpack_reader_t* reader) {
-    uint8_t type = mpack_expect_type_byte(reader);
-    if ((type & ~1) != 0xc2)
-        mpack_reader_flag_error(reader, mpack_error_type);
-    return (bool)(type & 1);
-}
-
-void mpack_expect_true(mpack_reader_t* reader) {
-    if (mpack_expect_bool(reader) != true)
-        mpack_reader_flag_error(reader, mpack_error_type);
-}
-
-void mpack_expect_false(mpack_reader_t* reader) {
-    if (mpack_expect_bool(reader) != false)
-        mpack_reader_flag_error(reader, mpack_error_type);
-}
-
-#if MPACK_EXTENSIONS
-mpack_timestamp_t mpack_expect_timestamp(mpack_reader_t* reader) {
-    mpack_timestamp_t zero = {0, 0};
-
-    mpack_tag_t tag = mpack_read_tag(reader);
-    if (tag.type != mpack_type_ext) {
-        mpack_reader_flag_error(reader, mpack_error_type);
-        return zero;
-    }
-    if (mpack_tag_ext_exttype(&tag) != MPACK_EXTTYPE_TIMESTAMP) {
-        mpack_reader_flag_error(reader, mpack_error_type);
-        return zero;
-    }
-
-    return mpack_read_timestamp(reader, mpack_tag_ext_length(&tag));
-}
-
-int64_t mpack_expect_timestamp_truncate(mpack_reader_t* reader) {
-    return mpack_expect_timestamp(reader).seconds;
-}
-#endif
-
-
-// Compound Types
-
-uint32_t mpack_expect_map(mpack_reader_t* reader) {
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_map)
-        return var.v.n;
-    mpack_reader_flag_error(reader, mpack_error_type);
-    return 0;
-}
-
-void mpack_expect_map_match(mpack_reader_t* reader, uint32_t count) {
-    if (mpack_expect_map(reader) != count)
-        mpack_reader_flag_error(reader, mpack_error_type);
-}
-
-bool mpack_expect_map_or_nil(mpack_reader_t* reader, uint32_t* count) {
-    mpack_assert(count != NULL, "count cannot be NULL");
-
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_nil) {
-        *count = 0;
-        return false;
-    }
-    if (var.type == mpack_type_map) {
-        *count = var.v.n;
-        return true;
-    }
-    mpack_reader_flag_error(reader, mpack_error_type);
-    *count = 0;
-    return false;
-}
-
-bool mpack_expect_map_max_or_nil(mpack_reader_t* reader, uint32_t max_count, uint32_t* count) {
-    mpack_assert(count != NULL, "count cannot be NULL");
-
-    bool has_map = mpack_expect_map_or_nil(reader, count);
-    if (has_map && *count > max_count) {
-        *count = 0;
-        mpack_reader_flag_error(reader, mpack_error_type);
-        return false;
-    }
-    return has_map;
-}
-
-uint32_t mpack_expect_array(mpack_reader_t* reader) {
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_array)
-        return var.v.n;
-    mpack_reader_flag_error(reader, mpack_error_type);
-    return 0;
-}
-
-void mpack_expect_array_match(mpack_reader_t* reader, uint32_t count) {
-    if (mpack_expect_array(reader) != count)
-        mpack_reader_flag_error(reader, mpack_error_type);
-}
-
-bool mpack_expect_array_or_nil(mpack_reader_t* reader, uint32_t* count) {
-    mpack_assert(count != NULL, "count cannot be NULL");
-
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_nil) {
-        *count = 0;
-        return false;
-    }
-    if (var.type == mpack_type_array) {
-        *count = var.v.n;
-        return true;
-    }
-    mpack_reader_flag_error(reader, mpack_error_type);
-    *count = 0;
-    return false;
-}
-
-bool mpack_expect_array_max_or_nil(mpack_reader_t* reader, uint32_t max_count, uint32_t* count) {
-    mpack_assert(count != NULL, "count cannot be NULL");
-
-    bool has_array = mpack_expect_array_or_nil(reader, count);
-    if (has_array && *count > max_count) {
-        *count = 0;
-        mpack_reader_flag_error(reader, mpack_error_type);
-        return false;
-    }
-    return has_array;
-}
-
-#ifdef MPACK_MALLOC
-void* mpack_expect_array_alloc_impl(mpack_reader_t* reader, size_t element_size, uint32_t max_count, uint32_t* out_count, bool allow_nil) {
-    mpack_assert(out_count != NULL, "out_count cannot be NULL");
-    *out_count = 0;
-
-    uint32_t count;
-    bool has_array = true;
-    if (allow_nil)
-        has_array = mpack_expect_array_max_or_nil(reader, max_count, &count);
-    else
-        count = mpack_expect_array_max(reader, max_count);
-    if (mpack_reader_error(reader))
-        return NULL;
-
-    // size 0 is not an error; we return NULL for no elements.
-    if (count == 0) {
-        // we call mpack_done_array() automatically ONLY if we are using
-        // the _or_nil variant. this is the only way to allow nil and empty
-        // to work the same way.
-        if (allow_nil && has_array)
-            mpack_done_array(reader);
-        return NULL;
-    }
-
-    void* p = MPACK_MALLOC(element_size * count);
-    if (p == NULL) {
-        mpack_reader_flag_error(reader, mpack_error_memory);
-        return NULL;
-    }
-
-    *out_count = count;
-    return p;
-}
-#endif
-
-
-// Str, Bin and Ext Functions
-
-uint32_t mpack_expect_str(mpack_reader_t* reader) {
-    #if MPACK_OPTIMIZE_FOR_SIZE
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_str)
-        return var.v.l;
-    mpack_reader_flag_error(reader, mpack_error_type);
-    return 0;
-    #else
-    uint8_t type = mpack_expect_type_byte(reader);
-    uint32_t count;
-
-    if ((type >> 5) == 5) {
-        count = type & (uint8_t)~0xe0;
-    } else if (type == 0xd9) {
-        count = mpack_expect_native_u8(reader);
-    } else if (type == 0xda) {
-        count = mpack_expect_native_u16(reader);
-    } else if (type == 0xdb) {
-        count = mpack_expect_native_u32(reader);
-    } else {
-        mpack_reader_flag_error(reader, mpack_error_type);
-        return 0;
-    }
-
-    #if MPACK_READ_TRACKING
-    mpack_reader_flag_if_error(reader, mpack_track_push(&reader->track, mpack_type_str, count));
-    #endif
-    return count;
-    #endif
-}
-
-size_t mpack_expect_str_buf(mpack_reader_t* reader, char* buf, size_t bufsize) {
-    mpack_assert(buf != NULL, "buf cannot be NULL");
-
-    size_t length = mpack_expect_str(reader);
-    if (mpack_reader_error(reader))
-        return 0;
-
-    if (length > bufsize) {
-        mpack_reader_flag_error(reader, mpack_error_too_big);
-        return 0;
-    }
-
-    mpack_read_bytes(reader, buf, length);
-    if (mpack_reader_error(reader))
-        return 0;
-
-    mpack_done_str(reader);
-    return length;
-}
-
-size_t mpack_expect_utf8(mpack_reader_t* reader, char* buf, size_t size) {
-    mpack_assert(buf != NULL, "buf cannot be NULL");
-
-    size_t length = mpack_expect_str_buf(reader, buf, size);
-
-    if (!mpack_utf8_check(buf, length)) {
-        mpack_reader_flag_error(reader, mpack_error_type);
-        return 0;
-    }
-
-    return length;
-}
-
-uint32_t mpack_expect_bin(mpack_reader_t* reader) {
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_bin)
-        return var.v.l;
-    mpack_reader_flag_error(reader, mpack_error_type);
-    return 0;
-}
-
-size_t mpack_expect_bin_buf(mpack_reader_t* reader, char* buf, size_t bufsize) {
-    mpack_assert(buf != NULL, "buf cannot be NULL");
-
-    size_t binsize = mpack_expect_bin(reader);
-    if (mpack_reader_error(reader))
-        return 0;
-    if (binsize > bufsize) {
-        mpack_reader_flag_error(reader, mpack_error_too_big);
-        return 0;
-    }
-    mpack_read_bytes(reader, buf, binsize);
-    if (mpack_reader_error(reader))
-        return 0;
-    mpack_done_bin(reader);
-    return binsize;
-}
-
-#if MPACK_EXTENSIONS
-uint32_t mpack_expect_ext(mpack_reader_t* reader, int8_t* type) {
-    mpack_tag_t var = mpack_read_tag(reader);
-    if (var.type == mpack_type_ext) {
-        *type = mpack_tag_ext_exttype(&var);
-        return mpack_tag_ext_length(&var);
-    }
-    *type = 0;
-    mpack_reader_flag_error(reader, mpack_error_type);
-    return 0;
-}
-
-size_t mpack_expect_ext_buf(mpack_reader_t* reader, int8_t* type, char* buf, size_t bufsize) {
-    mpack_assert(buf != NULL, "buf cannot be NULL");
-
-    size_t extsize = mpack_expect_ext(reader, type);
-    if (mpack_reader_error(reader))
-        return 0;
-    if (extsize > bufsize) {
-        *type = 0;
-        mpack_reader_flag_error(reader, mpack_error_too_big);
-        return 0;
-    }
-    mpack_read_bytes(reader, buf, extsize);
-    if (mpack_reader_error(reader)) {
-        *type = 0;
-        return 0;
-    }
-    mpack_done_ext(reader);
-    return extsize;
-}
-#endif
-
-void mpack_expect_cstr(mpack_reader_t* reader, char* buf, size_t bufsize) {
-    uint32_t length = mpack_expect_str(reader);
-    mpack_read_cstr(reader, buf, bufsize, length);
-    mpack_done_str(reader);
-}
-
-void mpack_expect_utf8_cstr(mpack_reader_t* reader, char* buf, size_t bufsize) {
-    uint32_t length = mpack_expect_str(reader);
-    mpack_read_utf8_cstr(reader, buf, bufsize, length);
-    mpack_done_str(reader);
-}
-
-#ifdef MPACK_MALLOC
-static char* mpack_expect_cstr_alloc_unchecked(mpack_reader_t* reader, size_t maxsize, size_t* out_length) {
-    mpack_assert(out_length != NULL, "out_length cannot be NULL");
-    *out_length = 0;
-
-    // make sure argument makes sense
-    if (maxsize < 1) {
-        mpack_break("maxsize is zero; you must have room for at least a null-terminator");
-        mpack_reader_flag_error(reader, mpack_error_bug);
-        return NULL;
-    }
-
-    if (maxsize > UINT32_MAX)
-        maxsize = UINT32_MAX;
-
-    size_t length = mpack_expect_str_max(reader, (uint32_t)maxsize - 1);
-    char* str = mpack_read_bytes_alloc_impl(reader, length, true);
-    mpack_done_str(reader);
-
-    if (str)
-        *out_length = length;
-    return str;
-}
-
-char* mpack_expect_cstr_alloc(mpack_reader_t* reader, size_t maxsize) {
-    size_t length;
-    char* str = mpack_expect_cstr_alloc_unchecked(reader, maxsize, &length);
-
-    if (str && !mpack_str_check_no_null(str, length)) {
-        MPACK_FREE(str);
-        mpack_reader_flag_error(reader, mpack_error_type);
-        return NULL;
-    }
-
-    return str;
-}
-
-char* mpack_expect_utf8_cstr_alloc(mpack_reader_t* reader, size_t maxsize) {
-    size_t length;
-    char* str = mpack_expect_cstr_alloc_unchecked(reader, maxsize, &length);
-
-    if (str && !mpack_utf8_check_no_null(str, length)) {
-        MPACK_FREE(str);
-        mpack_reader_flag_error(reader, mpack_error_type);
-        return NULL;
-    }
-
-    return str;
-}
-#endif
-
-void mpack_expect_str_match(mpack_reader_t* reader, const char* str, size_t len) {
-    mpack_assert(str != NULL, "str cannot be NULL");
-
-    // expect a str the correct length
-    if (len > UINT32_MAX)
-        mpack_reader_flag_error(reader, mpack_error_type);
-    mpack_expect_str_length(reader, (uint32_t)len);
-    if (mpack_reader_error(reader))
-        return;
-    mpack_reader_track_bytes(reader, len);
-
-    // check each byte one by one (matched strings are likely to be very small)
-    for (; len > 0; --len) {
-        if (mpack_expect_native_u8(reader) != *str++) {
-            mpack_reader_flag_error(reader, mpack_error_type);
-            return;
-        }
-    }
-
-    mpack_done_str(reader);
-}
-
-void mpack_expect_tag(mpack_reader_t* reader, mpack_tag_t expected) {
-    mpack_tag_t actual = mpack_read_tag(reader);
-    if (!mpack_tag_equal(actual, expected))
-        mpack_reader_flag_error(reader, mpack_error_type);
-}
-
-#ifdef MPACK_MALLOC
-char* mpack_expect_bin_alloc(mpack_reader_t* reader, size_t maxsize, size_t* size) {
-    mpack_assert(size != NULL, "size cannot be NULL");
-    *size = 0;
-
-    if (maxsize > UINT32_MAX)
-        maxsize = UINT32_MAX;
-
-    size_t length = mpack_expect_bin_max(reader, (uint32_t)maxsize);
-    if (mpack_reader_error(reader))
-        return NULL;
-
-    char* data = mpack_read_bytes_alloc(reader, length);
-    mpack_done_bin(reader);
-
-    if (data)
-        *size = length;
-    return data;
-}
-#endif
-
-#if MPACK_EXTENSIONS && defined(MPACK_MALLOC)
-char* mpack_expect_ext_alloc(mpack_reader_t* reader, int8_t* type, size_t maxsize, size_t* size) {
-    mpack_assert(size != NULL, "size cannot be NULL");
-    *size = 0;
-
-    if (maxsize > UINT32_MAX)
-        maxsize = UINT32_MAX;
-
-    size_t length = mpack_expect_ext_max(reader, type, (uint32_t)maxsize);
-    if (mpack_reader_error(reader))
-        return NULL;
-
-    char* data = mpack_read_bytes_alloc(reader, length);
-    mpack_done_ext(reader);
-
-    if (data) {
-        *size = length;
-    } else {
-        *type = 0;
-    }
-    return data;
-}
-#endif
-
-size_t mpack_expect_enum(mpack_reader_t* reader, const char* strings[], size_t count) {
-
-    // read the string in-place
-    size_t keylen = mpack_expect_str(reader);
-    const char* key = mpack_read_bytes_inplace(reader, keylen);
-    mpack_done_str(reader);
-    if (mpack_reader_error(reader) != mpack_ok)
-        return count;
-
-    // find what key it matches
-    for (size_t i = 0; i < count; ++i) {
-        const char* other = strings[i];
-        size_t otherlen = mpack_strlen(other);
-        if (keylen == otherlen && mpack_memcmp(key, other, keylen) == 0)
-            return i;
-    }
-
-    // no matches
-    mpack_reader_flag_error(reader, mpack_error_type);
-    return count;
-}
-
-size_t mpack_expect_enum_optional(mpack_reader_t* reader, const char* strings[], size_t count) {
-    if (mpack_reader_error(reader) != mpack_ok)
-        return count;
-
-    mpack_assert(count != 0, "count cannot be zero; no strings are valid!");
-    mpack_assert(strings != NULL, "strings cannot be NULL");
-
-    // the key is only recognized if it is a string
-    if (mpack_peek_tag(reader).type != mpack_type_str) {
-        mpack_discard(reader);
-        return count;
-    }
-
-    // read the string in-place
-    size_t keylen = mpack_expect_str(reader);
-    const char* key = mpack_read_bytes_inplace(reader, keylen);
-    mpack_done_str(reader);
-    if (mpack_reader_error(reader) != mpack_ok)
-        return count;
-
-    // find what key it matches
-    for (size_t i = 0; i < count; ++i) {
-        const char* other = strings[i];
-        size_t otherlen = mpack_strlen(other);
-        if (keylen == otherlen && mpack_memcmp(key, other, keylen) == 0)
-            return i;
-    }
-
-    // no matches
-    return count;
-}
-
-size_t mpack_expect_key_uint(mpack_reader_t* reader, bool found[], size_t count) {
-    if (mpack_reader_error(reader) != mpack_ok)
-        return count;
-
-    if (count == 0) {
-        mpack_break("count cannot be zero; no keys are valid!");
-        mpack_reader_flag_error(reader, mpack_error_bug);
-        return count;
-    }
-    mpack_assert(found != NULL, "found cannot be NULL");
-
-    // the key is only recognized if it is an unsigned int
-    if (mpack_peek_tag(reader).type != mpack_type_uint) {
-        mpack_discard(reader);
-        return count;
-    }
-
-    // read the key
-    uint64_t value = mpack_expect_u64(reader);
-    if (mpack_reader_error(reader) != mpack_ok)
-        return count;
-
-    // unrecognized keys are fine, we just return count
-    if (value >= count)
-        return count;
-
-    // check if this key is a duplicate
-    if (found[value]) {
-        mpack_reader_flag_error(reader, mpack_error_invalid);
-        return count;
-    }
-
-    found[value] = true;
-    return (size_t)value;
-}
-
-size_t mpack_expect_key_cstr(mpack_reader_t* reader, const char* keys[], bool found[], size_t count) {
-    size_t i = mpack_expect_enum_optional(reader, keys, count);
-
-    // unrecognized keys are fine, we just return count
-    if (i == count)
-        return count;
-
-    // check if this key is a duplicate
-    mpack_assert(found != NULL, "found cannot be NULL");
-    if (found[i]) {
-        mpack_reader_flag_error(reader, mpack_error_invalid);
-        return count;
-    }
-
-    found[i] = true;
-    return i;
-}
-
-#endif
-
-
-/* mpack/mpack-node.c.c */
-
-#define MPACK_INTERNAL 1
-
-/* #include "mpack-node.h" */
-
-#if MPACK_NODE
-
-MPACK_STATIC_INLINE const char* mpack_node_data_unchecked(mpack_node_t node) {
-    mpack_assert(mpack_node_error(node) == mpack_ok, "tree is in an error state!");
-
-    mpack_type_t type = node.data->type;
-    MPACK_UNUSED(type);
-    #if MPACK_EXTENSIONS
-    mpack_assert(type == mpack_type_str || type == mpack_type_bin || type == mpack_type_ext,
-            "node of type %i (%s) is not a data type!", type, mpack_type_to_string(type));
-    #else
-    mpack_assert(type == mpack_type_str || type == mpack_type_bin,
-            "node of type %i (%s) is not a data type!", type, mpack_type_to_string(type));
-    #endif
-
-    return node.tree->data + node.data->value.offset;
-}
-
-#if MPACK_EXTENSIONS
-MPACK_STATIC_INLINE int8_t mpack_node_exttype_unchecked(mpack_node_t node) {
-    mpack_assert(mpack_node_error(node) == mpack_ok, "tree is in an error state!");
-
-    mpack_type_t type = node.data->type;
-    MPACK_UNUSED(type);
-    mpack_assert(type == mpack_type_ext, "node of type %i (%s) is not an ext type!",
-            type, mpack_type_to_string(type));
-
-    // the exttype of an ext node is stored in the byte preceding the data
-    return mpack_load_i8(mpack_node_data_unchecked(node) - 1);
-}
-#endif
-
-
-
-/*
- * Tree Parsing
- */
-
-#ifdef MPACK_MALLOC
-
-// fix up the alloc size to make sure it exactly fits the
-// maximum number of nodes it can contain (the allocator will
-// waste it back anyway, but we round it down just in case)
-
-#define MPACK_NODES_PER_PAGE \
-    ((MPACK_NODE_PAGE_SIZE - sizeof(mpack_tree_page_t)) / sizeof(mpack_node_data_t) + 1)
-
-#define MPACK_PAGE_ALLOC_SIZE \
-    (sizeof(mpack_tree_page_t) + sizeof(mpack_node_data_t) * (MPACK_NODES_PER_PAGE - 1))
-
-#endif
-
-#ifdef MPACK_MALLOC
-/*
- * Fills the tree until we have at least enough bytes for the current node.
- */
-static bool mpack_tree_reserve_fill(mpack_tree_t* tree) {
-    mpack_assert(tree->parser.state == mpack_tree_parse_state_in_progress);
-
-    size_t bytes = tree->parser.current_node_reserved;
-    mpack_assert(bytes > tree->parser.possible_nodes_left,
-            "there are already enough bytes! call mpack_tree_ensure() instead.");
-    mpack_log("filling to reserve %i bytes\n", (int)bytes);
-
-    // if the necessary bytes would put us over the maximum tree
-    // size, fail right away.
-    // TODO: check for overflow?
-    if (tree->data_length + bytes > tree->max_size) {
-        mpack_tree_flag_error(tree, mpack_error_too_big);
-        return false;
-    }
-
-    // we'll need a read function to fetch more data. if there's
-    // no read function, the data should contain an entire message
-    // (or messages), so we flag it as invalid.
-    if (tree->read_fn == NULL) {
-        mpack_log("tree has no read function!\n");
-        mpack_tree_flag_error(tree, mpack_error_invalid);
-        return false;
-    }
-
-    // expand the buffer if needed
-    if (tree->data_length + bytes > tree->buffer_capacity) {
-
-        // TODO: check for overflow?
-        size_t new_capacity = (tree->buffer_capacity == 0) ? MPACK_BUFFER_SIZE : tree->buffer_capacity;
-        while (new_capacity < tree->data_length + bytes)
-            new_capacity *= 2;
-        if (new_capacity > tree->max_size)
-            new_capacity = tree->max_size;
-
-        mpack_log("expanding buffer from %i to %i\n", (int)tree->buffer_capacity, (int)new_capacity);
-
-        char* new_buffer;
-        if (tree->buffer == NULL)
-            new_buffer = (char*)MPACK_MALLOC(new_capacity);
-        else
-            new_buffer = (char*)mpack_realloc(tree->buffer, tree->data_length, new_capacity);
-
-        if (new_buffer == NULL) {
-            mpack_tree_flag_error(tree, mpack_error_memory);
-            return false;
-        }
-
-        tree->data = new_buffer;
-        tree->buffer = new_buffer;
-        tree->buffer_capacity = new_capacity;
-    }
-
-    // request as much data as possible, looping until we have
-    // all the data we need
-    do {
-        size_t read = tree->read_fn(tree, tree->buffer + tree->data_length, tree->buffer_capacity - tree->data_length);
-
-        // If the fill function encounters an error, it should flag an error on
-        // the tree.
-        if (mpack_tree_error(tree) != mpack_ok)
-            return false;
-
-        // We guard against fill functions that return -1 just in case.
-        if (read == (size_t)(-1)) {
-            mpack_tree_flag_error(tree, mpack_error_io);
-            return false;
-        }
-
-        // If the fill function returns 0, the data is not available yet. We
-        // return false to stop parsing the current node.
-        if (read == 0) {
-            mpack_log("not enough data.\n");
-            return false;
-        }
-
-        mpack_log("read %u more bytes\n", (uint32_t)read);
-        tree->data_length += read;
-        tree->parser.possible_nodes_left += read;
-    } while (tree->parser.possible_nodes_left < bytes);
-
-    return true;
-}
-#endif
-
-/*
- * Ensures there are enough additional bytes in the tree for the current node
- * (including reserved bytes for the children of this node, and in addition to
- * the reserved bytes for children of previous compound nodes), reading more
- * data if needed.
- *
- * extra_bytes is the number of additional bytes to reserve for the current
- * node beyond the type byte (since one byte is already reserved for each node
- * by its parent array or map.)
- *
- * This may reallocate the tree, which means the tree->data pointer may change!
- *
- * Returns false if not enough bytes could be read.
- */
-MPACK_STATIC_INLINE bool mpack_tree_reserve_bytes(mpack_tree_t* tree, size_t extra_bytes) {
-    mpack_assert(tree->parser.state == mpack_tree_parse_state_in_progress);
-
-    // We guard against overflow here. A compound type could declare more than
-    // UINT32_MAX contents which overflows SIZE_MAX on 32-bit platforms. We
-    // flag mpack_error_invalid instead of mpack_error_too_big since it's far
-    // more likely that the message is corrupt than that the data is valid but
-    // not parseable on this architecture (see test_read_node_possible() in
-    // test-node.c .)
-    if ((uint64_t)tree->parser.current_node_reserved + (uint64_t)extra_bytes > SIZE_MAX) {
-        mpack_tree_flag_error(tree, mpack_error_invalid);
-        return false;
-    }
-
-    tree->parser.current_node_reserved += extra_bytes;
-
-    // Note that possible_nodes_left already accounts for reserved bytes for
-    // children of previous compound nodes. So even if there are hundreds of
-    // bytes left in the buffer, we might need to read anyway.
-    if (tree->parser.current_node_reserved <= tree->parser.possible_nodes_left)
-        return true;
-
-    #ifdef MPACK_MALLOC
-    return mpack_tree_reserve_fill(tree);
-    #else
-    return false;
-    #endif
-}
-
-MPACK_STATIC_INLINE size_t mpack_tree_parser_stack_capacity(mpack_tree_t* tree) {
-    #ifdef MPACK_MALLOC
-    return tree->parser.stack_capacity;
-    #else
-    return sizeof(tree->parser.stack) / sizeof(tree->parser.stack[0]);
-    #endif
-}
-
-static bool mpack_tree_push_stack(mpack_tree_t* tree, mpack_node_data_t* first_child, size_t total) {
-    mpack_tree_parser_t* parser = &tree->parser;
-    mpack_assert(parser->state == mpack_tree_parse_state_in_progress);
-
-    // No need to push empty containers
-    if (total == 0)
-        return true;
-
-    // Make sure we have enough room in the stack
-    if (parser->level + 1 == mpack_tree_parser_stack_capacity(tree)) {
-        #ifdef MPACK_MALLOC
-        size_t new_capacity = parser->stack_capacity * 2;
-        mpack_log("growing parse stack to capacity %i\n", (int)new_capacity);
-
-        // Replace the stack-allocated parsing stack
-        if (!parser->stack_owned) {
-            mpack_level_t* new_stack = (mpack_level_t*)MPACK_MALLOC(sizeof(mpack_level_t) * new_capacity);
-            if (!new_stack) {
-                mpack_tree_flag_error(tree, mpack_error_memory);
-                return false;
-            }
-            mpack_memcpy(new_stack, parser->stack, sizeof(mpack_level_t) * parser->stack_capacity);
-            parser->stack = new_stack;
-            parser->stack_owned = true;
-
-        // Realloc the allocated parsing stack
-        } else {
-            mpack_level_t* new_stack = (mpack_level_t*)mpack_realloc(parser->stack,
-                    sizeof(mpack_level_t) * parser->stack_capacity, sizeof(mpack_level_t) * new_capacity);
-            if (!new_stack) {
-                mpack_tree_flag_error(tree, mpack_error_memory);
-                return false;
-            }
-            parser->stack = new_stack;
-        }
-        parser->stack_capacity = new_capacity;
-        #else
-        mpack_tree_flag_error(tree, mpack_error_too_big);
-        return false;
-        #endif
-    }
-
-    // Push the contents of this node onto the parsing stack
-    ++parser->level;
-    parser->stack[parser->level].child = first_child;
-    parser->stack[parser->level].left = total;
-    return true;
-}
-
-static bool mpack_tree_parse_children(mpack_tree_t* tree, mpack_node_data_t* node) {
-    mpack_tree_parser_t* parser = &tree->parser;
-    mpack_assert(parser->state == mpack_tree_parse_state_in_progress);
-
-    mpack_type_t type = node->type;
-    size_t total = node->len;
-
-    // Calculate total elements to read
-    if (type == mpack_type_map) {
-        if ((uint64_t)total * 2 > SIZE_MAX) {
-            mpack_tree_flag_error(tree, mpack_error_too_big);
-            return false;
-        }
-        total *= 2;
-    }
-
-    // Make sure we are under our total node limit (TODO can this overflow?)
-    tree->node_count += total;
-    if (tree->node_count > tree->max_nodes) {
-        mpack_tree_flag_error(tree, mpack_error_too_big);
-        return false;
-    }
-
-    // Each node is at least one byte. Count these bytes now to make
-    // sure there is enough data left.
-    if (!mpack_tree_reserve_bytes(tree, total))
-        return false;
-
-    // If there are enough nodes left in the current page, no need to grow
-    if (total <= parser->nodes_left) {
-        node->value.children = parser->nodes;
-        parser->nodes += total;
-        parser->nodes_left -= total;
-
-    } else {
-
-        #ifdef MPACK_MALLOC
-
-        // We can't grow if we're using a fixed pool (i.e. we didn't start with a page)
-        if (!tree->next) {
-            mpack_tree_flag_error(tree, mpack_error_too_big);
-            return false;
-        }
-
-        // Otherwise we need to grow, and the node's children need to be contiguous.
-        // This is a heuristic to decide whether we should waste the remaining space
-        // in the current page and start a new one, or give the children their
-        // own page. With a fraction of 1/8, this causes at most 12% additional
-        // waste. Note that reducing this too much causes less cache coherence and
-        // more malloc() overhead due to smaller allocations, so there's a tradeoff
-        // here. This heuristic could use some improvement, especially with custom
-        // page sizes.
-
-        mpack_tree_page_t* page;
-
-        if (total > MPACK_NODES_PER_PAGE || parser->nodes_left > MPACK_NODES_PER_PAGE / 8) {
-            // TODO: this should check for overflow
-            page = (mpack_tree_page_t*)MPACK_MALLOC(
-                    sizeof(mpack_tree_page_t) + sizeof(mpack_node_data_t) * (total - 1));
-            if (page == NULL) {
-                mpack_tree_flag_error(tree, mpack_error_memory);
-                return false;
-            }
-            mpack_log("allocated seperate page %p for %i children, %i left in page of %i total\n",
-                    page, (int)total, (int)parser->nodes_left, (int)MPACK_NODES_PER_PAGE);
-
-            node->value.children = page->nodes;
-
-        } else {
-            page = (mpack_tree_page_t*)MPACK_MALLOC(MPACK_PAGE_ALLOC_SIZE);
-            if (page == NULL) {
-                mpack_tree_flag_error(tree, mpack_error_memory);
-                return false;
-            }
-            mpack_log("allocated new page %p for %i children, wasting %i in page of %i total\n",
-                    page, (int)total, (int)parser->nodes_left, (int)MPACK_NODES_PER_PAGE);
-
-            node->value.children = page->nodes;
-            parser->nodes = page->nodes + total;
-            parser->nodes_left = MPACK_NODES_PER_PAGE - total;
-        }
-
-        page->next = tree->next;
-        tree->next = page;
-
-        #else
-        // We can't grow if we don't have an allocator
-        mpack_tree_flag_error(tree, mpack_error_too_big);
-        return false;
-        #endif
-    }
-
-    return mpack_tree_push_stack(tree, node->value.children, total);
-}
-
-static bool mpack_tree_parse_bytes(mpack_tree_t* tree, mpack_node_data_t* node) {
-    node->value.offset = tree->size + tree->parser.current_node_reserved + 1;
-    return mpack_tree_reserve_bytes(tree, node->len);
-}
-
-#if MPACK_EXTENSIONS
-static bool mpack_tree_parse_ext(mpack_tree_t* tree, mpack_node_data_t* node) {
-    // reserve space for exttype
-    tree->parser.current_node_reserved += sizeof(int8_t);
-    node->type = mpack_type_ext;
-    return mpack_tree_parse_bytes(tree, node);
-}
-#endif
-
-static bool mpack_tree_parse_node_contents(mpack_tree_t* tree, mpack_node_data_t* node) {
-    mpack_assert(tree->parser.state == mpack_tree_parse_state_in_progress);
-    mpack_assert(node != NULL, "null node?");
-
-    // read the type. we've already accounted for this byte in
-    // possible_nodes_left, so we already know it is in bounds, and we don't
-    // need to reserve it for this node.
-    mpack_assert(tree->data_length > tree->size);
-    uint8_t type = mpack_load_u8(tree->data + tree->size);
-    mpack_log("node type %x\n", type);
-    tree->parser.current_node_reserved = 0;
-
-    // as with mpack_read_tag(), the fastest way to parse a node is to switch
-    // on the first byte, and to explicitly list every possible byte. we switch
-    // on the first four bits in size-optimized builds.
-
-    #if MPACK_OPTIMIZE_FOR_SIZE
-    switch (type >> 4) {
-
-        // positive fixnum
-        case 0x0: case 0x1: case 0x2: case 0x3:
-        case 0x4: case 0x5: case 0x6: case 0x7:
-            node->type = mpack_type_uint;
-            node->value.u = type;
-            return true;
-
-        // negative fixnum
-        case 0xe: case 0xf:
-            node->type = mpack_type_int;
-            node->value.i = (int8_t)type;
-            return true;
-
-        // fixmap
-        case 0x8:
-            node->type = mpack_type_map;
-            node->len = (uint32_t)(type & ~0xf0);
-            return mpack_tree_parse_children(tree, node);
-
-        // fixarray
-        case 0x9:
-            node->type = mpack_type_array;
-            node->len = (uint32_t)(type & ~0xf0);
-            return mpack_tree_parse_children(tree, node);
-
-        // fixstr
-        case 0xa: case 0xb:
-            node->type = mpack_type_str;
-            node->len = (uint32_t)(type & ~0xe0);
-            return mpack_tree_parse_bytes(tree, node);
-
-        // not one of the common infix types
-        default:
-            break;
-    }
-    #endif
-
-    switch (type) {
-
-        #if !MPACK_OPTIMIZE_FOR_SIZE
-        // positive fixnum
-        case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07:
-        case 0x08: case 0x09: case 0x0a: case 0x0b: case 0x0c: case 0x0d: case 0x0e: case 0x0f:
-        case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17:
-        case 0x18: case 0x19: case 0x1a: case 0x1b: case 0x1c: case 0x1d: case 0x1e: case 0x1f:
-        case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27:
-        case 0x28: case 0x29: case 0x2a: case 0x2b: case 0x2c: case 0x2d: case 0x2e: case 0x2f:
-        case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37:
-        case 0x38: case 0x39: case 0x3a: case 0x3b: case 0x3c: case 0x3d: case 0x3e: case 0x3f:
-        case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47:
-        case 0x48: case 0x49: case 0x4a: case 0x4b: case 0x4c: case 0x4d: case 0x4e: case 0x4f:
-        case 0x50: case 0x51: case 0x52: case 0x53: case 0x54: case 0x55: case 0x56: case 0x57:
-        case 0x58: case 0x59: case 0x5a: case 0x5b: case 0x5c: case 0x5d: case 0x5e: case 0x5f:
-        case 0x60: case 0x61: case 0x62: case 0x63: case 0x64: case 0x65: case 0x66: case 0x67:
-        case 0x68: case 0x69: case 0x6a: case 0x6b: case 0x6c: case 0x6d: case 0x6e: case 0x6f:
-        case 0x70: case 0x71: case 0x72: case 0x73: case 0x74: case 0x75: case 0x76: case 0x77:
-        case 0x78: case 0x79: case 0x7a: case 0x7b: case 0x7c: case 0x7d: case 0x7e: case 0x7f:
-            node->type = mpack_type_uint;
-            node->value.u = type;
-            return true;
-
-        // negative fixnum
-        case 0xe0: case 0xe1: case 0xe2: case 0xe3: case 0xe4: case 0xe5: case 0xe6: case 0xe7:
-        case 0xe8: case 0xe9: case 0xea: case 0xeb: case 0xec: case 0xed: case 0xee: case 0xef:
-        case 0xf0: case 0xf1: case 0xf2: case 0xf3: case 0xf4: case 0xf5: case 0xf6: case 0xf7:
-        case 0xf8: case 0xf9: case 0xfa: case 0xfb: case 0xfc: case 0xfd: case 0xfe: case 0xff:
-            node->type = mpack_type_int;
-            node->value.i = (int8_t)type;
-            return true;
-
-        // fixmap
-        case 0x80: case 0x81: case 0x82: case 0x83: case 0x84: case 0x85: case 0x86: case 0x87:
-        case 0x88: case 0x89: case 0x8a: case 0x8b: case 0x8c: case 0x8d: case 0x8e: case 0x8f:
-            node->type = mpack_type_map;
-            node->len = (uint32_t)(type & ~0xf0);
-            return mpack_tree_parse_children(tree, node);
-
-        // fixarray
-        case 0x90: case 0x91: case 0x92: case 0x93: case 0x94: case 0x95: case 0x96: case 0x97:
-        case 0x98: case 0x99: case 0x9a: case 0x9b: case 0x9c: case 0x9d: case 0x9e: case 0x9f:
-            node->type = mpack_type_array;
-            node->len = (uint32_t)(type & ~0xf0);
-            return mpack_tree_parse_children(tree, node);
-
-        // fixstr
-        case 0xa0: case 0xa1: case 0xa2: case 0xa3: case 0xa4: case 0xa5: case 0xa6: case 0xa7:
-        case 0xa8: case 0xa9: case 0xaa: case 0xab: case 0xac: case 0xad: case 0xae: case 0xaf:
-        case 0xb0: case 0xb1: case 0xb2: case 0xb3: case 0xb4: case 0xb5: case 0xb6: case 0xb7:
-        case 0xb8: case 0xb9: case 0xba: case 0xbb: case 0xbc: case 0xbd: case 0xbe: case 0xbf:
-            node->type = mpack_type_str;
-            node->len = (uint32_t)(type & ~0xe0);
-            return mpack_tree_parse_bytes(tree, node);
-        #endif
-
-        // nil
-        case 0xc0:
-            node->type = mpack_type_nil;
-            return true;
-
-        // bool
-        case 0xc2: case 0xc3:
-            node->type = mpack_type_bool;
-            node->value.b = type & 1;
-            return true;
-
-        // bin8
-        case 0xc4:
-            node->type = mpack_type_bin;
-            if (!mpack_tree_reserve_bytes(tree, sizeof(uint8_t)))
-                return false;
-            node->len = mpack_load_u8(tree->data + tree->size + 1);
-            return mpack_tree_parse_bytes(tree, node);
-
-        // bin16
-        case 0xc5:
-            node->type = mpack_type_bin;
-            if (!mpack_tree_reserve_bytes(tree, sizeof(uint16_t)))
-                return false;
-            node->len = mpack_load_u16(tree->data + tree->size + 1);
-            return mpack_tree_parse_bytes(tree, node);
-
-        // bin32
-        case 0xc6:
-            node->type = mpack_type_bin;
-            if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t)))
-                return false;
-            node->len = mpack_load_u32(tree->data + tree->size + 1);
-            return mpack_tree_parse_bytes(tree, node);
-
-        #if MPACK_EXTENSIONS
-        // ext8
-        case 0xc7:
-            if (!mpack_tree_reserve_bytes(tree, sizeof(uint8_t)))
-                return false;
-            node->len = mpack_load_u8(tree->data + tree->size + 1);
-            return mpack_tree_parse_ext(tree, node);
-
-        // ext16
-        case 0xc8:
-            if (!mpack_tree_reserve_bytes(tree, sizeof(uint16_t)))
-                return false;
-            node->len = mpack_load_u16(tree->data + tree->size + 1);
-            return mpack_tree_parse_ext(tree, node);
-
-        // ext32
-        case 0xc9:
-            if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t)))
-                return false;
-            node->len = mpack_load_u32(tree->data + tree->size + 1);
-            return mpack_tree_parse_ext(tree, node);
-        #endif
-
-        // float
-        case 0xca:
-            if (!mpack_tree_reserve_bytes(tree, sizeof(float)))
-                return false;
-            node->value.f = mpack_load_float(tree->data + tree->size + 1);
-            node->type = mpack_type_float;
-            return true;
-
-        // double
-        case 0xcb:
-            if (!mpack_tree_reserve_bytes(tree, sizeof(double)))
-                return false;
-            node->value.d = mpack_load_double(tree->data + tree->size + 1);
-            node->type = mpack_type_double;
-            return true;
-
-        // uint8
-        case 0xcc:
-            node->type = mpack_type_uint;
-            if (!mpack_tree_reserve_bytes(tree, sizeof(uint8_t)))
-                return false;
-            node->value.u = mpack_load_u8(tree->data + tree->size + 1);
-            return true;
-
-        // uint16
-        case 0xcd:
-            node->type = mpack_type_uint;
-            if (!mpack_tree_reserve_bytes(tree, sizeof(uint16_t)))
-                return false;
-            node->value.u = mpack_load_u16(tree->data + tree->size + 1);
-            return true;
-
-        // uint32
-        case 0xce:
-            node->type = mpack_type_uint;
-            if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t)))
-                return false;
-            node->value.u = mpack_load_u32(tree->data + tree->size + 1);
-            return true;
-
-        // uint64
-        case 0xcf:
-            node->type = mpack_type_uint;
-            if (!mpack_tree_reserve_bytes(tree, sizeof(uint64_t)))
-                return false;
-            node->value.u = mpack_load_u64(tree->data + tree->size + 1);
-            return true;
-
-        // int8
-        case 0xd0:
-            node->type = mpack_type_int;
-            if (!mpack_tree_reserve_bytes(tree, sizeof(int8_t)))
-                return false;
-            node->value.i = mpack_load_i8(tree->data + tree->size + 1);
-            return true;
-
-        // int16
-        case 0xd1:
-            node->type = mpack_type_int;
-            if (!mpack_tree_reserve_bytes(tree, sizeof(int16_t)))
-                return false;
-            node->value.i = mpack_load_i16(tree->data + tree->size + 1);
-            return true;
-
-        // int32
-        case 0xd2:
-            node->type = mpack_type_int;
-            if (!mpack_tree_reserve_bytes(tree, sizeof(int32_t)))
-                return false;
-            node->value.i = mpack_load_i32(tree->data + tree->size + 1);
-            return true;
-
-        // int64
-        case 0xd3:
-            node->type = mpack_type_int;
-            if (!mpack_tree_reserve_bytes(tree, sizeof(int64_t)))
-                return false;
-            node->value.i = mpack_load_i64(tree->data + tree->size + 1);
-            return true;
-
-        #if MPACK_EXTENSIONS
-        // fixext1
-        case 0xd4:
-            node->len = 1;
-            return mpack_tree_parse_ext(tree, node);
-
-        // fixext2
-        case 0xd5:
-            node->len = 2;
-            return mpack_tree_parse_ext(tree, node);
-
-        // fixext4
-        case 0xd6:
-            node->len = 4;
-            return mpack_tree_parse_ext(tree, node);
-
-        // fixext8
-        case 0xd7:
-            node->len = 8;
-            return mpack_tree_parse_ext(tree, node);
-
-        // fixext16
-        case 0xd8:
-            node->len = 16;
-            return mpack_tree_parse_ext(tree, node);
-        #endif
-
-        // str8
-        case 0xd9:
-            if (!mpack_tree_reserve_bytes(tree, sizeof(uint8_t)))
-                return false;
-            node->len = mpack_load_u8(tree->data + tree->size + 1);
-            node->type = mpack_type_str;
-            return mpack_tree_parse_bytes(tree, node);
-
-        // str16
-        case 0xda:
-            if (!mpack_tree_reserve_bytes(tree, sizeof(uint16_t)))
-                return false;
-            node->len = mpack_load_u16(tree->data + tree->size + 1);
-            node->type = mpack_type_str;
-            return mpack_tree_parse_bytes(tree, node);
-
-        // str32
-        case 0xdb:
-            if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t)))
-                return false;
-            node->len = mpack_load_u32(tree->data + tree->size + 1);
-            node->type = mpack_type_str;
-            return mpack_tree_parse_bytes(tree, node);
-
-        // array16
-        case 0xdc:
-            if (!mpack_tree_reserve_bytes(tree, sizeof(uint16_t)))
-                return false;
-            node->len = mpack_load_u16(tree->data + tree->size + 1);
-            node->type = mpack_type_array;
-            return mpack_tree_parse_children(tree, node);
-
-        // array32
-        case 0xdd:
-            if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t)))
-                return false;
-            node->len = mpack_load_u32(tree->data + tree->size + 1);
-            node->type = mpack_type_array;
-            return mpack_tree_parse_children(tree, node);
-
-        // map16
-        case 0xde:
-            if (!mpack_tree_reserve_bytes(tree, sizeof(uint16_t)))
-                return false;
-            node->len = mpack_load_u16(tree->data + tree->size + 1);
-            node->type = mpack_type_map;
-            return mpack_tree_parse_children(tree, node);
-
-        // map32
-        case 0xdf:
-            if (!mpack_tree_reserve_bytes(tree, sizeof(uint32_t)))
-                return false;
-            node->len = mpack_load_u32(tree->data + tree->size + 1);
-            node->type = mpack_type_map;
-            return mpack_tree_parse_children(tree, node);
-
-        // reserved
-        case 0xc1:
-            mpack_tree_flag_error(tree, mpack_error_invalid);
-            return false;
-
-        #if !MPACK_EXTENSIONS
-        // ext
-        case 0xc7: // fallthrough
-        case 0xc8: // fallthrough
-        case 0xc9: // fallthrough
-        // fixext
-        case 0xd4: // fallthrough
-        case 0xd5: // fallthrough
-        case 0xd6: // fallthrough
-        case 0xd7: // fallthrough
-        case 0xd8:
-            mpack_tree_flag_error(tree, mpack_error_unsupported);
-            return false;
-        #endif
-
-        #if MPACK_OPTIMIZE_FOR_SIZE
-        // any other bytes should have been handled by the infix switch
-        default:
-            break;
-        #endif
-    }
-
-    mpack_assert(0, "unreachable");
-    return false;
-}
-
-static bool mpack_tree_parse_node(mpack_tree_t* tree, mpack_node_data_t* node) {
-    mpack_log("parsing a node at position %i in level %i\n",
-            (int)tree->size, (int)tree->parser.level);
-
-    if (!mpack_tree_parse_node_contents(tree, node)) {
-        mpack_log("node parsing returned false\n");
-        return false;
-    }
-
-    tree->parser.possible_nodes_left -= tree->parser.current_node_reserved;
-
-    // The reserve for the current node does not include the initial byte
-    // previously reserved as part of its parent.
-    size_t node_size = tree->parser.current_node_reserved + 1;
-
-    // If the parsed type is a map or array, the reserve includes one byte for
-    // each child. We want to subtract these out of possible_nodes_left, but
-    // not out of the current size of the tree.
-    if (node->type == mpack_type_array)
-        node_size -= node->len;
-    else if (node->type == mpack_type_map)
-        node_size -= node->len * 2;
-    tree->size += node_size;
-
-    mpack_log("parsed a node of type %s of %i bytes and "
-            "%i additional bytes reserved for children.\n",
-            mpack_type_to_string(node->type), (int)node_size,
-            (int)tree->parser.current_node_reserved + 1 - (int)node_size);
-
-    return true;
-}
-
-/*
- * We read nodes in a loop instead of recursively for maximum performance. The
- * stack holds the amount of children left to read in each level of the tree.
- * Parsing can pause and resume when more data becomes available.
- */
-static bool mpack_tree_continue_parsing(mpack_tree_t* tree) {
-    if (mpack_tree_error(tree) != mpack_ok)
-        return false;
-
-    mpack_tree_parser_t* parser = &tree->parser;
-    mpack_assert(parser->state == mpack_tree_parse_state_in_progress);
-    mpack_log("parsing tree elements, %i bytes in buffer\n", (int)tree->data_length);
-
-    // we loop parsing nodes until the parse stack is empty. we break
-    // by returning out of the function.
-    while (true) {
-        mpack_node_data_t* node = parser->stack[parser->level].child;
-        size_t level = parser->level;
-        if (!mpack_tree_parse_node(tree, node))
-            return false;
-        --parser->stack[level].left;
-        ++parser->stack[level].child;
-
-        mpack_assert(mpack_tree_error(tree) == mpack_ok,
-                "mpack_tree_parse_node() should have returned false due to error!");
-
-        // pop empty stack levels, exiting the outer loop when the stack is empty.
-        // (we could tail-optimize containers by pre-emptively popping empty
-        // stack levels before reading the new element, this way we wouldn't
-        // have to loop. but we eventually want to use the parse stack to give
-        // better error messages that contain the location of the error, so
-        // it needs to be complete.)
-        while (parser->stack[parser->level].left == 0) {
-            if (parser->level == 0)
-                return true;
-            --parser->level;
-        }
-    }
-}
-
-static void mpack_tree_cleanup(mpack_tree_t* tree) {
-    MPACK_UNUSED(tree);
-
-    #ifdef MPACK_MALLOC
-    if (tree->parser.stack_owned) {
-        MPACK_FREE(tree->parser.stack);
-        tree->parser.stack = NULL;
-        tree->parser.stack_owned = false;
-    }
-
-    mpack_tree_page_t* page = tree->next;
-    while (page != NULL) {
-        mpack_tree_page_t* next = page->next;
-        mpack_log("freeing page %p\n", page);
-        MPACK_FREE(page);
-        page = next;
-    }
-    tree->next = NULL;
-    #endif
-}
-
-static bool mpack_tree_parse_start(mpack_tree_t* tree) {
-    if (mpack_tree_error(tree) != mpack_ok)
-        return false;
-
-    mpack_tree_parser_t* parser = &tree->parser;
-    mpack_assert(parser->state != mpack_tree_parse_state_in_progress,
-            "previous parsing was not finished!");
-
-    if (parser->state == mpack_tree_parse_state_parsed)
-        mpack_tree_cleanup(tree);
-
-    mpack_log("starting parse\n");
-    tree->parser.state = mpack_tree_parse_state_in_progress;
-    tree->parser.current_node_reserved = 0;
-
-    // check if we previously parsed a tree
-    if (tree->size > 0) {
-        #ifdef MPACK_MALLOC
-        // if we're buffered, move the remaining data back to the
-        // start of the buffer
-        // TODO: This is not ideal performance-wise. We should only move data
-        // when we need to call the fill function.
-        // TODO: We could consider shrinking the buffer here, especially if we
-        // determine that the fill function is providing less than a quarter of
-        // the buffer size or if messages take up less than a quarter of the
-        // buffer size. Maybe this should be configurable.
-        if (tree->buffer != NULL) {
-            mpack_memmove(tree->buffer, tree->buffer + tree->size, tree->data_length - tree->size);
-        }
-        else
-        #endif
-        // otherwise advance past the parsed data
-        {
-            tree->data += tree->size;
-        }
-        tree->data_length -= tree->size;
-        tree->size = 0;
-        tree->node_count = 0;
-    }
-
-    // make sure we have at least one byte available before allocating anything
-    parser->possible_nodes_left = tree->data_length;
-    if (!mpack_tree_reserve_bytes(tree, sizeof(uint8_t))) {
-        tree->parser.state = mpack_tree_parse_state_not_started;
-        return false;
-    }
-    mpack_log("parsing tree at %p starting with byte %x\n", tree->data, (uint8_t)tree->data[0]);
-    parser->possible_nodes_left -= 1;
-    tree->node_count = 1;
-
-    #ifdef MPACK_MALLOC
-    parser->stack = parser->stack_local;
-    parser->stack_owned = false;
-    parser->stack_capacity = sizeof(parser->stack_local) / sizeof(*parser->stack_local);
-
-    if (tree->pool == NULL) {
-
-        // allocate first page
-        mpack_tree_page_t* page = (mpack_tree_page_t*)MPACK_MALLOC(MPACK_PAGE_ALLOC_SIZE);
-        mpack_log("allocated initial page %p of size %i count %i\n",
-                page, (int)MPACK_PAGE_ALLOC_SIZE, (int)MPACK_NODES_PER_PAGE);
-        if (page == NULL) {
-            tree->error = mpack_error_memory;
-            return false;
-        }
-        page->next = NULL;
-        tree->next = page;
-
-        parser->nodes = page->nodes;
-        parser->nodes_left = MPACK_NODES_PER_PAGE;
-    }
-    else
-    #endif
-    {
-        // otherwise use the provided pool
-        mpack_assert(tree->pool != NULL, "no pool provided?");
-        parser->nodes = tree->pool;
-        parser->nodes_left = tree->pool_count;
-    }
-
-    tree->root = parser->nodes;
-    ++parser->nodes;
-    --parser->nodes_left;
-
-    parser->level = 0;
-    parser->stack[0].child = tree->root;
-    parser->stack[0].left = 1;
-
-    return true;
-}
-
-void mpack_tree_parse(mpack_tree_t* tree) {
-    if (mpack_tree_error(tree) != mpack_ok)
-        return;
-
-    if (tree->parser.state != mpack_tree_parse_state_in_progress) {
-        if (!mpack_tree_parse_start(tree)) {
-            mpack_tree_flag_error(tree, (tree->read_fn == NULL) ?
-                    mpack_error_invalid : mpack_error_io);
-            return;
-        }
-    }
-
-    if (!mpack_tree_continue_parsing(tree)) {
-        if (mpack_tree_error(tree) != mpack_ok)
-            return;
-
-        // We're parsing synchronously on a blocking fill function. If we
-        // didn't completely finish parsing the tree, it's an error.
-        mpack_log("tree parsing incomplete. flagging error.\n");
-        mpack_tree_flag_error(tree, (tree->read_fn == NULL) ?
-                mpack_error_invalid : mpack_error_io);
-        return;
-    }
-
-    mpack_assert(mpack_tree_error(tree) == mpack_ok);
-    mpack_assert(tree->parser.level == 0);
-    tree->parser.state = mpack_tree_parse_state_parsed;
-    mpack_log("parsed tree of %i bytes, %i bytes left\n", (int)tree->size, (int)tree->parser.possible_nodes_left);
-    mpack_log("%i nodes in final page\n", (int)tree->parser.nodes_left);
-}
-
-bool mpack_tree_try_parse(mpack_tree_t* tree) {
-    if (mpack_tree_error(tree) != mpack_ok)
-        return false;
-
-    if (tree->parser.state != mpack_tree_parse_state_in_progress)
-        if (!mpack_tree_parse_start(tree))
-            return false;
-
-    if (!mpack_tree_continue_parsing(tree))
-        return false;
-
-    mpack_assert(mpack_tree_error(tree) == mpack_ok);
-    mpack_assert(tree->parser.level == 0);
-    tree->parser.state = mpack_tree_parse_state_parsed;
-    return true;
-}
-
-
-
-/*
- * Tree functions
- */
-
-mpack_node_t mpack_tree_root(mpack_tree_t* tree) {
-    if (mpack_tree_error(tree) != mpack_ok)
-        return mpack_tree_nil_node(tree);
-
-    // We check that a tree was parsed successfully and assert if not. You must
-    // call mpack_tree_parse() (or mpack_tree_try_parse() with a success
-    // result) in order to access the root node.
-    if (tree->parser.state != mpack_tree_parse_state_parsed) {
-        mpack_break("Tree has not been parsed! "
-                "Did you call mpack_tree_parse() or mpack_tree_try_parse()?");
-        mpack_tree_flag_error(tree, mpack_error_bug);
-        return mpack_tree_nil_node(tree);
-    }
-
-    return mpack_node(tree, tree->root);
-}
-
-static void mpack_tree_init_clear(mpack_tree_t* tree) {
-    mpack_memset(tree, 0, sizeof(*tree));
-    tree->nil_node.type = mpack_type_nil;
-    tree->missing_node.type = mpack_type_missing;
-    tree->max_size = SIZE_MAX;
-    tree->max_nodes = SIZE_MAX;
-}
-
-#ifdef MPACK_MALLOC
-void mpack_tree_init_data(mpack_tree_t* tree, const char* data, size_t length) {
-    mpack_tree_init_clear(tree);
-
-    MPACK_STATIC_ASSERT(MPACK_NODE_PAGE_SIZE >= sizeof(mpack_tree_page_t),
-            "MPACK_NODE_PAGE_SIZE is too small");
-
-    MPACK_STATIC_ASSERT(MPACK_PAGE_ALLOC_SIZE <= MPACK_NODE_PAGE_SIZE,
-            "incorrect page rounding?");
-
-    tree->data = data;
-    tree->data_length = length;
-    tree->pool = NULL;
-    tree->pool_count = 0;
-    tree->next = NULL;
-
-    mpack_log("===========================\n");
-    mpack_log("initializing tree with data of size %i\n", (int)length);
-}
-#endif
-
-void mpack_tree_init_pool(mpack_tree_t* tree, const char* data, size_t length,
-        mpack_node_data_t* node_pool, size_t node_pool_count)
-{
-    mpack_tree_init_clear(tree);
-    #ifdef MPACK_MALLOC
-    tree->next = NULL;
-    #endif
-
-    if (node_pool_count == 0) {
-        mpack_break("initial page has no nodes!");
-        mpack_tree_flag_error(tree, mpack_error_bug);
-        return;
-    }
-
-    tree->data = data;
-    tree->data_length = length;
-    tree->pool = node_pool;
-    tree->pool_count = node_pool_count;
-
-    mpack_log("===========================\n");
-    mpack_log("initializing tree with data of size %i and pool of count %i\n",
-            (int)length, (int)node_pool_count);
-}
-
-void mpack_tree_init_error(mpack_tree_t* tree, mpack_error_t error) {
-    mpack_tree_init_clear(tree);
-    tree->error = error;
-
-    mpack_log("===========================\n");
-    mpack_log("initializing tree error state %i\n", (int)error);
-}
-
-#ifdef MPACK_MALLOC
-void mpack_tree_init_stream(mpack_tree_t* tree, mpack_tree_read_t read_fn, void* context,
-        size_t max_message_size, size_t max_message_nodes) {
-    mpack_tree_init_clear(tree);
-
-    tree->read_fn = read_fn;
-    tree->context = context;
-
-    mpack_tree_set_limits(tree, max_message_size, max_message_nodes);
-    tree->max_size = max_message_size;
-    tree->max_nodes = max_message_nodes;
-
-    mpack_log("===========================\n");
-    mpack_log("initializing tree with stream, max size %i max nodes %i\n",
-            (int)max_message_size, (int)max_message_nodes);
-}
-#endif
-
-void mpack_tree_set_limits(mpack_tree_t* tree, size_t max_message_size, size_t max_message_nodes) {
-    mpack_assert(max_message_size > 0);
-    mpack_assert(max_message_nodes > 0);
-    tree->max_size = max_message_size;
-    tree->max_nodes = max_message_nodes;
-}
-
-#if MPACK_STDIO
-typedef struct mpack_file_tree_t {
-    char* data;
-    size_t size;
-    char buffer[MPACK_BUFFER_SIZE];
-} mpack_file_tree_t;
-
-static void mpack_file_tree_teardown(mpack_tree_t* tree) {
-    mpack_file_tree_t* file_tree = (mpack_file_tree_t*)tree->context;
-    MPACK_FREE(file_tree->data);
-    MPACK_FREE(file_tree);
-}
-
-static bool mpack_file_tree_read(mpack_tree_t* tree, mpack_file_tree_t* file_tree, FILE* file, size_t max_bytes) {
-
-    // get the file size
-    errno = 0;
-    int error = 0;
-    fseek(file, 0, SEEK_END);
-    error |= errno;
-    long size = ftell(file);
-    error |= errno;
-    fseek(file, 0, SEEK_SET);
-    error |= errno;
-
-    // check for errors
-    if (error != 0 || size < 0) {
-        mpack_tree_init_error(tree, mpack_error_io);
-        return false;
-    }
-    if (size == 0) {
-        mpack_tree_init_error(tree, mpack_error_invalid);
-        return false;
-    }
-
-    // make sure the size is less than max_bytes
-    // (this mess exists to safely convert between long and size_t regardless of their widths)
-    if (max_bytes != 0 && (((uint64_t)LONG_MAX > (uint64_t)SIZE_MAX && size > (long)SIZE_MAX) || (size_t)size > max_bytes)) {
-        mpack_tree_init_error(tree, mpack_error_too_big);
-        return false;
-    }
-
-    // allocate data
-    file_tree->data = (char*)MPACK_MALLOC((size_t)size);
-    if (file_tree->data == NULL) {
-        mpack_tree_init_error(tree, mpack_error_memory);
-        return false;
-    }
-
-    // read the file
-    long total = 0;
-    while (total < size) {
-        size_t read = fread(file_tree->data + total, 1, (size_t)(size - total), file);
-        if (read <= 0) {
-            mpack_tree_init_error(tree, mpack_error_io);
-            MPACK_FREE(file_tree->data);
-            return false;
-        }
-        total += (long)read;
-    }
-
-    file_tree->size = (size_t)size;
-    return true;
-}
-
-static bool mpack_tree_file_check_max_bytes(mpack_tree_t* tree, size_t max_bytes) {
-
-    // the C STDIO family of file functions use long (e.g. ftell)
-    if (max_bytes > LONG_MAX) {
-        mpack_break("max_bytes of %" PRIu64 " is invalid, maximum is LONG_MAX", (uint64_t)max_bytes);
-        mpack_tree_init_error(tree, mpack_error_bug);
-        return false;
-    }
-
-    return true;
-}
-
-static void mpack_tree_init_stdfile_noclose(mpack_tree_t* tree, FILE* stdfile, size_t max_bytes) {
-
-    // allocate file tree
-    mpack_file_tree_t* file_tree = (mpack_file_tree_t*) MPACK_MALLOC(sizeof(mpack_file_tree_t));
-    if (file_tree == NULL) {
-        mpack_tree_init_error(tree, mpack_error_memory);
-        return;
-    }
-
-    // read all data
-    if (!mpack_file_tree_read(tree, file_tree, stdfile, max_bytes)) {
-        MPACK_FREE(file_tree);
-        return;
-    }
-
-    mpack_tree_init_data(tree, file_tree->data, file_tree->size);
-    mpack_tree_set_context(tree, file_tree);
-    mpack_tree_set_teardown(tree, mpack_file_tree_teardown);
-}
-
-void mpack_tree_init_stdfile(mpack_tree_t* tree, FILE* stdfile, size_t max_bytes, bool close_when_done) {
-    if (!mpack_tree_file_check_max_bytes(tree, max_bytes))
-        return;
-
-    mpack_tree_init_stdfile_noclose(tree, stdfile, max_bytes);
-
-    if (close_when_done)
-        fclose(stdfile);
-}
-
-void mpack_tree_init_filename(mpack_tree_t* tree, const char* filename, size_t max_bytes) {
-    if (!mpack_tree_file_check_max_bytes(tree, max_bytes))
-        return;
-
-    // open the file
-    FILE* file = fopen(filename, "rb");
-    if (!file) {
-        mpack_tree_init_error(tree, mpack_error_io);
-        return;
-    }
-
-    mpack_tree_init_stdfile(tree, file, max_bytes, true);
-}
-#endif
-
-mpack_error_t mpack_tree_destroy(mpack_tree_t* tree) {
-    mpack_tree_cleanup(tree);
-
-    #ifdef MPACK_MALLOC
-    if (tree->buffer)
-        MPACK_FREE(tree->buffer);
-    #endif
-
-    if (tree->teardown)
-        tree->teardown(tree);
-    tree->teardown = NULL;
-
-    return tree->error;
-}
-
-void mpack_tree_flag_error(mpack_tree_t* tree, mpack_error_t error) {
-    if (tree->error == mpack_ok) {
-        mpack_log("tree %p setting error %i: %s\n", tree, (int)error, mpack_error_to_string(error));
-        tree->error = error;
-        if (tree->error_fn)
-            tree->error_fn(tree, error);
-    }
-
-}
-
-
-
-/*
- * Node misc functions
- */
-
-void mpack_node_flag_error(mpack_node_t node, mpack_error_t error) {
-    mpack_tree_flag_error(node.tree, error);
-}
-
-mpack_tag_t mpack_node_tag(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return mpack_tag_nil();
-
-    mpack_tag_t tag = MPACK_TAG_ZERO;
-
-    tag.type = node.data->type;
-    switch (node.data->type) {
-        case mpack_type_missing:
-            // If a node is missing, I don't know if it makes sense to ask for
-            // a tag for it. We'll return a missing tag to match the missing
-            // node I guess, but attempting to use the tag for anything (like
-            // writing it for example) will flag mpack_error_bug.
-            break;
-        case mpack_type_nil:                                            break;
-        case mpack_type_bool:    tag.v.b = node.data->value.b;          break;
-        case mpack_type_float:   tag.v.f = node.data->value.f;          break;
-        case mpack_type_double:  tag.v.d = node.data->value.d;          break;
-        case mpack_type_int:     tag.v.i = node.data->value.i;          break;
-        case mpack_type_uint:    tag.v.u = node.data->value.u;          break;
-
-        case mpack_type_str:     tag.v.l = node.data->len;     break;
-        case mpack_type_bin:     tag.v.l = node.data->len;     break;
-
-        #if MPACK_EXTENSIONS
-        case mpack_type_ext:
-            tag.v.l = node.data->len;
-            tag.exttype = mpack_node_exttype_unchecked(node);
-            break;
-        #endif
-
-        case mpack_type_array:   tag.v.n = node.data->len;  break;
-        case mpack_type_map:     tag.v.n = node.data->len;  break;
-
-        default:
-            mpack_assert(0, "unrecognized type %i", (int)node.data->type);
-            break;
-    }
-    return tag;
-}
-
-#if MPACK_DEBUG && MPACK_STDIO
-static void mpack_node_print_element(mpack_node_t node, mpack_print_t* print, size_t depth) {
-    mpack_node_data_t* data = node.data;
-    switch (data->type) {
-        case mpack_type_str:
-            {
-                mpack_print_append_cstr(print, "\"");
-                const char* bytes = mpack_node_data_unchecked(node);
-                for (size_t i = 0; i < data->len; ++i) {
-                    char c = bytes[i];
-                    switch (c) {
-                        case '\n': mpack_print_append_cstr(print, "\\n"); break;
-                        case '\\': mpack_print_append_cstr(print, "\\\\"); break;
-                        case '"': mpack_print_append_cstr(print, "\\\""); break;
-                        default: mpack_print_append(print, &c, 1); break;
-                    }
-                }
-                mpack_print_append_cstr(print, "\"");
-            }
-            break;
-
-        case mpack_type_array:
-            mpack_print_append_cstr(print, "[\n");
-            for (size_t i = 0; i < data->len; ++i) {
-                for (size_t j = 0; j < depth + 1; ++j)
-                    mpack_print_append_cstr(print, "    ");
-                mpack_node_print_element(mpack_node_array_at(node, i), print, depth + 1);
-                if (i != data->len - 1)
-                    mpack_print_append_cstr(print, ",");
-                mpack_print_append_cstr(print, "\n");
-            }
-            for (size_t i = 0; i < depth; ++i)
-                mpack_print_append_cstr(print, "    ");
-            mpack_print_append_cstr(print, "]");
-            break;
-
-        case mpack_type_map:
-            mpack_print_append_cstr(print, "{\n");
-            for (size_t i = 0; i < data->len; ++i) {
-                for (size_t j = 0; j < depth + 1; ++j)
-                    mpack_print_append_cstr(print, "    ");
-                mpack_node_print_element(mpack_node_map_key_at(node, i), print, depth + 1);
-                mpack_print_append_cstr(print, ": ");
-                mpack_node_print_element(mpack_node_map_value_at(node, i), print, depth + 1);
-                if (i != data->len - 1)
-                    mpack_print_append_cstr(print, ",");
-                mpack_print_append_cstr(print, "\n");
-            }
-            for (size_t i = 0; i < depth; ++i)
-                mpack_print_append_cstr(print, "    ");
-            mpack_print_append_cstr(print, "}");
-            break;
-
-        default:
-            {
-                const char* prefix = NULL;
-                size_t prefix_length = 0;
-                if (mpack_node_type(node) == mpack_type_bin
-                        #if MPACK_EXTENSIONS
-                        || mpack_node_type(node) == mpack_type_ext
-                        #endif
-                ) {
-                    prefix = mpack_node_data(node);
-                    prefix_length = mpack_node_data_len(node);
-                }
-
-                char buf[256];
-                mpack_tag_t tag = mpack_node_tag(node);
-                mpack_tag_debug_pseudo_json(tag, buf, sizeof(buf), prefix, prefix_length);
-                mpack_print_append_cstr(print, buf);
-            }
-            break;
-    }
-}
-
-void mpack_node_print_to_buffer(mpack_node_t node, char* buffer, size_t buffer_size) {
-    if (buffer_size == 0) {
-        mpack_assert(false, "buffer size is zero!");
-        return;
-    }
-
-    mpack_print_t print;
-    mpack_memset(&print, 0, sizeof(print));
-    print.buffer = buffer;
-    print.size = buffer_size;
-    mpack_node_print_element(node, &print, 0);
-    mpack_print_append(&print, "",  1); // null-terminator
-    mpack_print_flush(&print);
-
-    // we always make sure there's a null-terminator at the end of the buffer
-    // in case we ran out of space.
-    print.buffer[print.size - 1] = '\0';
-}
-
-void mpack_node_print_to_callback(mpack_node_t node, mpack_print_callback_t callback, void* context) {
-    char buffer[1024];
-    mpack_print_t print;
-    mpack_memset(&print, 0, sizeof(print));
-    print.buffer = buffer;
-    print.size = sizeof(buffer);
-    print.callback = callback;
-    print.context = context;
-    mpack_node_print_element(node, &print, 0);
-    mpack_print_flush(&print);
-}
-
-void mpack_node_print_to_file(mpack_node_t node, FILE* file) {
-    mpack_assert(file != NULL, "file is NULL");
-
-    char buffer[1024];
-    mpack_print_t print;
-    mpack_memset(&print, 0, sizeof(print));
-    print.buffer = buffer;
-    print.size = sizeof(buffer);
-    print.callback = &mpack_print_file_callback;
-    print.context = file;
-
-    size_t depth = 2;
-    for (size_t i = 0; i < depth; ++i)
-        mpack_print_append_cstr(&print, "    ");
-    mpack_node_print_element(node, &print, depth);
-    mpack_print_append_cstr(&print, "\n");
-    mpack_print_flush(&print);
-}
-#endif
- 
-
- 
-/*
- * Node Value Functions
- */
-
-#if MPACK_EXTENSIONS
-mpack_timestamp_t mpack_node_timestamp(mpack_node_t node) {
-    mpack_timestamp_t timestamp = {0, 0};
-
-    // we'll let mpack_node_exttype() do most checks
-    if (mpack_node_exttype(node) != MPACK_EXTTYPE_TIMESTAMP) {
-        mpack_log("exttype %i\n", mpack_node_exttype(node));
-        mpack_node_flag_error(node, mpack_error_type);
-        return timestamp;
-    }
-
-    const char* p = mpack_node_data_unchecked(node);
-
-    switch (node.data->len) {
-        case 4:
-            timestamp.nanoseconds = 0;
-            timestamp.seconds = mpack_load_u32(p);
-            break;
-
-        case 8: {
-            uint64_t value = mpack_load_u64(p);
-            timestamp.nanoseconds = (uint32_t)(value >> 34);
-            timestamp.seconds = value & ((UINT64_C(1) << 34) - 1);
-            break;
-        }
-
-        case 12:
-            timestamp.nanoseconds = mpack_load_u32(p);
-            timestamp.seconds = mpack_load_i64(p + 4);
-            break;
-
-        default:
-            mpack_tree_flag_error(node.tree, mpack_error_invalid);
-            return timestamp;
-    }
-
-    if (timestamp.nanoseconds > MPACK_TIMESTAMP_NANOSECONDS_MAX) {
-        mpack_tree_flag_error(node.tree, mpack_error_invalid);
-        mpack_timestamp_t zero = {0, 0};
-        return zero;
-    }
-
-    return timestamp;
-}
-
-int64_t mpack_node_timestamp_seconds(mpack_node_t node) {
-    return mpack_node_timestamp(node).seconds;
-}
-
-uint32_t mpack_node_timestamp_nanoseconds(mpack_node_t node) {
-    return mpack_node_timestamp(node).nanoseconds;
-}
-#endif
-
-
-
-/*
- * Node Data Functions
- */
-
-void mpack_node_check_utf8(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return;
-    mpack_node_data_t* data = node.data;
-    if (data->type != mpack_type_str || !mpack_utf8_check(mpack_node_data_unchecked(node), data->len))
-        mpack_node_flag_error(node, mpack_error_type);
-}
-
-void mpack_node_check_utf8_cstr(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return;
-    mpack_node_data_t* data = node.data;
-    if (data->type != mpack_type_str || !mpack_utf8_check_no_null(mpack_node_data_unchecked(node), data->len))
-        mpack_node_flag_error(node, mpack_error_type);
-}
-
-size_t mpack_node_copy_data(mpack_node_t node, char* buffer, size_t bufsize) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0;
-
-    mpack_assert(bufsize == 0 || buffer != NULL, "buffer is NULL for maximum of %i bytes", (int)bufsize);
-
-    mpack_type_t type = node.data->type;
-    if (type != mpack_type_str && type != mpack_type_bin
-            #if MPACK_EXTENSIONS
-            && type != mpack_type_ext
-            #endif
-    ) {
-        mpack_node_flag_error(node, mpack_error_type);
-        return 0;
-    }
-
-    if (node.data->len > bufsize) {
-        mpack_node_flag_error(node, mpack_error_too_big);
-        return 0;
-    }
-
-    mpack_memcpy(buffer, mpack_node_data_unchecked(node), node.data->len);
-    return (size_t)node.data->len;
-}
-
-size_t mpack_node_copy_utf8(mpack_node_t node, char* buffer, size_t bufsize) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0;
-
-    mpack_assert(bufsize == 0 || buffer != NULL, "buffer is NULL for maximum of %i bytes", (int)bufsize);
-
-    mpack_type_t type = node.data->type;
-    if (type != mpack_type_str) {
-        mpack_node_flag_error(node, mpack_error_type);
-        return 0;
-    }
-
-    if (node.data->len > bufsize) {
-        mpack_node_flag_error(node, mpack_error_too_big);
-        return 0;
-    }
-
-    if (!mpack_utf8_check(mpack_node_data_unchecked(node), node.data->len)) {
-        mpack_node_flag_error(node, mpack_error_type);
-        return 0;
-    }
-
-    mpack_memcpy(buffer, mpack_node_data_unchecked(node), node.data->len);
-    return (size_t)node.data->len;
-}
-
-void mpack_node_copy_cstr(mpack_node_t node, char* buffer, size_t bufsize) {
-
-    // we can't break here because the error isn't recoverable; we
-    // have to add a null-terminator.
-    mpack_assert(buffer != NULL, "buffer is NULL");
-    mpack_assert(bufsize >= 1, "buffer size is zero; you must have room for at least a null-terminator");
-
-    if (mpack_node_error(node) != mpack_ok) {
-        buffer[0] = '\0';
-        return;
-    }
-
-    if (node.data->type != mpack_type_str) {
-        buffer[0] = '\0';
-        mpack_node_flag_error(node, mpack_error_type);
-        return;
-    }
-
-    if (node.data->len > bufsize - 1) {
-        buffer[0] = '\0';
-        mpack_node_flag_error(node, mpack_error_too_big);
-        return;
-    }
-
-    if (!mpack_str_check_no_null(mpack_node_data_unchecked(node), node.data->len)) {
-        buffer[0] = '\0';
-        mpack_node_flag_error(node, mpack_error_type);
-        return;
-    }
-
-    mpack_memcpy(buffer, mpack_node_data_unchecked(node), node.data->len);
-    buffer[node.data->len] = '\0';
-}
-
-void mpack_node_copy_utf8_cstr(mpack_node_t node, char* buffer, size_t bufsize) {
-
-    // we can't break here because the error isn't recoverable; we
-    // have to add a null-terminator.
-    mpack_assert(buffer != NULL, "buffer is NULL");
-    mpack_assert(bufsize >= 1, "buffer size is zero; you must have room for at least a null-terminator");
-
-    if (mpack_node_error(node) != mpack_ok) {
-        buffer[0] = '\0';
-        return;
-    }
-
-    if (node.data->type != mpack_type_str) {
-        buffer[0] = '\0';
-        mpack_node_flag_error(node, mpack_error_type);
-        return;
-    }
-
-    if (node.data->len > bufsize - 1) {
-        buffer[0] = '\0';
-        mpack_node_flag_error(node, mpack_error_too_big);
-        return;
-    }
-
-    if (!mpack_utf8_check_no_null(mpack_node_data_unchecked(node), node.data->len)) {
-        buffer[0] = '\0';
-        mpack_node_flag_error(node, mpack_error_type);
-        return;
-    }
-
-    mpack_memcpy(buffer, mpack_node_data_unchecked(node), node.data->len);
-    buffer[node.data->len] = '\0';
-}
-
-#ifdef MPACK_MALLOC
-char* mpack_node_data_alloc(mpack_node_t node, size_t maxlen) {
-    if (mpack_node_error(node) != mpack_ok)
-        return NULL;
-
-    // make sure this is a valid data type
-    mpack_type_t type = node.data->type;
-    if (type != mpack_type_str && type != mpack_type_bin
-            #if MPACK_EXTENSIONS
-            && type != mpack_type_ext
-            #endif
-    ) {
-        mpack_node_flag_error(node, mpack_error_type);
-        return NULL;
-    }
-
-    if (node.data->len > maxlen) {
-        mpack_node_flag_error(node, mpack_error_too_big);
-        return NULL;
-    }
-
-    char* ret = (char*) MPACK_MALLOC((size_t)node.data->len);
-    if (ret == NULL) {
-        mpack_node_flag_error(node, mpack_error_memory);
-        return NULL;
-    }
-
-    mpack_memcpy(ret, mpack_node_data_unchecked(node), node.data->len);
-    return ret;
-}
-
-char* mpack_node_cstr_alloc(mpack_node_t node, size_t maxlen) {
-    if (mpack_node_error(node) != mpack_ok)
-        return NULL;
-
-    // make sure maxlen makes sense
-    if (maxlen < 1) {
-        mpack_break("maxlen is zero; you must have room for at least a null-terminator");
-        mpack_node_flag_error(node, mpack_error_bug);
-        return NULL;
-    }
-
-    if (node.data->type != mpack_type_str) {
-        mpack_node_flag_error(node, mpack_error_type);
-        return NULL;
-    }
-
-    if (node.data->len > maxlen - 1) {
-        mpack_node_flag_error(node, mpack_error_too_big);
-        return NULL;
-    }
-
-    if (!mpack_str_check_no_null(mpack_node_data_unchecked(node), node.data->len)) {
-        mpack_node_flag_error(node, mpack_error_type);
-        return NULL;
-    }
-
-    char* ret = (char*) MPACK_MALLOC((size_t)(node.data->len + 1));
-    if (ret == NULL) {
-        mpack_node_flag_error(node, mpack_error_memory);
-        return NULL;
-    }
-
-    mpack_memcpy(ret, mpack_node_data_unchecked(node), node.data->len);
-    ret[node.data->len] = '\0';
-    return ret;
-}
-
-char* mpack_node_utf8_cstr_alloc(mpack_node_t node, size_t maxlen) {
-    if (mpack_node_error(node) != mpack_ok)
-        return NULL;
-
-    // make sure maxlen makes sense
-    if (maxlen < 1) {
-        mpack_break("maxlen is zero; you must have room for at least a null-terminator");
-        mpack_node_flag_error(node, mpack_error_bug);
-        return NULL;
-    }
-
-    if (node.data->type != mpack_type_str) {
-        mpack_node_flag_error(node, mpack_error_type);
-        return NULL;
-    }
-
-    if (node.data->len > maxlen - 1) {
-        mpack_node_flag_error(node, mpack_error_too_big);
-        return NULL;
-    }
-
-    if (!mpack_utf8_check_no_null(mpack_node_data_unchecked(node), node.data->len)) {
-        mpack_node_flag_error(node, mpack_error_type);
-        return NULL;
-    }
-
-    char* ret = (char*) MPACK_MALLOC((size_t)(node.data->len + 1));
-    if (ret == NULL) {
-        mpack_node_flag_error(node, mpack_error_memory);
-        return NULL;
-    }
-
-    mpack_memcpy(ret, mpack_node_data_unchecked(node), node.data->len);
-    ret[node.data->len] = '\0';
-    return ret;
-}
-#endif
-
-
-/*
- * Compound Node Functions
- */
-
-static mpack_node_data_t* mpack_node_map_int_impl(mpack_node_t node, int64_t num) {
-    if (mpack_node_error(node) != mpack_ok)
-        return NULL;
-
-    if (node.data->type != mpack_type_map) {
-        mpack_node_flag_error(node, mpack_error_type);
-        return NULL;
-    }
-
-    mpack_node_data_t* found = NULL;
-
-    for (size_t i = 0; i < node.data->len; ++i) {
-        mpack_node_data_t* key = mpack_node_child(node, i * 2);
-
-        if ((key->type == mpack_type_int && key->value.i == num) ||
-            (key->type == mpack_type_uint && num >= 0 && key->value.u == (uint64_t)num))
-        {
-            if (found) {
-                mpack_node_flag_error(node, mpack_error_data);
-                return NULL;
-            }
-            found = mpack_node_child(node, i * 2 + 1);
-        }
-    }
-
-    if (found)
-        return found;
-
-    return NULL;
-}
-
-static mpack_node_data_t* mpack_node_map_uint_impl(mpack_node_t node, uint64_t num) {
-    if (mpack_node_error(node) != mpack_ok)
-        return NULL;
-
-    if (node.data->type != mpack_type_map) {
-        mpack_node_flag_error(node, mpack_error_type);
-        return NULL;
-    }
-
-    mpack_node_data_t* found = NULL;
-
-    for (size_t i = 0; i < node.data->len; ++i) {
-        mpack_node_data_t* key = mpack_node_child(node, i * 2);
-
-        if ((key->type == mpack_type_uint && key->value.u == num) ||
-            (key->type == mpack_type_int && key->value.i >= 0 && (uint64_t)key->value.i == num))
-        {
-            if (found) {
-                mpack_node_flag_error(node, mpack_error_data);
-                return NULL;
-            }
-            found = mpack_node_child(node, i * 2 + 1);
-        }
-    }
-
-    if (found)
-        return found;
-
-    return NULL;
-}
-
-static mpack_node_data_t* mpack_node_map_str_impl(mpack_node_t node, const char* str, size_t length) {
-    if (mpack_node_error(node) != mpack_ok)
-        return NULL;
-
-    mpack_assert(length == 0 || str != NULL, "str of length %i is NULL", (int)length);
-
-    if (node.data->type != mpack_type_map) {
-        mpack_node_flag_error(node, mpack_error_type);
-        return NULL;
-    }
-
-    mpack_tree_t* tree = node.tree;
-    mpack_node_data_t* found = NULL;
-
-    for (size_t i = 0; i < node.data->len; ++i) {
-        mpack_node_data_t* key = mpack_node_child(node, i * 2);
-
-        if (key->type == mpack_type_str && key->len == length &&
-                mpack_memcmp(str, mpack_node_data_unchecked(mpack_node(tree, key)), length) == 0) {
-            if (found) {
-                mpack_node_flag_error(node, mpack_error_data);
-                return NULL;
-            }
-            found = mpack_node_child(node, i * 2 + 1);
-        }
-    }
-
-    if (found)
-        return found;
-
-    return NULL;
-}
-
-static mpack_node_t mpack_node_wrap_lookup(mpack_tree_t* tree, mpack_node_data_t* data) {
-    if (!data) {
-        if (tree->error == mpack_ok)
-            mpack_tree_flag_error(tree, mpack_error_data);
-        return mpack_tree_nil_node(tree);
-    }
-    return mpack_node(tree, data);
-}
-
-static mpack_node_t mpack_node_wrap_lookup_optional(mpack_tree_t* tree, mpack_node_data_t* data) {
-    if (!data) {
-        if (tree->error == mpack_ok)
-            return mpack_tree_missing_node(tree);
-        return mpack_tree_nil_node(tree);
-    }
-    return mpack_node(tree, data);
-}
-
-mpack_node_t mpack_node_map_int(mpack_node_t node, int64_t num) {
-    return mpack_node_wrap_lookup(node.tree, mpack_node_map_int_impl(node, num));
-}
-
-mpack_node_t mpack_node_map_int_optional(mpack_node_t node, int64_t num) {
-    return mpack_node_wrap_lookup_optional(node.tree, mpack_node_map_int_impl(node, num));
-}
-
-mpack_node_t mpack_node_map_uint(mpack_node_t node, uint64_t num) {
-    return mpack_node_wrap_lookup(node.tree, mpack_node_map_uint_impl(node, num));
-}
-
-mpack_node_t mpack_node_map_uint_optional(mpack_node_t node, uint64_t num) {
-    return mpack_node_wrap_lookup_optional(node.tree, mpack_node_map_uint_impl(node, num));
-}
-
-mpack_node_t mpack_node_map_str(mpack_node_t node, const char* str, size_t length) {
-    return mpack_node_wrap_lookup(node.tree, mpack_node_map_str_impl(node, str, length));
-}
-
-mpack_node_t mpack_node_map_str_optional(mpack_node_t node, const char* str, size_t length) {
-    return mpack_node_wrap_lookup_optional(node.tree, mpack_node_map_str_impl(node, str, length));
-}
-
-mpack_node_t mpack_node_map_cstr(mpack_node_t node, const char* cstr) {
-    mpack_assert(cstr != NULL, "cstr is NULL");
-    return mpack_node_map_str(node, cstr, mpack_strlen(cstr));
-}
-
-mpack_node_t mpack_node_map_cstr_optional(mpack_node_t node, const char* cstr) {
-    mpack_assert(cstr != NULL, "cstr is NULL");
-    return mpack_node_map_str_optional(node, cstr, mpack_strlen(cstr));
-}
-
-bool mpack_node_map_contains_int(mpack_node_t node, int64_t num) {
-    return mpack_node_map_int_impl(node, num) != NULL;
-}
-
-bool mpack_node_map_contains_uint(mpack_node_t node, uint64_t num) {
-    return mpack_node_map_uint_impl(node, num) != NULL;
-}
-
-bool mpack_node_map_contains_str(mpack_node_t node, const char* str, size_t length) {
-    return mpack_node_map_str_impl(node, str, length) != NULL;
-}
-
-bool mpack_node_map_contains_cstr(mpack_node_t node, const char* cstr) {
-    mpack_assert(cstr != NULL, "cstr is NULL");
-    return mpack_node_map_contains_str(node, cstr, mpack_strlen(cstr));
-}
-
-size_t mpack_node_enum_optional(mpack_node_t node, const char* strings[], size_t count) {
-    if (mpack_node_error(node) != mpack_ok)
-        return count;
-
-    // the value is only recognized if it is a string
-    if (mpack_node_type(node) != mpack_type_str)
-        return count;
-
-    // fetch the string
-    const char* key = mpack_node_str(node);
-    size_t keylen = mpack_node_strlen(node);
-    mpack_assert(mpack_node_error(node) == mpack_ok, "these should not fail");
-
-    // find what key it matches
-    for (size_t i = 0; i < count; ++i) {
-        const char* other = strings[i];
-        size_t otherlen = mpack_strlen(other);
-        if (keylen == otherlen && mpack_memcmp(key, other, keylen) == 0)
-            return i;
-    }
-
-    // no matches
-    return count;
-}
-
-size_t mpack_node_enum(mpack_node_t node, const char* strings[], size_t count) {
-    size_t value = mpack_node_enum_optional(node, strings, count);
-    if (value == count)
-        mpack_node_flag_error(node, mpack_error_type);
-    return value;
-}
-
-mpack_type_t mpack_node_type(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return mpack_type_nil;
-    return node.data->type;
-}
-
-bool mpack_node_is_nil(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok) {
-        // All nodes are treated as nil nodes when we are in error.
-        return true;
-    }
-    return node.data->type == mpack_type_nil;
-}
-
-bool mpack_node_is_missing(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok) {
-        // errors still return nil nodes, not missing nodes.
-        return false;
-    }
-    return node.data->type == mpack_type_missing;
-}
-
-void mpack_node_nil(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return;
-    if (node.data->type != mpack_type_nil)
-        mpack_node_flag_error(node, mpack_error_type);
-}
-
-void mpack_node_missing(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return;
-    if (node.data->type != mpack_type_missing)
-        mpack_node_flag_error(node, mpack_error_type);
-}
-
-bool mpack_node_bool(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return false;
-
-    if (node.data->type == mpack_type_bool)
-        return node.data->value.b;
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return false;
-}
-
-void mpack_node_true(mpack_node_t node) {
-    if (mpack_node_bool(node) != true)
-        mpack_node_flag_error(node, mpack_error_type);
-}
-
-void mpack_node_false(mpack_node_t node) {
-    if (mpack_node_bool(node) != false)
-        mpack_node_flag_error(node, mpack_error_type);
-}
-
-uint8_t mpack_node_u8(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0;
-
-    if (node.data->type == mpack_type_uint) {
-        if (node.data->value.u <= UINT8_MAX)
-            return (uint8_t)node.data->value.u;
-    } else if (node.data->type == mpack_type_int) {
-        if (node.data->value.i >= 0 && node.data->value.i <= UINT8_MAX)
-            return (uint8_t)node.data->value.i;
-    }
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return 0;
-}
-
-int8_t mpack_node_i8(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0;
-
-    if (node.data->type == mpack_type_uint) {
-        if (node.data->value.u <= INT8_MAX)
-            return (int8_t)node.data->value.u;
-    } else if (node.data->type == mpack_type_int) {
-        if (node.data->value.i >= INT8_MIN && node.data->value.i <= INT8_MAX)
-            return (int8_t)node.data->value.i;
-    }
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return 0;
-}
-
-uint16_t mpack_node_u16(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0;
-
-    if (node.data->type == mpack_type_uint) {
-        if (node.data->value.u <= UINT16_MAX)
-            return (uint16_t)node.data->value.u;
-    } else if (node.data->type == mpack_type_int) {
-        if (node.data->value.i >= 0 && node.data->value.i <= UINT16_MAX)
-            return (uint16_t)node.data->value.i;
-    }
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return 0;
-}
-
-int16_t mpack_node_i16(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0;
-
-    if (node.data->type == mpack_type_uint) {
-        if (node.data->value.u <= INT16_MAX)
-            return (int16_t)node.data->value.u;
-    } else if (node.data->type == mpack_type_int) {
-        if (node.data->value.i >= INT16_MIN && node.data->value.i <= INT16_MAX)
-            return (int16_t)node.data->value.i;
-    }
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return 0;
-}
-
-uint32_t mpack_node_u32(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0;
-
-    if (node.data->type == mpack_type_uint) {
-        if (node.data->value.u <= UINT32_MAX)
-            return (uint32_t)node.data->value.u;
-    } else if (node.data->type == mpack_type_int) {
-        if (node.data->value.i >= 0 && node.data->value.i <= UINT32_MAX)
-            return (uint32_t)node.data->value.i;
-    }
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return 0;
-}
-
-int32_t mpack_node_i32(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0;
-
-    if (node.data->type == mpack_type_uint) {
-        if (node.data->value.u <= INT32_MAX)
-            return (int32_t)node.data->value.u;
-    } else if (node.data->type == mpack_type_int) {
-        if (node.data->value.i >= INT32_MIN && node.data->value.i <= INT32_MAX)
-            return (int32_t)node.data->value.i;
-    }
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return 0;
-}
-
-uint64_t mpack_node_u64(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0;
-
-    if (node.data->type == mpack_type_uint) {
-        return node.data->value.u;
-    } else if (node.data->type == mpack_type_int) {
-        if (node.data->value.i >= 0)
-            return (uint64_t)node.data->value.i;
-    }
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return 0;
-}
-
-int64_t mpack_node_i64(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0;
-
-    if (node.data->type == mpack_type_uint) {
-        if (node.data->value.u <= (uint64_t)INT64_MAX)
-            return (int64_t)node.data->value.u;
-    } else if (node.data->type == mpack_type_int) {
-        return node.data->value.i;
-    }
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return 0;
-}
-
-unsigned int mpack_node_uint(mpack_node_t node) {
-
-    // This should be true at compile-time, so this just wraps the 32-bit function.
-    if (sizeof(unsigned int) == 4)
-        return (unsigned int)mpack_node_u32(node);
-
-    // Otherwise we use u64 and check the range.
-    uint64_t val = mpack_node_u64(node);
-    if (val <= UINT_MAX)
-        return (unsigned int)val;
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return 0;
-}
-
-int mpack_node_int(mpack_node_t node) {
-
-    // This should be true at compile-time, so this just wraps the 32-bit function.
-    if (sizeof(int) == 4)
-        return (int)mpack_node_i32(node);
-
-    // Otherwise we use i64 and check the range.
-    int64_t val = mpack_node_i64(node);
-    if (val >= INT_MIN && val <= INT_MAX)
-        return (int)val;
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return 0;
-}
-
-float mpack_node_float(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0.0f;
-
-    if (node.data->type == mpack_type_uint)
-        return (float)node.data->value.u;
-    else if (node.data->type == mpack_type_int)
-        return (float)node.data->value.i;
-    else if (node.data->type == mpack_type_float)
-        return node.data->value.f;
-    else if (node.data->type == mpack_type_double)
-        return (float)node.data->value.d;
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return 0.0f;
-}
-
-double mpack_node_double(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0.0;
-
-    if (node.data->type == mpack_type_uint)
-        return (double)node.data->value.u;
-    else if (node.data->type == mpack_type_int)
-        return (double)node.data->value.i;
-    else if (node.data->type == mpack_type_float)
-        return (double)node.data->value.f;
-    else if (node.data->type == mpack_type_double)
-        return node.data->value.d;
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return 0.0;
-}
-
-float mpack_node_float_strict(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0.0f;
-
-    if (node.data->type == mpack_type_float)
-        return node.data->value.f;
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return 0.0f;
-}
-
-double mpack_node_double_strict(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0.0;
-
-    if (node.data->type == mpack_type_float)
-        return (double)node.data->value.f;
-    else if (node.data->type == mpack_type_double)
-        return node.data->value.d;
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return 0.0;
-}
-
-#if MPACK_EXTENSIONS
-int8_t mpack_node_exttype(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0;
-
-    if (node.data->type == mpack_type_ext)
-        return mpack_node_exttype_unchecked(node);
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return 0;
-}
-#endif
-
-uint32_t mpack_node_data_len(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0;
-
-    mpack_type_t type = node.data->type;
-    if (type == mpack_type_str || type == mpack_type_bin
-            #if MPACK_EXTENSIONS
-            || type == mpack_type_ext
-            #endif
-            )
-        return (uint32_t)node.data->len;
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return 0;
-}
-
-size_t mpack_node_strlen(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0;
-
-    if (node.data->type == mpack_type_str)
-        return (size_t)node.data->len;
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return 0;
-}
-
-const char* mpack_node_str(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return NULL;
-
-    mpack_type_t type = node.data->type;
-    if (type == mpack_type_str)
-        return mpack_node_data_unchecked(node);
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return NULL;
-}
-
-const char* mpack_node_data(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return NULL;
-
-    mpack_type_t type = node.data->type;
-    if (type == mpack_type_str || type == mpack_type_bin
-            #if MPACK_EXTENSIONS
-            || type == mpack_type_ext
-            #endif
-            )
-        return mpack_node_data_unchecked(node);
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return NULL;
-}
-
-const char* mpack_node_bin_data(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return NULL;
-
-    if (node.data->type == mpack_type_bin)
-        return mpack_node_data_unchecked(node);
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return NULL;
-}
-
-size_t mpack_node_bin_size(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0;
-
-    if (node.data->type == mpack_type_bin)
-        return (size_t)node.data->len;
-
-    mpack_node_flag_error(node, mpack_error_type);
-    return 0;
-}
-
-size_t mpack_node_array_length(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0;
-
-    if (node.data->type != mpack_type_array) {
-        mpack_node_flag_error(node, mpack_error_type);
-        return 0;
-    }
-
-    return (size_t)node.data->len;
-}
-
-mpack_node_t mpack_node_array_at(mpack_node_t node, size_t index) {
-    if (mpack_node_error(node) != mpack_ok)
-        return mpack_tree_nil_node(node.tree);
-
-    if (node.data->type != mpack_type_array) {
-        mpack_node_flag_error(node, mpack_error_type);
-        return mpack_tree_nil_node(node.tree);
-    }
-
-    if (index >= node.data->len) {
-        mpack_node_flag_error(node, mpack_error_data);
-        return mpack_tree_nil_node(node.tree);
-    }
-
-    return mpack_node(node.tree, mpack_node_child(node, index));
-}
-
-size_t mpack_node_map_count(mpack_node_t node) {
-    if (mpack_node_error(node) != mpack_ok)
-        return 0;
-
-    if (node.data->type != mpack_type_map) {
-        mpack_node_flag_error(node, mpack_error_type);
-        return 0;
-    }
-
-    return node.data->len;
-}
-
-// internal node map lookup
-static mpack_node_t mpack_node_map_at(mpack_node_t node, size_t index, size_t offset) {
-    if (mpack_node_error(node) != mpack_ok)
-        return mpack_tree_nil_node(node.tree);
-
-    if (node.data->type != mpack_type_map) {
-        mpack_node_flag_error(node, mpack_error_type);
-        return mpack_tree_nil_node(node.tree);
-    }
-
-    if (index >= node.data->len) {
-        mpack_node_flag_error(node, mpack_error_data);
-        return mpack_tree_nil_node(node.tree);
-    }
-
-    return mpack_node(node.tree, mpack_node_child(node, index * 2 + offset));
-}
-
-mpack_node_t mpack_node_map_key_at(mpack_node_t node, size_t index) {
-    return mpack_node_map_at(node, index, 0);
-}
-
-mpack_node_t mpack_node_map_value_at(mpack_node_t node, size_t index) {
-    return mpack_node_map_at(node, index, 1);
-}
-
-#endif
diff --git a/mpack.h b/mpack.h
deleted file mode 100644
index ee989d8..0000000
--- a/mpack.h
+++ /dev/null
@@ -1,7151 +0,0 @@
-/**
- * The MIT License (MIT)
- * 
- * Copyright (c) 2015-2018 Nicholas Fraser
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * 
- */
-
-/*
- * This is the MPack 1.0 amalgamation package.
- *
- * http://github.com/ludocode/mpack
- */
-
-#ifndef MPACK_H
-#define MPACK_H 1
-
-#define MPACK_AMALGAMATED 1
-#define MPACK_RELEASE_VERSION 1
-
-#if defined(MPACK_HAS_CONFIG) && MPACK_HAS_CONFIG
-#include "mpack-config.h"
-#endif
-
-
-/* mpack/mpack-defaults.h.h */
-
-
-/**
- * @name Features
- * @{
- */
-
-/**
- * @def MPACK_READER
- *
- * Enables compilation of the base Tag Reader.
- */
-#ifndef MPACK_READER
-#define MPACK_READER 1
-#endif
-
-/**
- * @def MPACK_EXPECT
- *
- * Enables compilation of the static Expect API.
- */
-#ifndef MPACK_EXPECT
-#define MPACK_EXPECT 1
-#endif
-
-/**
- * @def MPACK_NODE
- *
- * Enables compilation of the dynamic Node API.
- */
-#ifndef MPACK_NODE
-#define MPACK_NODE 1
-#endif
-
-/**
- * @def MPACK_WRITER
- *
- * Enables compilation of the Writer.
- */
-#ifndef MPACK_WRITER
-#define MPACK_WRITER 1
-#endif
-
-/**
- * @def MPACK_COMPATIBILITY
- *
- * Enables compatibility features for reading and writing older
- * versions of MessagePack.
- *
- * This is disabled by default. When disabled, the behaviour is equivalent to
- * using the default version, @ref mpack_version_current.
- *
- * Enable this if you need to interoperate with applications or data that do
- * not support the new (v5) MessagePack spec. See the section on v4
- * compatibility in @ref docs/protocol.md for more information.
- */
-#ifndef MPACK_COMPATIBILITY
-#define MPACK_COMPATIBILITY 0
-#endif
-
-/**
- * @def MPACK_EXTENSIONS
- *
- * Enables the use of extension types.
- *
- * This is disabled by default. Define it to 1 to enable it. If disabled,
- * functions to read and write extensions will not exist, and any occurrence of
- * extension types in parsed messages will flag @ref mpack_error_invalid.
- *
- * MPack discourages the use of extension types. See the section on extension
- * types in @ref docs/protocol.md for more information.
- */
-#ifndef MPACK_EXTENSIONS
-#define MPACK_EXTENSIONS 0
-#endif
-
-
-/**
- * @}
- */
-
-
-/**
- * @name Dependencies
- * @{
- */
-
-/**
- * @def MPACK_HAS_CONFIG
- *
- * Enables the use of an @c mpack-config.h configuration file for MPack.
- * This file must be in the same folder as @c mpack.h, or it must be
- * available from your project's include paths.
- */
-// This goes in your project settings.
-
-/**
- * @def MPACK_STDLIB
- *
- * Enables the use of C stdlib. This allows the library to use malloc
- * for debugging and in allocation helpers.
- */
-#ifndef MPACK_STDLIB
-#define MPACK_STDLIB 1
-#endif
-
-/**
- * @def MPACK_STDIO
- *
- * Enables the use of C stdio. This adds helpers for easily
- * reading/writing C files and makes debugging easier.
- */
-#ifndef MPACK_STDIO
-#define MPACK_STDIO 1
-#endif
-
-/**
- * @}
- */
-
-
-/**
- * @name System Functions
- * @{
- */
-
-/**
- * @def MPACK_MALLOC
- *
- * Defines the memory allocation function used by MPack. This is used by
- * helpers for automatically allocating data the correct size, and for
- * debugging functions. If this macro is undefined, the allocation helpers
- * will not be compiled.
- *
- * The default is @c malloc() if @ref MPACK_STDLIB is enabled.
- */
-/**
- * @def MPACK_FREE
- *
- * Defines the memory free function used by MPack. This is used by helpers
- * for automatically allocating data the correct size. If this macro is
- * undefined, the allocation helpers will not be compiled.
- *
- * The default is @c free() if @ref MPACK_MALLOC has not been customized and
- * @ref MPACK_STDLIB is enabled.
- */
-/**
- * @def MPACK_REALLOC
- *
- * Defines the realloc function used by MPack. It is used by growable
- * buffers to resize more efficiently.
- *
- * The default is @c realloc() if @ref MPACK_MALLOC has not been customized and
- * @ref MPACK_STDLIB is enabled.
- *
- * This is optional, even when @ref MPACK_MALLOC is used. If @ref MPACK_MALLOC is
- * set and @ref MPACK_REALLOC is not, @ref MPACK_MALLOC is used with a simple copy
- * to grow buffers.
- */
-#if defined(MPACK_STDLIB) && MPACK_STDLIB && !defined(MPACK_MALLOC)
-#define MPACK_MALLOC malloc
-#define MPACK_REALLOC realloc
-#define MPACK_FREE free
-#endif
-
-/**
- * @}
- */
-
-
-/**
- * @name Debugging Options
- */
-
-/**
- * @def MPACK_DEBUG
- *
- * Enables debug features. You may want to wrap this around your
- * own debug preprocs. By default, this is enabled if @c DEBUG or @c _DEBUG
- * are defined. (@c NDEBUG is not used since it is allowed to have
- * different values in different translation units.)
- */
-#if !defined(MPACK_DEBUG) && (defined(DEBUG) || defined(_DEBUG))
-#define MPACK_DEBUG 1
-#endif
-
-/**
- * @def MPACK_STRINGS
- *
- * Enables descriptive error and type strings.
- *
- * This can be turned off (by defining it to 0) to maximize space savings
- * on embedded devices. If this is disabled, string functions such as
- * mpack_error_to_string() and mpack_type_to_string() return an empty string.
- */
-#ifndef MPACK_STRINGS
-#define MPACK_STRINGS 1
-#endif
-
-/**
- * Set this to 1 to implement a custom @ref mpack_assert_fail() function.
- * See the documentation on @ref mpack_assert_fail() for details.
- *
- * Asserts are only used when @ref MPACK_DEBUG is enabled, and can be
- * triggered by bugs in MPack or bugs due to incorrect usage of MPack.
- */
-#ifndef MPACK_CUSTOM_ASSERT
-#define MPACK_CUSTOM_ASSERT 0
-#endif
-
-/**
- * @def MPACK_READ_TRACKING
- *
- * Enables compound type size tracking for readers. This ensures that the
- * correct number of elements or bytes are read from a compound type.
- *
- * This is enabled by default in debug builds (provided a @c malloc() is
- * available.)
- */
-#if !defined(MPACK_READ_TRACKING) && \
-        defined(MPACK_DEBUG) && MPACK_DEBUG && \
-        defined(MPACK_READER) && MPACK_READER && \
-        defined(MPACK_MALLOC)
-#define MPACK_READ_TRACKING 1
-#endif
-
-/**
- * @def MPACK_WRITE_TRACKING
- *
- * Enables compound type size tracking for writers. This ensures that the
- * correct number of elements or bytes are written in a compound type.
- *
- * Note that without write tracking enabled, it is possible for buggy code
- * to emit invalid MessagePack without flagging an error by writing the wrong
- * number of elements or bytes in a compound type. With tracking enabled,
- * MPack will catch such errors and break on the offending line of code.
- *
- * This is enabled by default in debug builds (provided a @c malloc() is
- * available.)
- */
-#if !defined(MPACK_WRITE_TRACKING) && \
-        defined(MPACK_DEBUG) && MPACK_DEBUG && \
-        defined(MPACK_WRITER) && MPACK_WRITER && \
-        defined(MPACK_MALLOC)
-#define MPACK_WRITE_TRACKING 1
-#endif
-
-/**
- * @}
- */
-
-
-/**
- * @name Miscellaneous Options
- * @{
- */
-
-/**
- * Whether to optimize for size or speed.
- *
- * Optimizing for size simplifies some parsing and encoding algorithms
- * at the expense of speed, and saves a few kilobytes of space in the
- * resulting executable.
- *
- * This automatically detects -Os with GCC/Clang. Unfortunately there
- * doesn't seem to be a macro defined for /Os under MSVC.
- */
-#ifndef MPACK_OPTIMIZE_FOR_SIZE
-#ifdef __OPTIMIZE_SIZE__
-#define MPACK_OPTIMIZE_FOR_SIZE 1
-#else
-#define MPACK_OPTIMIZE_FOR_SIZE 0
-#endif
-#endif
-
-/**
- * Stack space in bytes to use when initializing a reader or writer
- * with a stack-allocated buffer.
- */
-#ifndef MPACK_STACK_SIZE
-#define MPACK_STACK_SIZE 4096
-#endif
-
-/**
- * Buffer size to use for allocated buffers (such as for a file writer.)
- *
- * Starting with a single page and growing as needed seems to
- * provide the best performance with minimal memory waste.
- * Increasing this does not improve performance even when writing
- * huge messages.
- */
-#ifndef MPACK_BUFFER_SIZE
-#define MPACK_BUFFER_SIZE 4096
-#endif
-
-/**
- * Minimum size of an allocated node page in bytes.
- *
- * The children for a given compound element must be contiguous, so
- * larger pages than this may be allocated as needed. (Safety checks
- * exist to prevent malicious data from causing too large allocations.)
- *
- * See @ref mpack_node_data_t for the size of nodes.
- *
- * Using as many nodes fit in one memory page seems to provide the
- * best performance, and has very little waste when parsing small
- * messages.
- */
-#ifndef MPACK_NODE_PAGE_SIZE
-#define MPACK_NODE_PAGE_SIZE 4096
-#endif
-
-/**
- * The initial depth for the node parser. When MPACK_MALLOC is available,
- * the node parser has no practical depth limit, and it is not recursive
- * so there is no risk of overflowing the call stack.
- */
-#ifndef MPACK_NODE_INITIAL_DEPTH
-#define MPACK_NODE_INITIAL_DEPTH 8
-#endif
-
-/**
- * The maximum depth for the node parser if @ref MPACK_MALLOC is not available.
- */
-#ifndef MPACK_NODE_MAX_DEPTH_WITHOUT_MALLOC
-#define MPACK_NODE_MAX_DEPTH_WITHOUT_MALLOC 32
-#endif
-
-/**
- * @}
- */
-
-
-/**
- * @}
- */
-
-
-/* mpack/mpack-platform.h.h */
-
-/**
- * @file
- *
- * Abstracts all platform-specific code from MPack. This contains
- * implementations of standard C functions when libc is not available,
- * as well as wrappers to library functions.
- */
-
-#ifndef MPACK_PLATFORM_H
-#define MPACK_PLATFORM_H 1
-
-
-
-/* Pre-include checks */
-
-#if defined(_MSC_VER) && _MSC_VER < 1800 && !defined(__cplusplus)
-#error "In Visual Studio 2012 and earlier, MPack must be compiled as C++. Enable the /Tp compiler flag."
-#endif
-
-#if defined(WIN32) && defined(MPACK_INTERNAL) && MPACK_INTERNAL
-#define _CRT_SECURE_NO_WARNINGS 1
-#endif
-
-
-
-/* Doxygen preprocs */
-#if defined(MPACK_DOXYGEN) && MPACK_DOXYGEN
-#define MPACK_HAS_CONFIG 0
-// We give these their default values of 0 here even though they are defined to
-// 1 in the doxyfile. Doxygen will show this as the value in the docs, even
-// though it ignores it when parsing the rest of the source. This is what we
-// want, since we want the documentation to show these defaults but still
-// generate documentation for the functions they add when they're on.
-#define MPACK_COMPATIBILITY 0
-#define MPACK_EXTENSIONS 0
-#endif
-
-
-
-/* Include the custom config file if enabled */
-
-#if defined(MPACK_HAS_CONFIG) && MPACK_HAS_CONFIG
-/* #include "mpack-config.h" */
-#endif
-
-/*
- * Now that the optional config is included, we define the defaults
- * for any of the configuration options and other switches that aren't
- * yet defined.
- */
-#if defined(MPACK_DOXYGEN) && MPACK_DOXYGEN
-/* #include "mpack-defaults-doxygen.h" */
-#else
-/* #include "mpack-defaults.h" */
-#endif
-
-/*
- * All remaining configuration options that have not yet been set must
- * be defined here in order to support -Wundef.
- */
-#ifndef MPACK_DEBUG
-#define MPACK_DEBUG 0
-#endif
-#ifndef MPACK_CUSTOM_BREAK
-#define MPACK_CUSTOM_BREAK 0
-#endif
-#ifndef MPACK_READ_TRACKING
-#define MPACK_READ_TRACKING 0
-#endif
-#ifndef MPACK_WRITE_TRACKING
-#define MPACK_WRITE_TRACKING 0
-#endif
-#ifndef MPACK_EMIT_INLINE_DEFS
-#define MPACK_EMIT_INLINE_DEFS 0
-#endif
-#ifndef MPACK_AMALGAMATED
-#define MPACK_AMALGAMATED 0
-#endif
-#ifndef MPACK_RELEASE_VERSION
-#define MPACK_RELEASE_VERSION 0
-#endif
-#ifndef MPACK_INTERNAL
-#define MPACK_INTERNAL 0
-#endif
-#ifndef MPACK_NO_BUILTINS
-#define MPACK_NO_BUILTINS 0
-#endif
-
-
-
-/* System headers (based on configuration) */
-
-#ifndef __STDC_LIMIT_MACROS
-#define __STDC_LIMIT_MACROS 1
-#endif
-#ifndef __STDC_FORMAT_MACROS
-#define __STDC_FORMAT_MACROS 1
-#endif
-#ifndef __STDC_CONSTANT_MACROS
-#define __STDC_CONSTANT_MACROS 1
-#endif
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <inttypes.h>
-#include <limits.h>
-
-#if MPACK_STDLIB
-#include <string.h>
-#include <stdlib.h>
-#endif
-
-#if MPACK_STDIO
-#include <stdio.h>
-#include <errno.h>
-#endif
-
-
-
-/*
- * Header configuration
- */
-
-#ifdef __cplusplus
-    #define MPACK_EXTERN_C_START extern "C" {
-    #define MPACK_EXTERN_C_END   }
-#else
-    #define MPACK_EXTERN_C_START /* nothing */
-    #define MPACK_EXTERN_C_END   /* nothing */
-#endif
-
-/* GCC versions from 4.6 to before 5.1 warn about defining a C99
- * non-static inline function before declaring it (see issue #20) */
-#ifdef __GNUC__
-    #if (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-        #ifdef __cplusplus
-            #define MPACK_DECLARED_INLINE_WARNING_START \
-                _Pragma ("GCC diagnostic push") \
-                _Pragma ("GCC diagnostic ignored \"-Wmissing-declarations\"")
-        #else
-            #define MPACK_DECLARED_INLINE_WARNING_START \
-                _Pragma ("GCC diagnostic push") \
-                _Pragma ("GCC diagnostic ignored \"-Wmissing-prototypes\"")
-        #endif
-        #define MPACK_DECLARED_INLINE_WARNING_END \
-            _Pragma ("GCC diagnostic pop")
-    #endif
-#endif
-#ifndef MPACK_DECLARED_INLINE_WARNING_START
-    #define MPACK_DECLARED_INLINE_WARNING_START /* nothing */
-    #define MPACK_DECLARED_INLINE_WARNING_END /* nothing */
-#endif
-
-/* GCC versions before 4.8 warn about shadowing a function with a
- * variable that isn't a function or function pointer (like "index") */
-#ifdef __GNUC__
-    #if (__GNUC__ < 4) || (__GNUC__ == 4 && __GNUC_MINOR__ < 8)
-        #define MPACK_WSHADOW_WARNING_START \
-            _Pragma ("GCC diagnostic push") \
-            _Pragma ("GCC diagnostic ignored \"-Wshadow\"")
-        #define MPACK_WSHADOW_WARNING_END \
-            _Pragma ("GCC diagnostic pop")
-    #endif
-#endif
-#ifndef MPACK_WSHADOW_WARNING_START
-    #define MPACK_WSHADOW_WARNING_START /* nothing */
-    #define MPACK_WSHADOW_WARNING_END /* nothing */
-#endif
-
-#define MPACK_HEADER_START \
-    MPACK_EXTERN_C_START \
-    MPACK_WSHADOW_WARNING_START \
-    MPACK_DECLARED_INLINE_WARNING_START
-
-#define MPACK_HEADER_END \
-    MPACK_DECLARED_INLINE_WARNING_END \
-    MPACK_WSHADOW_WARNING_END \
-    MPACK_EXTERN_C_END
-
-MPACK_HEADER_START
-
-
-
-/* Miscellaneous helper macros */
-
-#define MPACK_UNUSED(var) ((void)(var))
-
-#define MPACK_STRINGIFY_IMPL(arg) #arg
-#define MPACK_STRINGIFY(arg) MPACK_STRINGIFY_IMPL(arg)
-
-// This is a workaround for MSVC's incorrect expansion of __VA_ARGS__. It
-// treats __VA_ARGS__ as a single preprocessor token when passed in the
-// argument list of another macro unless we use an outer wrapper to expand it
-// lexically first. (For safety/consistency we use this in all variadic macros
-// that don't ignore the variadic arguments regardless of whether __VA_ARGS__
-// is passed to another macro.)
-//     https://stackoverflow.com/a/32400131
-#define MPACK_EXPAND(x) x
-
-// Extracts the first argument of a variadic macro list, where there might only
-// be one argument.
-#define MPACK_EXTRACT_ARG0_IMPL(first, ...) first
-#define MPACK_EXTRACT_ARG0(...) MPACK_EXPAND(MPACK_EXTRACT_ARG0_IMPL( __VA_ARGS__ , ignored))
-
-// Stringifies the first argument of a variadic macro list, where there might
-// only be one argument.
-#define MPACK_STRINGIFY_ARG0_impl(first, ...) #first
-#define MPACK_STRINGIFY_ARG0(...) MPACK_EXPAND(MPACK_STRINGIFY_ARG0_impl( __VA_ARGS__ , ignored))
-
-
-
-/*
- * Definition of inline macros.
- *
- * MPack does not use static inline in header files; only one non-inline definition
- * of each function should exist in the final build. This can reduce the binary size
- * in cases where the compiler cannot or chooses not to inline a function.
- * The addresses of functions should also compare equal across translation units
- * regardless of whether they are declared inline.
- *
- * The above requirements mean that the declaration and definition of non-trivial
- * inline functions must be separated so that the definitions will only
- * appear when necessary. In addition, three different linkage models need
- * to be supported:
- *
- *  - The C99 model, where a standalone function is emitted only if there is any
- *    `extern inline` or non-`inline` declaration (including the definition itself)
- *
- *  - The GNU model, where an `inline` definition emits a standalone function and an
- *    `extern inline` definition does not, regardless of other declarations
- *
- *  - The C++ model, where `inline` emits a standalone function with special
- *    (COMDAT) linkage
- *
- * The macros below wrap up everything above. All inline functions defined in header
- * files have a single non-inline definition emitted in the compilation of
- * mpack-platform.c. All inline declarations and definitions use the same MPACK_INLINE
- * specification to simplify the rules on when standalone functions are emitted.
- * Inline functions in source files are defined MPACK_STATIC_INLINE.
- *
- * Additional reading:
- *     http://www.greenend.org.uk/rjk/tech/inline.html
- */
-
-#if defined(__cplusplus)
-    // C++ rules
-    // The linker will need COMDAT support to link C++ object files,
-    // so we don't need to worry about emitting definitions from C++
-    // translation units. If mpack-platform.c (or the amalgamation)
-    // is compiled as C, its definition will be used, otherwise a
-    // C++ definition will be used, and no other C files will emit
-    // a defition.
-    #define MPACK_INLINE inline
-
-#elif defined(_MSC_VER)
-    // MSVC 2013 always uses COMDAT linkage, but it doesn't treat 'inline' as a
-    // keyword in C99 mode. (This appears to be fixed in a later version of
-    // MSVC but we don't bother detecting it.)
-    #define MPACK_INLINE __inline
-    #define MPACK_STATIC_INLINE static __inline
-
-#elif defined(__GNUC__) && (defined(__GNUC_GNU_INLINE__) || \
-        !defined(__GNUC_STDC_INLINE__) && !defined(__GNUC_GNU_INLINE__))
-    // GNU rules
-    #if MPACK_EMIT_INLINE_DEFS
-        #define MPACK_INLINE inline
-    #else
-        #define MPACK_INLINE extern inline
-    #endif
-
-#else
-    // C99 rules
-    #if MPACK_EMIT_INLINE_DEFS
-        #define MPACK_INLINE extern inline
-    #else
-        #define MPACK_INLINE inline
-    #endif
-#endif
-
-#ifndef MPACK_STATIC_INLINE
-#define MPACK_STATIC_INLINE static inline
-#endif
-
-#ifdef MPACK_OPTIMIZE_FOR_SPEED
-    #error "You should define MPACK_OPTIMIZE_FOR_SIZE, not MPACK_OPTIMIZE_FOR_SPEED."
-#endif
-
-
-
-/*
- * Prevent inlining
- *
- * When a function is only used once, it is almost always inlined
- * automatically. This can cause poor instruction cache usage because a
- * function that should rarely be called (such as buffer exhaustion handling)
- * will get inlined into the middle of a hot code path.
- */
-
-#if !MPACK_NO_BUILTINS
-    #if defined(_MSC_VER)
-        #define MPACK_NOINLINE __declspec(noinline)
-    #elif defined(__GNUC__) || defined(__clang__)
-        #define MPACK_NOINLINE __attribute__((noinline))
-    #endif
-#endif
-#ifndef MPACK_NOINLINE
-    #define MPACK_NOINLINE /* nothing */
-#endif
-
-
-
-/* Some compiler-specific keywords and builtins */
-
-#if !MPACK_NO_BUILTINS
-    #if defined(__GNUC__) || defined(__clang__)
-        #define MPACK_UNREACHABLE __builtin_unreachable()
-        #define MPACK_NORETURN(fn) fn __attribute__((noreturn))
-        #define MPACK_RESTRICT __restrict__
-    #elif defined(_MSC_VER)
-        #define MPACK_UNREACHABLE __assume(0)
-        #define MPACK_NORETURN(fn) __declspec(noreturn) fn
-        #define MPACK_RESTRICT __restrict
-    #endif
-#endif
-
-#ifndef MPACK_RESTRICT
-#ifdef __cplusplus
-#define MPACK_RESTRICT /* nothing, unavailable in C++ */
-#else
-#define MPACK_RESTRICT restrict /* required in C99 */
-#endif
-#endif
-
-#ifndef MPACK_UNREACHABLE
-#define MPACK_UNREACHABLE ((void)0)
-#endif
-#ifndef MPACK_NORETURN
-#define MPACK_NORETURN(fn) fn
-#endif
-
-
-
-/*
- * Likely/unlikely
- *
- * These should only really be used when a branch is taken (or not taken) less
- * than 1/1000th of the time. Buffer flush checks when writing very small
- * elements are a good example.
- */
-
-#if !MPACK_NO_BUILTINS
-    #if defined(__GNUC__) || defined(__clang__)
-        #ifndef MPACK_LIKELY
-            #define MPACK_LIKELY(x) __builtin_expect((x),1)
-        #endif
-        #ifndef MPACK_UNLIKELY
-            #define MPACK_UNLIKELY(x) __builtin_expect((x),0)
-        #endif
-    #endif
-#endif
-
-#ifndef MPACK_LIKELY
-    #define MPACK_LIKELY(x) (x)
-#endif
-#ifndef MPACK_UNLIKELY
-    #define MPACK_UNLIKELY(x) (x)
-#endif
-
-
-
-/* Static assert */
-
-#ifndef MPACK_STATIC_ASSERT
-    #if defined(__cplusplus)
-        #if __cplusplus >= 201103L
-            #define MPACK_STATIC_ASSERT static_assert
-        #endif
-    #elif defined(__STDC_VERSION__)
-        #if __STDC_VERSION__ >= 201112L
-            #define MPACK_STATIC_ASSERT _Static_assert
-        #endif
-    #endif
-#endif
-
-#if !MPACK_NO_BUILTINS
-    #ifndef MPACK_STATIC_ASSERT
-        #if defined(__has_feature)
-            #if __has_feature(cxx_static_assert)
-                #define MPACK_STATIC_ASSERT static_assert
-            #elif __has_feature(c_static_assert)
-                #define MPACK_STATIC_ASSERT _Static_assert
-            #endif
-        #endif
-    #endif
-
-    #ifndef MPACK_STATIC_ASSERT
-        #if defined(__GNUC__)
-            #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
-                #ifndef __cplusplus
-                    #if __GNUC__ >= 5
-                    #define MPACK_IGNORE_PEDANTIC "GCC diagnostic ignored \"-Wpedantic\""
-                    #else
-                    #define MPACK_IGNORE_PEDANTIC "GCC diagnostic ignored \"-pedantic\""
-                    #endif
-                    #define MPACK_STATIC_ASSERT(expr, str) do { \
-                        _Pragma ("GCC diagnostic push") \
-                        _Pragma (MPACK_IGNORE_PEDANTIC) \
-                        _Pragma ("GCC diagnostic ignored \"-Wc++-compat\"") \
-                        _Static_assert(expr, str); \
-                        _Pragma ("GCC diagnostic pop") \
-                    } while (0)
-                #endif
-            #endif
-        #endif
-    #endif
-
-    #ifndef MPACK_STATIC_ASSERT
-        #ifdef _MSC_VER
-            #if _MSC_VER >= 1600
-                #define MPACK_STATIC_ASSERT static_assert
-            #endif
-        #endif
-    #endif
-#endif
-
-#ifndef MPACK_STATIC_ASSERT
-    #define MPACK_STATIC_ASSERT(expr, str) (MPACK_UNUSED(sizeof(char[1 - 2*!(expr)])))
-#endif
-
-
-
-/* _Generic */
-
-#ifndef MPACK_HAS_GENERIC
-    #if defined(__clang__) && defined(__has_feature)
-        // With Clang we can test for _Generic support directly
-        // and ignore C/C++ version
-        #if __has_feature(c_generic_selections)
-            #define MPACK_HAS_GENERIC 1
-        #else
-            #define MPACK_HAS_GENERIC 0
-        #endif
-    #endif
-#endif
-
-#ifndef MPACK_HAS_GENERIC
-    #if defined(__STDC_VERSION__)
-        #if __STDC_VERSION__ >= 201112L
-            #if defined(__GNUC__) && !defined(__clang__)
-                // GCC does not have full C11 support in GCC 4.7 and 4.8
-                #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9)
-                    #define MPACK_HAS_GENERIC 1
-                #endif
-            #else
-                // We hope other compilers aren't lying about C11/_Generic support
-                #define MPACK_HAS_GENERIC 1
-            #endif
-        #endif
-    #endif
-#endif
-
-#ifndef MPACK_HAS_GENERIC
-    #define MPACK_HAS_GENERIC 0
-#endif
-
-
-
-/*
- * Finite Math
- *
- * -ffinite-math-only, included in -ffast-math, breaks functions that
- * that check for non-finite real values such as isnan() and isinf().
- *
- * We should use this to trap errors when reading data that contains
- * non-finite reals. This isn't currently implemented.
- */
-
-#ifndef MPACK_FINITE_MATH
-#if defined(__FINITE_MATH_ONLY__) && __FINITE_MATH_ONLY__
-#define MPACK_FINITE_MATH 1
-#endif
-#endif
-
-#ifndef MPACK_FINITE_MATH
-#define MPACK_FINITE_MATH 0
-#endif
-
-
-
-/*
- * Endianness checks
- *
- * These define MPACK_NHSWAP*() which swap network<->host byte
- * order when needed.
- *
- * We leave them undefined if we can't determine the endianness
- * at compile-time, in which case we fall back to bit-shifts.
- *
- * See the notes in mpack-common.h.
- */
-
-#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && defined(__ORDER_BIG_ENDIAN__)
-    #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-        #define MPACK_NHSWAP16(x) (x)
-        #define MPACK_NHSWAP32(x) (x)
-        #define MPACK_NHSWAP64(x) (x)
-    #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-
-        #if !MPACK_NO_BUILTINS
-            #if defined(__clang__)
-                #ifdef __has_builtin
-                    // Unlike the GCC builtins, the bswap builtins in Clang
-                    // significantly improve ARM performance.
-                    #if __has_builtin(__builtin_bswap16)
-                        #define MPACK_NHSWAP16(x) __builtin_bswap16(x)
-                    #endif
-                    #if __has_builtin(__builtin_bswap32)
-                        #define MPACK_NHSWAP32(x) __builtin_bswap32(x)
-                    #endif
-                    #if __has_builtin(__builtin_bswap64)
-                        #define MPACK_NHSWAP64(x) __builtin_bswap64(x)
-                    #endif
-                #endif
-
-            #elif defined(__GNUC__)
-
-                // The GCC bswap builtins are apparently poorly optimized on older
-                // versions of GCC, so we set a minimum version here just in case.
-                //     http://hardwarebug.org/2010/01/14/beware-the-builtins/
-
-                #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
-                    #define MPACK_NHSWAP64(x) __builtin_bswap64(x)
-                #endif
-
-                // __builtin_bswap16() was not implemented on all platforms
-                // until GCC 4.8.0:
-                //     https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52624
-                //
-                // The 16- and 32-bit versions in GCC significantly reduce performance
-                // on ARM with little effect on code size so we don't use them.
-
-            #endif
-        #endif
-    #endif
-
-#elif defined(_MSC_VER) && defined(_WIN32) && !MPACK_NO_BUILTINS
-
-    // On Windows, we assume x86 and x86_64 are always little-endian.
-    // We make no assumptions about ARM even though all current
-    // Windows Phone devices are little-endian in case Microsoft's
-    // compiler is ever used with a big-endian ARM device.
-
-    #if defined(_M_IX86) || defined(_M_X64) || defined(_M_AMD64)
-        #define MPACK_NHSWAP16(x) _byteswap_ushort(x)
-        #define MPACK_NHSWAP32(x) _byteswap_ulong(x)
-        #define MPACK_NHSWAP64(x) _byteswap_uint64(x)
-    #endif
-
-#endif
-
-#if defined(__FLOAT_WORD_ORDER__) && defined(__BYTE_ORDER__)
-
-    // We check where possible that the float byte order matches the
-    // integer byte order. This is extremely unlikely to fail, but
-    // we check anyway just in case.
-    //
-    // (The static assert is placed in float/double encoders instead
-    // of here because our static assert fallback doesn't work at
-    // file scope)
-
-    #define MPACK_CHECK_FLOAT_ORDER() \
-        MPACK_STATIC_ASSERT(__FLOAT_WORD_ORDER__ == __BYTE_ORDER__, \
-            "float byte order does not match int byte order! float/double " \
-            "encoding is not properly implemented on this platform.")
-
-#endif
-
-#ifndef MPACK_CHECK_FLOAT_ORDER
-    #define MPACK_CHECK_FLOAT_ORDER() /* nothing */
-#endif
-
-
-/*
- * Here we define mpack_assert() and mpack_break(). They both work like a normal
- * assertion function in debug mode, causing a trap or abort. However, on some platforms
- * you can safely resume execution from mpack_break(), whereas mpack_assert() is
- * always fatal.
- *
- * In release mode, mpack_assert() is converted to an assurance to the compiler
- * that the expression cannot be false (via e.g. __assume() or __builtin_unreachable())
- * to improve optimization where supported. There is thus no point in "safely" handling
- * the case of this being false. Writing mpack_assert(0) rarely makes sense (except
- * possibly as a default handler in a switch) since the compiler will throw away any
- * code after it. If at any time an mpack_assert() is not true, the behaviour is
- * undefined. This also means the expression is evaluated even in release.
- *
- * mpack_break() on the other hand is compiled to nothing in release. It is
- * used in situations where we want to highlight a programming error as early as
- * possible (in the debugger), but we still handle the situation safely if it
- * happens in release to avoid producing incorrect results (such as in
- * MPACK_WRITE_TRACKING.) It does not take an expression to test because it
- * belongs in a safe-handling block after its failing condition has been tested.
- *
- * If stdio is available, we can add a format string describing the error, and
- * on some compilers we can declare it noreturn to get correct results from static
- * analysis tools. Note that the format string and arguments are not evaluated unless
- * the assertion is hit.
- *
- * Note that any arguments to mpack_assert() beyond the first are only evaluated
- * if the expression is false (and are never evaluated in release.)
- *
- * mpack_assert_fail() and mpack_break_hit() are defined separately
- * because assert is noreturn and break isn't. This distinction is very
- * important for static analysis tools to give correct results.
- */
-
-#if MPACK_DEBUG
-
-    /**
-     * @addtogroup config
-     * @{
-     */
-    /**
-     * @name Debug Functions
-     */
-    /**
-     * Implement this and define @ref MPACK_CUSTOM_ASSERT to use a custom
-     * assertion function.
-     *
-     * This function should not return. If it does, MPack will @c abort().
-     *
-     * If you use C++, make sure you include @c mpack.h where you define
-     * this to get the correct linkage (or define it <code>extern "C"</code>.)
-     *
-     * Asserts are only used when @ref MPACK_DEBUG is enabled, and can be
-     * triggered by bugs in MPack or bugs due to incorrect usage of MPack.
-     */
-    void mpack_assert_fail(const char* message);
-    /**
-     * @}
-     */
-    /**
-     * @}
-     */
-
-    MPACK_NORETURN(void mpack_assert_fail_wrapper(const char* message));
-    #if MPACK_STDIO
-        MPACK_NORETURN(void mpack_assert_fail_format(const char* format, ...));
-        #define mpack_assert_fail_at(line, file, exprstr, format, ...) \
-                MPACK_EXPAND(mpack_assert_fail_format("mpack assertion failed at " file ":" #line "\n%s\n" format, exprstr, __VA_ARGS__))
-    #else
-        #define mpack_assert_fail_at(line, file, exprstr, format, ...) \
-                mpack_assert_fail_wrapper("mpack assertion failed at " file ":" #line "\n" exprstr "\n")
-    #endif
-
-    #define mpack_assert_fail_pos(line, file, exprstr, expr, ...) \
-            MPACK_EXPAND(mpack_assert_fail_at(line, file, exprstr, __VA_ARGS__))
-
-    // This contains a workaround to the pedantic C99 requirement of having at
-    // least one argument to a variadic macro. The first argument is the
-    // boolean expression, the optional second argument (if provided) must be a
-    // literal format string, and any additional arguments are the format
-    // argument list.
-    //
-    // Unfortunately this means macros are expanded in the expression before it
-    // gets stringified. I haven't found a workaround to this.
-    //
-    // This adds two unused arguments to the format argument list when a
-    // format string is provided, so this would complicate the use of
-    // -Wformat and __attribute__((format)) on mpack_assert_fail_format() if we
-    // ever bothered to implement it.
-    #define mpack_assert(...) \
-            MPACK_EXPAND(((!(MPACK_EXTRACT_ARG0(__VA_ARGS__))) ? \
-                mpack_assert_fail_pos(__LINE__, __FILE__, MPACK_STRINGIFY_ARG0(__VA_ARGS__) , __VA_ARGS__ , "", NULL) : \
-                (void)0))
-
-    void mpack_break_hit(const char* message);
-    #if MPACK_STDIO
-        void mpack_break_hit_format(const char* format, ...);
-        #define mpack_break_hit_at(line, file, ...) \
-                MPACK_EXPAND(mpack_break_hit_format("mpack breakpoint hit at " file ":" #line "\n" __VA_ARGS__))
-    #else
-        #define mpack_break_hit_at(line, file, ...) \
-                mpack_break_hit("mpack breakpoint hit at " file ":" #line )
-    #endif
-    #define mpack_break_hit_pos(line, file, ...) MPACK_EXPAND(mpack_break_hit_at(line, file, __VA_ARGS__))
-    #define mpack_break(...) MPACK_EXPAND(mpack_break_hit_pos(__LINE__, __FILE__, __VA_ARGS__))
-#else
-    #define mpack_assert(...) \
-            (MPACK_EXPAND((!(MPACK_EXTRACT_ARG0(__VA_ARGS__))) ? \
-                (MPACK_UNREACHABLE, (void)0) : \
-                (void)0))
-    #define mpack_break(...) ((void)0)
-#endif
-
-
-
-/* Wrap some needed libc functions */
-
-#if MPACK_STDLIB
-    #define mpack_memcmp memcmp
-    #define mpack_memcpy memcpy
-    #define mpack_memmove memmove
-    #define mpack_memset memset
-    #ifndef mpack_strlen
-        #define mpack_strlen strlen
-    #endif
-
-    #if defined(MPACK_UNIT_TESTS) && MPACK_INTERNAL && defined(__GNUC__)
-        // make sure we don't use the stdlib directly during development
-        #undef memcmp
-        #undef memcpy
-        #undef memmove
-        #undef memset
-        #undef strlen
-        #undef malloc
-        #undef free
-        #pragma GCC poison memcmp
-        #pragma GCC poison memcpy
-        #pragma GCC poison memmove
-        #pragma GCC poison memset
-        #pragma GCC poison strlen
-        #pragma GCC poison malloc
-        #pragma GCC poison free
-    #endif
-
-#elif defined(__GNUC__) && !MPACK_NO_BUILTINS
-    // there's not always a builtin memmove for GCC,
-    // and we don't have a way to test for it
-    #define mpack_memcmp __builtin_memcmp
-    #define mpack_memcpy __builtin_memcpy
-    #define mpack_memset __builtin_memset
-    #define mpack_strlen __builtin_strlen
-
-#elif defined(__clang__) && defined(__has_builtin) && !MPACK_NO_BUILTINS
-    #if __has_builtin(__builtin_memcmp)
-    #define mpack_memcmp __builtin_memcmp
-    #endif
-    #if __has_builtin(__builtin_memcpy)
-    #define mpack_memcpy __builtin_memcpy
-    #endif
-    #if __has_builtin(__builtin_memmove)
-    #define mpack_memmove __builtin_memmove
-    #endif
-    #if __has_builtin(__builtin_memset)
-    #define mpack_memset __builtin_memset
-    #endif
-    #if __has_builtin(__builtin_strlen)
-    #define mpack_strlen __builtin_strlen
-    #endif
-#endif
-
-#ifndef mpack_memcmp
-int mpack_memcmp(const void* s1, const void* s2, size_t n);
-#endif
-#ifndef mpack_memcpy
-void* mpack_memcpy(void* MPACK_RESTRICT s1, const void* MPACK_RESTRICT s2, size_t n);
-#endif
-#ifndef mpack_memmove
-void* mpack_memmove(void* s1, const void* s2, size_t n);
-#endif
-#ifndef mpack_memset
-void* mpack_memset(void* s, int c, size_t n);
-#endif
-#ifndef mpack_strlen
-size_t mpack_strlen(const char* s);
-#endif
-
-#if MPACK_STDIO
-    #if defined(WIN32)
-        #define mpack_snprintf _snprintf
-    #else
-        #define mpack_snprintf snprintf
-    #endif
-#endif
-
-
-
-/* Debug logging */
-#if 0
-    #include <stdio.h>
-    #define mpack_log(...) (MPACK_EXPAND(printf(__VA_ARGS__), fflush(stdout)))
-#else
-    #define mpack_log(...) ((void)0)
-#endif
-
-
-
-/* Make sure our configuration makes sense */
-#if defined(MPACK_MALLOC) && !defined(MPACK_FREE)
-    #error "MPACK_MALLOC requires MPACK_FREE."
-#endif
-#if !defined(MPACK_MALLOC) && defined(MPACK_FREE)
-    #error "MPACK_FREE requires MPACK_MALLOC."
-#endif
-#if MPACK_READ_TRACKING && !defined(MPACK_READER)
-    #error "MPACK_READ_TRACKING requires MPACK_READER."
-#endif
-#if MPACK_WRITE_TRACKING && !defined(MPACK_WRITER)
-    #error "MPACK_WRITE_TRACKING requires MPACK_WRITER."
-#endif
-#ifndef MPACK_MALLOC
-    #if MPACK_STDIO
-        #error "MPACK_STDIO requires preprocessor definitions for MPACK_MALLOC and MPACK_FREE."
-    #endif
-    #if MPACK_READ_TRACKING
-        #error "MPACK_READ_TRACKING requires preprocessor definitions for MPACK_MALLOC and MPACK_FREE."
-    #endif
-    #if MPACK_WRITE_TRACKING
-        #error "MPACK_WRITE_TRACKING requires preprocessor definitions for MPACK_MALLOC and MPACK_FREE."
-    #endif
-#endif
-
-
-
-/* Implement realloc if unavailable */
-#ifdef MPACK_MALLOC
-    #ifdef MPACK_REALLOC
-        MPACK_INLINE void* mpack_realloc(void* old_ptr, size_t used_size, size_t new_size) {
-            MPACK_UNUSED(used_size);
-            return MPACK_REALLOC(old_ptr, new_size);
-        }
-    #else
-        void* mpack_realloc(void* old_ptr, size_t used_size, size_t new_size);
-    #endif
-#endif
-
-
-
-/**
- * @}
- */
-
-MPACK_HEADER_END
-
-#endif
-
-
-/* mpack/mpack-common.h.h */
-
-/**
- * @file
- *
- * Defines types and functions shared by the MPack reader and writer.
- */
-
-#ifndef MPACK_COMMON_H
-#define MPACK_COMMON_H 1
-
-/* #include "mpack-platform.h" */
-
-#ifndef MPACK_PRINT_BYTE_COUNT
-#define MPACK_PRINT_BYTE_COUNT 12
-#endif
-
-MPACK_HEADER_START
-
-
-
-/**
- * @defgroup common Tags and Common Elements
- *
- * Contains types, constants and functions shared by both the encoding
- * and decoding portions of MPack.
- *
- * @{
- */
-
-/* Version information */
-
-#define MPACK_VERSION_MAJOR 1  /**< The major version number of MPack. */
-#define MPACK_VERSION_MINOR 0  /**< The minor version number of MPack. */
-#define MPACK_VERSION_PATCH 0  /**< The patch version number of MPack. */
-
-/** A number containing the version number of MPack for comparison purposes. */
-#define MPACK_VERSION ((MPACK_VERSION_MAJOR * 10000) + \
-        (MPACK_VERSION_MINOR * 100) + MPACK_VERSION_PATCH)
-
-/** A macro to test for a minimum version of MPack. */
-#define MPACK_VERSION_AT_LEAST(major, minor, patch) \
-        (MPACK_VERSION >= (((major) * 10000) + ((minor) * 100) + (patch)))
-
-/** @cond */
-#if (MPACK_VERSION_PATCH > 0)
-#define MPACK_VERSION_STRING_BASE \
-        MPACK_STRINGIFY(MPACK_VERSION_MAJOR) "." \
-        MPACK_STRINGIFY(MPACK_VERSION_MINOR) "." \
-        MPACK_STRINGIFY(MPACK_VERSION_PATCH)
-#else
-#define MPACK_VERSION_STRING_BASE \
-        MPACK_STRINGIFY(MPACK_VERSION_MAJOR) "." \
-        MPACK_STRINGIFY(MPACK_VERSION_MINOR)
-#endif
-/** @endcond */
-
-/**
- * @def MPACK_VERSION_STRING
- * @hideinitializer
- *
- * A string containing the MPack version.
- */
-#if MPACK_RELEASE_VERSION
-#define MPACK_VERSION_STRING MPACK_VERSION_STRING_BASE
-#else
-#define MPACK_VERSION_STRING MPACK_VERSION_STRING_BASE "dev"
-#endif
-
-/**
- * @def MPACK_LIBRARY_STRING
- * @hideinitializer
- *
- * A string describing MPack, containing the library name, version and debug mode.
- */
-#if MPACK_DEBUG
-#define MPACK_LIBRARY_STRING "MPack " MPACK_VERSION_STRING "-debug"
-#else
-#define MPACK_LIBRARY_STRING "MPack " MPACK_VERSION_STRING
-#endif
-
-/** @cond */
-/**
- * @def MPACK_MAXIMUM_TAG_SIZE
- *
- * The maximum encoded size of a tag in bytes.
- */
-#define MPACK_MAXIMUM_TAG_SIZE 9
-/** @endcond */
-
-#if MPACK_EXTENSIONS
-/**
- * @def MPACK_TIMESTAMP_NANOSECONDS_MAX
- *
- * The maximum value of nanoseconds for a timestamp.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- */
-#define MPACK_TIMESTAMP_NANOSECONDS_MAX 999999999
-#endif
-
-
-
-#if MPACK_COMPATIBILITY
-/**
- * Versions of the MessagePack format.
- *
- * A reader, writer, or tree can be configured to serialize in an older
- * version of the MessagePack spec. This is necessary to interface with
- * older MessagePack libraries that do not support new MessagePack features.
- *
- * @note This requires @ref MPACK_COMPATIBILITY.
- */
-typedef enum mpack_version_t {
-
-    /**
-     * Version 1.0/v4, supporting only the @c raw type without @c str8.
-     */
-    mpack_version_v4 = 4,
-
-    /**
-     * Version 2.0/v5, supporting the @c str8, @c bin and @c ext types.
-     */
-    mpack_version_v5 = 5,
-
-    /**
-     * The most recent supported version of MessagePack. This is the default.
-     */
-    mpack_version_current = mpack_version_v5,
-
-} mpack_version_t;
-#endif
-
-/**
- * Error states for MPack objects.
- *
- * When a reader, writer, or tree is in an error state, all subsequent calls
- * are ignored and their return values are nil/zero. You should check whether
- * the source is in an error state before using such values.
- */
-typedef enum mpack_error_t {
-    mpack_ok = 0,        /**< No error. */
-    mpack_error_io = 2,  /**< The reader or writer failed to fill or flush, or some other file or socket error occurred. */
-    mpack_error_invalid, /**< The data read is not valid MessagePack. */
-    mpack_error_unsupported, /**< The data read is not supported by this configuration of MPack. (See @ref MPACK_EXTENSIONS.) */
-    mpack_error_type,    /**< The type or value range did not match what was expected by the caller. */
-    mpack_error_too_big, /**< A read or write was bigger than the maximum size allowed for that operation. */
-    mpack_error_memory,  /**< An allocation failure occurred. */
-    mpack_error_bug,     /**< The MPack API was used incorrectly. (This will always assert in debug mode.) */
-    mpack_error_data,    /**< The contained data is not valid. */
-    mpack_error_eof,     /**< The reader failed to read because of file or socket EOF */
-} mpack_error_t;
-
-/**
- * Converts an MPack error to a string. This function returns an empty
- * string when MPACK_DEBUG is not set.
- */
-const char* mpack_error_to_string(mpack_error_t error);
-
-/**
- * Defines the type of a MessagePack tag.
- *
- * Note that extension types, both user defined and built-in, are represented
- * in tags as @ref mpack_type_ext. The value for an extension type is stored
- * separately.
- */
-typedef enum mpack_type_t {
-    mpack_type_missing = 0, /**< Special type indicating a missing optional value. */
-    mpack_type_nil,         /**< A null value. */
-    mpack_type_bool,        /**< A boolean (true or false.) */
-    mpack_type_int,         /**< A 64-bit signed integer. */
-    mpack_type_uint,        /**< A 64-bit unsigned integer. */
-    mpack_type_float,       /**< A 32-bit IEEE 754 floating point number. */
-    mpack_type_double,      /**< A 64-bit IEEE 754 floating point number. */
-    mpack_type_str,         /**< A string. */
-    mpack_type_bin,         /**< A chunk of binary data. */
-    mpack_type_array,       /**< An array of MessagePack objects. */
-    mpack_type_map,         /**< An ordered map of key/value pairs of MessagePack objects. */
-
-    #if MPACK_EXTENSIONS
-    /**
-     * A typed MessagePack extension object containing a chunk of binary data.
-     *
-     * @note This requires @ref MPACK_EXTENSIONS.
-     */
-    mpack_type_ext,
-    #endif
-} mpack_type_t;
-
-/**
- * Converts an MPack type to a string. This function returns an empty
- * string when MPACK_DEBUG is not set.
- */
-const char* mpack_type_to_string(mpack_type_t type);
-
-#if MPACK_EXTENSIONS
-/**
- * A timestamp.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- */
-typedef struct mpack_timestamp_t {
-    int64_t seconds; /*< The number of seconds (signed) since 1970-01-01T00:00:00Z. */
-    uint32_t nanoseconds; /*< The number of additional nanoseconds, between 0 and 999,999,999. */
-} mpack_timestamp_t;
-#endif
-
-/**
- * An MPack tag is a MessagePack object header. It is a variant type
- * representing any kind of object, and includes the length of compound types
- * (e.g. map, array, string) or the value of non-compound types (e.g. boolean,
- * integer, float.)
- *
- * If the type is compound (str, bin, ext, array or map), the contained
- * elements or bytes are stored separately.
- *
- * This structure is opaque; its fields should not be accessed outside
- * of MPack.
- */
-typedef struct mpack_tag_t mpack_tag_t;
-
-/* Hide internals from documentation */
-/** @cond */
-struct mpack_tag_t {
-    mpack_type_t type; /*< The type of value. */
-
-    #if MPACK_EXTENSIONS
-    int8_t exttype; /*< The extension type if the type is @ref mpack_type_ext. */
-    #endif
-
-    /* The value for non-compound types. */
-    union {
-        uint64_t u; /*< The value if the type is unsigned int. */
-        int64_t  i; /*< The value if the type is signed int. */
-        double   d; /*< The value if the type is double. */
-        float    f; /*< The value if the type is float. */
-        bool     b; /*< The value if the type is bool. */
-
-        /* The number of bytes if the type is str, bin or ext. */
-        uint32_t l;
-
-        /* The element count if the type is an array, or the number of
-            key/value pairs if the type is map. */
-        uint32_t n;
-    } v;
-};
-/** @endcond */
-
-/**
- * @name Tag Generators
- * @{
- */
-
-/**
- * @def MPACK_TAG_ZERO
- *
- * An @ref mpack_tag_t initializer that zeroes the given tag.
- *
- * @warning This does not make the tag nil! The tag's type is invalid when
- * initialized this way. Use @ref mpack_tag_make_nil() to generate a nil tag.
- */
-#if MPACK_EXTENSIONS
-#define MPACK_TAG_ZERO {(mpack_type_t)0, 0, {0}}
-#else
-#define MPACK_TAG_ZERO {(mpack_type_t)0, {0}}
-#endif
-
-/** Generates a nil tag. */
-MPACK_INLINE mpack_tag_t mpack_tag_make_nil(void) {
-    mpack_tag_t ret = MPACK_TAG_ZERO;
-    ret.type = mpack_type_nil;
-    return ret;
-}
-
-/** Generates a bool tag. */
-MPACK_INLINE mpack_tag_t mpack_tag_make_bool(bool value) {
-    mpack_tag_t ret = MPACK_TAG_ZERO;
-    ret.type = mpack_type_bool;
-    ret.v.b = value;
-    return ret;
-}
-
-/** Generates a bool tag with value true. */
-MPACK_INLINE mpack_tag_t mpack_tag_make_true(void) {
-    mpack_tag_t ret = MPACK_TAG_ZERO;
-    ret.type = mpack_type_bool;
-    ret.v.b = true;
-    return ret;
-}
-
-/** Generates a bool tag with value false. */
-MPACK_INLINE mpack_tag_t mpack_tag_make_false(void) {
-    mpack_tag_t ret = MPACK_TAG_ZERO;
-    ret.type = mpack_type_bool;
-    ret.v.b = false;
-    return ret;
-}
-
-/** Generates a signed int tag. */
-MPACK_INLINE mpack_tag_t mpack_tag_make_int(int64_t value) {
-    mpack_tag_t ret = MPACK_TAG_ZERO;
-    ret.type = mpack_type_int;
-    ret.v.i = value;
-    return ret;
-}
-
-/** Generates an unsigned int tag. */
-MPACK_INLINE mpack_tag_t mpack_tag_make_uint(uint64_t value) {
-    mpack_tag_t ret = MPACK_TAG_ZERO;
-    ret.type = mpack_type_uint;
-    ret.v.u = value;
-    return ret;
-}
-
-/** Generates a float tag. */
-MPACK_INLINE mpack_tag_t mpack_tag_make_float(float value) {
-    mpack_tag_t ret = MPACK_TAG_ZERO;
-    ret.type = mpack_type_float;
-    ret.v.f = value;
-    return ret;
-}
-
-/** Generates a double tag. */
-MPACK_INLINE mpack_tag_t mpack_tag_make_double(double value) {
-    mpack_tag_t ret = MPACK_TAG_ZERO;
-    ret.type = mpack_type_double;
-    ret.v.d = value;
-    return ret;
-}
-
-/** Generates an array tag. */
-MPACK_INLINE mpack_tag_t mpack_tag_make_array(uint32_t count) {
-    mpack_tag_t ret = MPACK_TAG_ZERO;
-    ret.type = mpack_type_array;
-    ret.v.n = count;
-    return ret;
-}
-
-/** Generates a map tag. */
-MPACK_INLINE mpack_tag_t mpack_tag_make_map(uint32_t count) {
-    mpack_tag_t ret = MPACK_TAG_ZERO;
-    ret.type = mpack_type_map;
-    ret.v.n = count;
-    return ret;
-}
-
-/** Generates a str tag. */
-MPACK_INLINE mpack_tag_t mpack_tag_make_str(uint32_t length) {
-    mpack_tag_t ret = MPACK_TAG_ZERO;
-    ret.type = mpack_type_str;
-    ret.v.l = length;
-    return ret;
-}
-
-/** Generates a bin tag. */
-MPACK_INLINE mpack_tag_t mpack_tag_make_bin(uint32_t length) {
-    mpack_tag_t ret = MPACK_TAG_ZERO;
-    ret.type = mpack_type_bin;
-    ret.v.l = length;
-    return ret;
-}
-
-#if MPACK_EXTENSIONS
-/**
- * Generates an ext tag.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- */
-MPACK_INLINE mpack_tag_t mpack_tag_make_ext(int8_t exttype, uint32_t length) {
-    mpack_tag_t ret = MPACK_TAG_ZERO;
-    ret.type = mpack_type_ext;
-    ret.exttype = exttype;
-    ret.v.l = length;
-    return ret;
-}
-#endif
-
-/**
- * @}
- */
-
-/**
- * @name Tag Querying Functions
- * @{
- */
-
-/**
- * Gets the type of a tag.
- */
-MPACK_INLINE mpack_type_t mpack_tag_type(mpack_tag_t* tag) {
-    return tag->type;
-}
-
-/**
- * Gets the boolean value of a bool-type tag. The tag must be of type @ref
- * mpack_type_bool.
- *
- * This asserts that the type in the tag is @ref mpack_type_bool. (No check is
- * performed if MPACK_DEBUG is not set.)
- */
-MPACK_INLINE bool mpack_tag_bool_value(mpack_tag_t* tag) {
-    mpack_assert(tag->type == mpack_type_bool, "tag is not a bool!");
-    return tag->v.b;
-}
-
-/**
- * Gets the signed integer value of an int-type tag.
- *
- * This asserts that the type in the tag is @ref mpack_type_int. (No check is
- * performed if MPACK_DEBUG is not set.)
- *
- * @warning This does not convert between signed and unsigned tags! A positive
- * integer may be stored in a tag as either @ref mpack_type_int or @ref
- * mpack_type_uint. You must check the type first; this can only be used if the
- * type is @ref mpack_type_int.
- *
- * @see mpack_type_int
- */
-MPACK_INLINE int64_t mpack_tag_int_value(mpack_tag_t* tag) {
-    mpack_assert(tag->type == mpack_type_int, "tag is not an int!");
-    return tag->v.i;
-}
-
-/**
- * Gets the unsigned integer value of a uint-type tag.
- *
- * This asserts that the type in the tag is @ref mpack_type_uint. (No check is
- * performed if MPACK_DEBUG is not set.)
- *
- * @warning This does not convert between signed and unsigned tags! A positive
- * integer may be stored in a tag as either @ref mpack_type_int or @ref
- * mpack_type_uint. You must check the type first; this can only be used if the
- * type is @ref mpack_type_uint.
- *
- * @see mpack_type_uint
- */
-MPACK_INLINE uint64_t mpack_tag_uint_value(mpack_tag_t* tag) {
-    mpack_assert(tag->type == mpack_type_uint, "tag is not a uint!");
-    return tag->v.u;
-}
-
-/**
- * Gets the float value of a float-type tag.
- *
- * This asserts that the type in the tag is @ref mpack_type_float. (No check is
- * performed if MPACK_DEBUG is not set.)
- *
- * @warning This does not convert between float and double tags! This can only
- * be used if the type is @ref mpack_type_float.
- *
- * @see mpack_type_float
- */
-MPACK_INLINE float mpack_tag_float_value(mpack_tag_t* tag) {
-    mpack_assert(tag->type == mpack_type_float, "tag is not a float!");
-    return tag->v.f;
-}
-
-/**
- * Gets the double value of a double-type tag.
- *
- * This asserts that the type in the tag is @ref mpack_type_double. (No check
- * is performed if MPACK_DEBUG is not set.)
- *
- * @warning This does not convert between float and double tags! This can only
- * be used if the type is @ref mpack_type_double.
- *
- * @see mpack_type_double
- */
-MPACK_INLINE double mpack_tag_double_value(mpack_tag_t* tag) {
-    mpack_assert(tag->type == mpack_type_double, "tag is not a double!");
-    return tag->v.d;
-}
-
-/**
- * Gets the number of elements in an array tag.
- *
- * This asserts that the type in the tag is @ref mpack_type_array. (No check is
- * performed if MPACK_DEBUG is not set.)
- *
- * @see mpack_type_array
- */
-MPACK_INLINE uint32_t mpack_tag_array_count(mpack_tag_t* tag) {
-    mpack_assert(tag->type == mpack_type_array, "tag is not an array!");
-    return tag->v.n;
-}
-
-/**
- * Gets the number of key-value pairs in a map tag.
- *
- * This asserts that the type in the tag is @ref mpack_type_map. (No check is
- * performed if MPACK_DEBUG is not set.)
- *
- * @see mpack_type_map
- */
-MPACK_INLINE uint32_t mpack_tag_map_count(mpack_tag_t* tag) {
-    mpack_assert(tag->type == mpack_type_map, "tag is not a map!");
-    return tag->v.n;
-}
-
-/**
- * Gets the length in bytes of a str-type tag.
- *
- * This asserts that the type in the tag is @ref mpack_type_str. (No check is
- * performed if MPACK_DEBUG is not set.)
- *
- * @see mpack_type_str
- */
-MPACK_INLINE uint32_t mpack_tag_str_length(mpack_tag_t* tag) {
-    mpack_assert(tag->type == mpack_type_str, "tag is not a str!");
-    return tag->v.l;
-}
-
-/**
- * Gets the length in bytes of a bin-type tag.
- *
- * This asserts that the type in the tag is @ref mpack_type_bin. (No check is
- * performed if MPACK_DEBUG is not set.)
- *
- * @see mpack_type_bin
- */
-MPACK_INLINE uint32_t mpack_tag_bin_length(mpack_tag_t* tag) {
-    mpack_assert(tag->type == mpack_type_bin, "tag is not a bin!");
-    return tag->v.l;
-}
-
-#if MPACK_EXTENSIONS
-/**
- * Gets the length in bytes of an ext-type tag.
- *
- * This asserts that the type in the tag is @ref mpack_type_ext. (No check is
- * performed if MPACK_DEBUG is not set.)
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- *
- * @see mpack_type_ext
- */
-MPACK_INLINE uint32_t mpack_tag_ext_length(mpack_tag_t* tag) {
-    mpack_assert(tag->type == mpack_type_ext, "tag is not an ext!");
-    return tag->v.l;
-}
-
-/**
- * Gets the extension type (exttype) of an ext-type tag.
- *
- * This asserts that the type in the tag is @ref mpack_type_ext. (No check is
- * performed if MPACK_DEBUG is not set.)
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- *
- * @see mpack_type_ext
- */
-MPACK_INLINE int8_t mpack_tag_ext_exttype(mpack_tag_t* tag) {
-    mpack_assert(tag->type == mpack_type_ext, "tag is not an ext!");
-    return tag->exttype;
-}
-#endif
-
-/**
- * Gets the length in bytes of a str-, bin- or ext-type tag.
- *
- * This asserts that the type in the tag is @ref mpack_type_str, @ref
- * mpack_type_bin or @ref mpack_type_ext. (No check is performed if MPACK_DEBUG
- * is not set.)
- *
- * @see mpack_type_str
- * @see mpack_type_bin
- * @see mpack_type_ext
- */
-MPACK_INLINE uint32_t mpack_tag_bytes(mpack_tag_t* tag) {
-    #if MPACK_EXTENSIONS
-    mpack_assert(tag->type == mpack_type_str || tag->type == mpack_type_bin
-            || tag->type == mpack_type_ext, "tag is not a str, bin or ext!");
-    #else
-    mpack_assert(tag->type == mpack_type_str || tag->type == mpack_type_bin,
-            "tag is not a str or bin!");
-    #endif
-    return tag->v.l;
-}
-
-/**
- * @}
- */
-
-/**
- * @name Other tag functions
- * @{
- */
-
-#if MPACK_EXTENSIONS
-/**
- * The extension type for a timestamp.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- */
-#define MPACK_EXTTYPE_TIMESTAMP ((int8_t)(-1))
-#endif
-
-/**
- * Compares two tags with an arbitrary fixed ordering. Returns 0 if the tags are
- * equal, a negative integer if left comes before right, or a positive integer
- * otherwise.
- *
- * \warning The ordering is not guaranteed to be preserved across MPack versions; do
- * not rely on it in persistent data.
- *
- * \warning Floating point numbers are compared bit-for-bit, not using the language's
- * operator==. This means that NaNs with matching representation will compare equal.
- * This behaviour is up for debate; see comments in the definition of mpack_tag_cmp().
- *
- * See mpack_tag_equal() for more information on when tags are considered equal.
- */
-int mpack_tag_cmp(mpack_tag_t left, mpack_tag_t right);
-
-/**
- * Compares two tags for equality. Tags are considered equal if the types are compatible
- * and the values (for non-compound types) are equal.
- *
- * The field width of variable-width fields is ignored (and in fact is not stored
- * in a tag), and positive numbers in signed integers are considered equal to their
- * unsigned counterparts. So for example the value 1 stored as a positive fixint
- * is equal to the value 1 stored in a 64-bit unsigned integer field.
- *
- * The "extension type" of an extension object is considered part of the value
- * and must match exactly.
- *
- * \warning Floating point numbers are compared bit-for-bit, not using the language's
- * operator==. This means that NaNs with matching representation will compare equal.
- * This behaviour is up for debate; see comments in the definition of mpack_tag_cmp().
- */
-MPACK_INLINE bool mpack_tag_equal(mpack_tag_t left, mpack_tag_t right) {
-    return mpack_tag_cmp(left, right) == 0;
-}
-
-#if MPACK_DEBUG && MPACK_STDIO
-/**
- * Generates a json-like debug description of the given tag into the given buffer.
- *
- * This is only available in debug mode, and only if stdio is available (since
- * it uses snprintf().) It's strictly for debugging purposes.
- *
- * The prefix is used to print the first few hexadecimal bytes of a bin or ext
- * type. Pass NULL if not a bin or ext.
- */
-void mpack_tag_debug_pseudo_json(mpack_tag_t tag, char* buffer, size_t buffer_size,
-        const char* prefix, size_t prefix_size);
-
-/**
- * Generates a debug string description of the given tag into the given buffer.
- *
- * This is only available in debug mode, and only if stdio is available (since
- * it uses snprintf().) It's strictly for debugging purposes.
- */
-void mpack_tag_debug_describe(mpack_tag_t tag, char* buffer, size_t buffer_size);
-
-/** @cond */
-
-/*
- * A callback function for printing pseudo-JSON for debugging purposes.
- *
- * @see mpack_node_print_callback
- */
-typedef void (*mpack_print_callback_t)(void* context, const char* data, size_t count);
-
-// helpers for printing debug output
-// i feel a bit like i'm re-implementing a buffered writer again...
-typedef struct mpack_print_t {
-    char* buffer;
-    size_t size;
-    size_t count;
-    mpack_print_callback_t callback;
-    void* context;
-} mpack_print_t;
-
-void mpack_print_append(mpack_print_t* print, const char* data, size_t count);
-
-MPACK_INLINE void mpack_print_append_cstr(mpack_print_t* print, const char* cstr) {
-    mpack_print_append(print, cstr, mpack_strlen(cstr));
-}
-
-void mpack_print_flush(mpack_print_t* print);
-
-void mpack_print_file_callback(void* context, const char* data, size_t count);
-
-/** @endcond */
-
-#endif
-
-/**
- * @}
- */
-
-/**
- * @name Deprecated Tag Generators
- * @{
- */
-
-/*
- * "make" has been added to their names to disambiguate them from the
- * value-fetching functions (e.g. mpack_tag_make_bool() vs
- * mpack_tag_bool_value().)
- *
- * The length and count for all compound types was the wrong sign (int32_t
- * instead of uint32_t.) These preserve the old behaviour; the new "make"
- * functions have the correct sign.
- */
-
-/** \deprecated Renamed to mpack_tag_make_nil(). */
-MPACK_INLINE mpack_tag_t mpack_tag_nil(void) {
-    return mpack_tag_make_nil();
-}
-
-/** \deprecated Renamed to mpack_tag_make_bool(). */
-MPACK_INLINE mpack_tag_t mpack_tag_bool(bool value) {
-    return mpack_tag_make_bool(value);
-}
-
-/** \deprecated Renamed to mpack_tag_make_true(). */
-MPACK_INLINE mpack_tag_t mpack_tag_true(void) {
-    return mpack_tag_make_true();
-}
-
-/** \deprecated Renamed to mpack_tag_make_false(). */
-MPACK_INLINE mpack_tag_t mpack_tag_false(void) {
-    return mpack_tag_make_false();
-}
-
-/** \deprecated Renamed to mpack_tag_make_int(). */
-MPACK_INLINE mpack_tag_t mpack_tag_int(int64_t value) {
-    return mpack_tag_make_int(value);
-}
-
-/** \deprecated Renamed to mpack_tag_make_uint(). */
-MPACK_INLINE mpack_tag_t mpack_tag_uint(uint64_t value) {
-    return mpack_tag_make_uint(value);
-}
-
-/** \deprecated Renamed to mpack_tag_make_float(). */
-MPACK_INLINE mpack_tag_t mpack_tag_float(float value) {
-    return mpack_tag_make_float(value);
-}
-
-/** \deprecated Renamed to mpack_tag_make_double(). */
-MPACK_INLINE mpack_tag_t mpack_tag_double(double value) {
-    return mpack_tag_make_double(value);
-}
-
-/** \deprecated Renamed to mpack_tag_make_array(). */
-MPACK_INLINE mpack_tag_t mpack_tag_array(int32_t count) {
-    return mpack_tag_make_array((uint32_t)count);
-}
-
-/** \deprecated Renamed to mpack_tag_make_map(). */
-MPACK_INLINE mpack_tag_t mpack_tag_map(int32_t count) {
-    return mpack_tag_make_map((uint32_t)count);
-}
-
-/** \deprecated Renamed to mpack_tag_make_str(). */
-MPACK_INLINE mpack_tag_t mpack_tag_str(int32_t length) {
-    return mpack_tag_make_str((uint32_t)length);
-}
-
-/** \deprecated Renamed to mpack_tag_make_bin(). */
-MPACK_INLINE mpack_tag_t mpack_tag_bin(int32_t length) {
-    return mpack_tag_make_bin((uint32_t)length);
-}
-
-#if MPACK_EXTENSIONS
-/** \deprecated Renamed to mpack_tag_make_ext(). */
-MPACK_INLINE mpack_tag_t mpack_tag_ext(int8_t exttype, int32_t length) {
-    return mpack_tag_make_ext(exttype, (uint32_t)length);
-}
-#endif
-
-/**
- * @}
- */
-
-/** @cond */
-
-/*
- * Helpers to perform unaligned network-endian loads and stores
- * at arbitrary addresses. Byte-swapping builtins are used if they
- * are available and if they improve performance.
- *
- * These will remain available in the public API so feel free to
- * use them for other purposes, but they are undocumented.
- */
-
-MPACK_INLINE uint8_t mpack_load_u8(const char* p) {
-    return (uint8_t)p[0];
-}
-
-MPACK_INLINE uint16_t mpack_load_u16(const char* p) {
-    #ifdef MPACK_NHSWAP16
-    uint16_t val;
-    mpack_memcpy(&val, p, sizeof(val));
-    return MPACK_NHSWAP16(val);
-    #else
-    return (uint16_t)((((uint16_t)(uint8_t)p[0]) << 8) |
-           ((uint16_t)(uint8_t)p[1]));
-    #endif
-}
-
-MPACK_INLINE uint32_t mpack_load_u32(const char* p) {
-    #ifdef MPACK_NHSWAP32
-    uint32_t val;
-    mpack_memcpy(&val, p, sizeof(val));
-    return MPACK_NHSWAP32(val);
-    #else
-    return (((uint32_t)(uint8_t)p[0]) << 24) |
-           (((uint32_t)(uint8_t)p[1]) << 16) |
-           (((uint32_t)(uint8_t)p[2]) <<  8) |
-            ((uint32_t)(uint8_t)p[3]);
-    #endif
-}
-
-MPACK_INLINE uint64_t mpack_load_u64(const char* p) {
-    #ifdef MPACK_NHSWAP64
-    uint64_t val;
-    mpack_memcpy(&val, p, sizeof(val));
-    return MPACK_NHSWAP64(val);
-    #else
-    return (((uint64_t)(uint8_t)p[0]) << 56) |
-           (((uint64_t)(uint8_t)p[1]) << 48) |
-           (((uint64_t)(uint8_t)p[2]) << 40) |
-           (((uint64_t)(uint8_t)p[3]) << 32) |
-           (((uint64_t)(uint8_t)p[4]) << 24) |
-           (((uint64_t)(uint8_t)p[5]) << 16) |
-           (((uint64_t)(uint8_t)p[6]) <<  8) |
-            ((uint64_t)(uint8_t)p[7]);
-    #endif
-}
-
-MPACK_INLINE void mpack_store_u8(char* p, uint8_t val) {
-    uint8_t* u = (uint8_t*)p;
-    u[0] = val;
-}
-
-MPACK_INLINE void mpack_store_u16(char* p, uint16_t val) {
-    #ifdef MPACK_NHSWAP16
-    val = MPACK_NHSWAP16(val);
-    mpack_memcpy(p, &val, sizeof(val));
-    #else
-    uint8_t* u = (uint8_t*)p;
-    u[0] = (uint8_t)((val >> 8) & 0xFF);
-    u[1] = (uint8_t)( val       & 0xFF);
-    #endif
-}
-
-MPACK_INLINE void mpack_store_u32(char* p, uint32_t val) {
-    #ifdef MPACK_NHSWAP32
-    val = MPACK_NHSWAP32(val);
-    mpack_memcpy(p, &val, sizeof(val));
-    #else
-    uint8_t* u = (uint8_t*)p;
-    u[0] = (uint8_t)((val >> 24) & 0xFF);
-    u[1] = (uint8_t)((val >> 16) & 0xFF);
-    u[2] = (uint8_t)((val >>  8) & 0xFF);
-    u[3] = (uint8_t)( val        & 0xFF);
-    #endif
-}
-
-MPACK_INLINE void mpack_store_u64(char* p, uint64_t val) {
-    #ifdef MPACK_NHSWAP64
-    val = MPACK_NHSWAP64(val);
-    mpack_memcpy(p, &val, sizeof(val));
-    #else
-    uint8_t* u = (uint8_t*)p;
-    u[0] = (uint8_t)((val >> 56) & 0xFF);
-    u[1] = (uint8_t)((val >> 48) & 0xFF);
-    u[2] = (uint8_t)((val >> 40) & 0xFF);
-    u[3] = (uint8_t)((val >> 32) & 0xFF);
-    u[4] = (uint8_t)((val >> 24) & 0xFF);
-    u[5] = (uint8_t)((val >> 16) & 0xFF);
-    u[6] = (uint8_t)((val >>  8) & 0xFF);
-    u[7] = (uint8_t)( val        & 0xFF);
-    #endif
-}
-
-MPACK_INLINE int8_t  mpack_load_i8 (const char* p) {return (int8_t) mpack_load_u8 (p);}
-MPACK_INLINE int16_t mpack_load_i16(const char* p) {return (int16_t)mpack_load_u16(p);}
-MPACK_INLINE int32_t mpack_load_i32(const char* p) {return (int32_t)mpack_load_u32(p);}
-MPACK_INLINE int64_t mpack_load_i64(const char* p) {return (int64_t)mpack_load_u64(p);}
-MPACK_INLINE void mpack_store_i8 (char* p, int8_t  val) {mpack_store_u8 (p, (uint8_t) val);}
-MPACK_INLINE void mpack_store_i16(char* p, int16_t val) {mpack_store_u16(p, (uint16_t)val);}
-MPACK_INLINE void mpack_store_i32(char* p, int32_t val) {mpack_store_u32(p, (uint32_t)val);}
-MPACK_INLINE void mpack_store_i64(char* p, int64_t val) {mpack_store_u64(p, (uint64_t)val);}
-
-MPACK_INLINE float mpack_load_float(const char* p) {
-    MPACK_CHECK_FLOAT_ORDER();
-    MPACK_STATIC_ASSERT(sizeof(float) == sizeof(uint32_t), "float is wrong size??");
-    union {
-        float f;
-        uint32_t u;
-    } v;
-    v.u = mpack_load_u32(p);
-    return v.f;
-}
-
-MPACK_INLINE double mpack_load_double(const char* p) {
-    MPACK_CHECK_FLOAT_ORDER();
-    MPACK_STATIC_ASSERT(sizeof(double) == sizeof(uint64_t), "double is wrong size??");
-    union {
-        double d;
-        uint64_t u;
-    } v;
-    v.u = mpack_load_u64(p);
-    return v.d;
-}
-
-MPACK_INLINE void mpack_store_float(char* p, float value) {
-    MPACK_CHECK_FLOAT_ORDER();
-    union {
-        float f;
-        uint32_t u;
-    } v;
-    v.f = value;
-    mpack_store_u32(p, v.u);
-}
-
-MPACK_INLINE void mpack_store_double(char* p, double value) {
-    MPACK_CHECK_FLOAT_ORDER();
-    union {
-        double d;
-        uint64_t u;
-    } v;
-    v.d = value;
-    mpack_store_u64(p, v.u);
-}
-
-/** @endcond */
-
-
-
-/** @cond */
-
-// Sizes in bytes for the various possible tags
-#define MPACK_TAG_SIZE_FIXUINT  1
-#define MPACK_TAG_SIZE_U8       2
-#define MPACK_TAG_SIZE_U16      3
-#define MPACK_TAG_SIZE_U32      5
-#define MPACK_TAG_SIZE_U64      9
-#define MPACK_TAG_SIZE_FIXINT   1
-#define MPACK_TAG_SIZE_I8       2
-#define MPACK_TAG_SIZE_I16      3
-#define MPACK_TAG_SIZE_I32      5
-#define MPACK_TAG_SIZE_I64      9
-#define MPACK_TAG_SIZE_FLOAT    5
-#define MPACK_TAG_SIZE_DOUBLE   9
-#define MPACK_TAG_SIZE_FIXARRAY 1
-#define MPACK_TAG_SIZE_ARRAY16  3
-#define MPACK_TAG_SIZE_ARRAY32  5
-#define MPACK_TAG_SIZE_FIXMAP   1
-#define MPACK_TAG_SIZE_MAP16    3
-#define MPACK_TAG_SIZE_MAP32    5
-#define MPACK_TAG_SIZE_FIXSTR   1
-#define MPACK_TAG_SIZE_STR8     2
-#define MPACK_TAG_SIZE_STR16    3
-#define MPACK_TAG_SIZE_STR32    5
-#define MPACK_TAG_SIZE_BIN8     2
-#define MPACK_TAG_SIZE_BIN16    3
-#define MPACK_TAG_SIZE_BIN32    5
-#define MPACK_TAG_SIZE_FIXEXT1  2
-#define MPACK_TAG_SIZE_FIXEXT2  2
-#define MPACK_TAG_SIZE_FIXEXT4  2
-#define MPACK_TAG_SIZE_FIXEXT8  2
-#define MPACK_TAG_SIZE_FIXEXT16 2
-#define MPACK_TAG_SIZE_EXT8     3
-#define MPACK_TAG_SIZE_EXT16    4
-#define MPACK_TAG_SIZE_EXT32    6
-
-// size in bytes for complete ext types
-#define MPACK_EXT_SIZE_TIMESTAMP4 (MPACK_TAG_SIZE_FIXEXT4 + 4)
-#define MPACK_EXT_SIZE_TIMESTAMP8 (MPACK_TAG_SIZE_FIXEXT8 + 8)
-#define MPACK_EXT_SIZE_TIMESTAMP12 (MPACK_TAG_SIZE_EXT8 + 12)
-
-/** @endcond */
-
-
-
-#if MPACK_READ_TRACKING || MPACK_WRITE_TRACKING
-/* Tracks the write state of compound elements (maps, arrays, */
-/* strings, binary blobs and extension types) */
-/** @cond */
-
-typedef struct mpack_track_element_t {
-    mpack_type_t type;
-    uint64_t left; // we need 64-bit because (2 * INT32_MAX) elements can be stored in a map
-} mpack_track_element_t;
-
-typedef struct mpack_track_t {
-    size_t count;
-    size_t capacity;
-    mpack_track_element_t* elements;
-} mpack_track_t;
-
-#if MPACK_INTERNAL
-mpack_error_t mpack_track_init(mpack_track_t* track);
-mpack_error_t mpack_track_grow(mpack_track_t* track);
-mpack_error_t mpack_track_push(mpack_track_t* track, mpack_type_t type, uint64_t count);
-mpack_error_t mpack_track_pop(mpack_track_t* track, mpack_type_t type);
-mpack_error_t mpack_track_element(mpack_track_t* track, bool read);
-mpack_error_t mpack_track_peek_element(mpack_track_t* track, bool read);
-mpack_error_t mpack_track_bytes(mpack_track_t* track, bool read, uint64_t count);
-mpack_error_t mpack_track_str_bytes_all(mpack_track_t* track, bool read, uint64_t count);
-mpack_error_t mpack_track_check_empty(mpack_track_t* track);
-mpack_error_t mpack_track_destroy(mpack_track_t* track, bool cancel);
-#endif
-
-/** @endcond */
-#endif
-
-
-
-#if MPACK_INTERNAL
-/** @cond */
-
-
-
-/* Miscellaneous string functions */
-
-/**
- * Returns true if the given UTF-8 string is valid.
- */
-bool mpack_utf8_check(const char* str, size_t bytes);
-
-/**
- * Returns true if the given UTF-8 string is valid and contains no null characters.
- */
-bool mpack_utf8_check_no_null(const char* str, size_t bytes);
-
-/**
- * Returns true if the given string has no null bytes.
- */
-bool mpack_str_check_no_null(const char* str, size_t bytes);
-
-
-
-/** @endcond */
-#endif
-
-
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-MPACK_HEADER_END
-
-#endif
-
-
-/* mpack/mpack-writer.h.h */
-
-/**
- * @file
- *
- * Declares the MPack Writer.
- */
-
-#ifndef MPACK_WRITER_H
-#define MPACK_WRITER_H 1
-
-/* #include "mpack-common.h" */
-
-MPACK_HEADER_START
-
-#if MPACK_WRITER
-
-#if MPACK_WRITE_TRACKING
-struct mpack_track_t;
-#endif
-
-/**
- * @defgroup writer Write API
- *
- * The MPack Write API encodes structured data of a fixed (hardcoded) schema to MessagePack.
- *
- * @{
- */
-
-/**
- * @def MPACK_WRITER_MINIMUM_BUFFER_SIZE
- *
- * The minimum buffer size for a writer with a flush function.
- */
-#define MPACK_WRITER_MINIMUM_BUFFER_SIZE 32
-
-/**
- * A buffered MessagePack encoder.
- *
- * The encoder wraps an existing buffer and, optionally, a flush function.
- * This allows efficiently encoding to an in-memory buffer or to a stream.
- *
- * All write operations are synchronous; they will block until the
- * data is fully written, or an error occurs.
- */
-typedef struct mpack_writer_t mpack_writer_t;
-
-/**
- * The MPack writer's flush function to flush the buffer to the output stream.
- * It should flag an appropriate error on the writer if flushing fails (usually
- * mpack_error_io or mpack_error_memory.)
- *
- * The specified context for callbacks is at writer->context.
- */
-typedef void (*mpack_writer_flush_t)(mpack_writer_t* writer, const char* buffer, size_t count);
-
-/**
- * An error handler function to be called when an error is flagged on
- * the writer.
- *
- * The error handler will only be called once on the first error flagged;
- * any subsequent writes and errors are ignored, and the writer is
- * permanently in that error state.
- *
- * MPack is safe against non-local jumps out of error handler callbacks.
- * This means you are allowed to longjmp or throw an exception (in C++,
- * Objective-C, or with SEH) out of this callback.
- *
- * Bear in mind when using longjmp that local non-volatile variables that
- * have changed are undefined when setjmp() returns, so you can't put the
- * writer on the stack in the same activation frame as the setjmp without
- * declaring it volatile.
- *
- * You must still eventually destroy the writer. It is not destroyed
- * automatically when an error is flagged. It is safe to destroy the
- * writer within this error callback, but you will either need to perform
- * a non-local jump, or store something in your context to identify
- * that the writer is destroyed since any future accesses to it cause
- * undefined behavior.
- */
-typedef void (*mpack_writer_error_t)(mpack_writer_t* writer, mpack_error_t error);
-
-/**
- * A teardown function to be called when the writer is destroyed.
- */
-typedef void (*mpack_writer_teardown_t)(mpack_writer_t* writer);
-
-/* Hide internals from documentation */
-/** @cond */
-
-struct mpack_writer_t {
-    #if MPACK_COMPATIBILITY
-    mpack_version_t version;          /* Version of the MessagePack spec to write */
-    #endif
-    mpack_writer_flush_t flush;       /* Function to write bytes to the output stream */
-    mpack_writer_error_t error_fn;    /* Function to call on error */
-    mpack_writer_teardown_t teardown; /* Function to teardown the context on destroy */
-    void* context;                    /* Context for writer callbacks */
-
-    char* buffer;         /* Byte buffer */
-    char* current;        /* Current position within the buffer */
-    char* end;            /* The end of the buffer */
-    mpack_error_t error;  /* Error state */
-
-    #if MPACK_WRITE_TRACKING
-    mpack_track_t track; /* Stack of map/array/str/bin/ext writes */
-    #endif
-
-    #ifdef MPACK_MALLOC
-    /* Reserved. You can use this space to allocate a custom
-     * context in order to reduce heap allocations. */
-    void* reserved[2];
-    #endif
-};
-
-#if MPACK_WRITE_TRACKING
-void mpack_writer_track_push(mpack_writer_t* writer, mpack_type_t type, uint64_t count);
-void mpack_writer_track_pop(mpack_writer_t* writer, mpack_type_t type);
-void mpack_writer_track_element(mpack_writer_t* writer);
-void mpack_writer_track_bytes(mpack_writer_t* writer, size_t count);
-#else
-MPACK_INLINE void mpack_writer_track_push(mpack_writer_t* writer, mpack_type_t type, uint64_t count) {
-    MPACK_UNUSED(writer);
-    MPACK_UNUSED(type);
-    MPACK_UNUSED(count);
-}
-MPACK_INLINE void mpack_writer_track_pop(mpack_writer_t* writer, mpack_type_t type) {
-    MPACK_UNUSED(writer);
-    MPACK_UNUSED(type);
-}
-MPACK_INLINE void mpack_writer_track_element(mpack_writer_t* writer) {
-    MPACK_UNUSED(writer);
-}
-MPACK_INLINE void mpack_writer_track_bytes(mpack_writer_t* writer, size_t count) {
-    MPACK_UNUSED(writer);
-    MPACK_UNUSED(count);
-}
-#endif
-
-/** @endcond */
-
-/**
- * @name Lifecycle Functions
- * @{
- */
-
-/**
- * Initializes an MPack writer with the given buffer. The writer
- * does not assume ownership of the buffer.
- *
- * Trying to write past the end of the buffer will result in mpack_error_too_big
- * unless a flush function is set with mpack_writer_set_flush(). To use the data
- * without flushing, call mpack_writer_buffer_used() to determine the number of
- * bytes written.
- *
- * @param writer The MPack writer.
- * @param buffer The buffer into which to write MessagePack data.
- * @param size The size of the buffer.
- */
-void mpack_writer_init(mpack_writer_t* writer, char* buffer, size_t size);
-
-#ifdef MPACK_MALLOC
-/**
- * Initializes an MPack writer using a growable buffer.
- *
- * The data is placed in the given data pointer if and when the writer
- * is destroyed without error. The data pointer is NULL during writing,
- * and will remain NULL if an error occurs.
- *
- * The allocated data must be freed with MPACK_FREE() (or simply free()
- * if MPack's allocator hasn't been customized.)
- *
- * @throws mpack_error_memory if the buffer fails to grow when
- * flushing.
- *
- * @param writer The MPack writer.
- * @param data Where to place the allocated data.
- * @param size Where to write the size of the data.
- */
-void mpack_writer_init_growable(mpack_writer_t* writer, char** data, size_t* size);
-#endif
-
-/**
- * Initializes an MPack writer directly into an error state. Use this if you
- * are writing a wrapper to mpack_writer_init() which can fail its setup.
- */
-void mpack_writer_init_error(mpack_writer_t* writer, mpack_error_t error);
-
-#if MPACK_STDIO
-/**
- * Initializes an MPack writer that writes to a file.
- *
- * @throws mpack_error_memory if allocation fails
- * @throws mpack_error_io if the file cannot be opened
- */
-void mpack_writer_init_filename(mpack_writer_t* writer, const char* filename);
-
-/**
- * Deprecated.
- *
- * \deprecated Renamed to mpack_writer_init_filename().
- */
-MPACK_INLINE void mpack_writer_init_file(mpack_writer_t* writer, const char* filename) {
-    mpack_writer_init_filename(writer, filename);
-}
-
-/**
- * Initializes an MPack writer that writes to a libc FILE. This can be used to
- * write to stdout or stderr, or to a file opened separately.
- *
- * @param writer The MPack writer.
- * @param stdfile The FILE.
- * @param close_when_done If true, fclose() will be called on the FILE when it
- *         is no longer needed. If false, the file will not be flushed or
- *         closed when writing is done.
- *
- * @note The writer is buffered. If you want to write other data to the FILE in
- *         between messages, you must flush it first.
- *
- * @see mpack_writer_flush_message
- */
-void mpack_writer_init_stdfile(mpack_writer_t* writer, FILE* stdfile, bool close_when_done);
-#endif
-
-/** @cond */
-
-#define mpack_writer_init_stack_line_ex(line, writer) \
-    char mpack_buf_##line[MPACK_STACK_SIZE]; \
-    mpack_writer_init(writer, mpack_buf_##line, sizeof(mpack_buf_##line))
-
-#define mpack_writer_init_stack_line(line, writer) \
-    mpack_writer_init_stack_line_ex(line, writer)
-
-/*
- * Initializes an MPack writer using stack space as a buffer. A flush function
- * should be added to the writer to flush the buffer.
- *
- * This is currently undocumented since it's not entirely useful on its own.
- */
-
-#define mpack_writer_init_stack(writer) \
-    mpack_writer_init_stack_line(__LINE__, (writer))
-
-/** @endcond */
-
-/**
- * Cleans up the MPack writer, flushing and closing the underlying stream,
- * if any. Returns the final error state of the writer.
- *
- * No flushing is performed if the writer is in an error state. The attached
- * teardown function is called whether or not the writer is in an error state.
- *
- * This will assert in tracking mode if the writer is not in an error
- * state and has any unclosed compound types. If you want to cancel
- * writing in the middle of a document, you need to flag an error on
- * the writer before destroying it (such as mpack_error_data).
- *
- * Note that a writer may raise an error and call your error handler during
- * the final flush. It is safe to longjmp or throw out of this error handler,
- * but if you do, the writer will not be destroyed, and the teardown function
- * will not be called. You can still get the writer's error state, and you
- * must call @ref mpack_writer_destroy() again. (The second call is guaranteed
- * not to call your error handler again since the writer is already in an error
- * state.)
- *
- * @see mpack_writer_set_error_handler
- * @see mpack_writer_set_flush
- * @see mpack_writer_set_teardown
- * @see mpack_writer_flag_error
- * @see mpack_error_data
- */
-mpack_error_t mpack_writer_destroy(mpack_writer_t* writer);
-
-/**
- * @}
- */
-
-/**
- * @name Configuration
- * @{
- */
-
-#if MPACK_COMPATIBILITY
-/**
- * Sets the version of the MessagePack spec that will be generated.
- *
- * This can be used to interface with older libraries that do not support
- * the newest MessagePack features (such as the @c str8 type.)
- *
- * @note This requires @ref MPACK_COMPATIBILITY.
- */
-MPACK_INLINE void mpack_writer_set_version(mpack_writer_t* writer, mpack_version_t version) {
-    writer->version = version;
-}
-#endif
-
-/**
- * Sets the custom pointer to pass to the writer callbacks, such as flush
- * or teardown.
- *
- * @param writer The MPack writer.
- * @param context User data to pass to the writer callbacks.
- *
- * @see mpack_writer_context()
- */
-MPACK_INLINE void mpack_writer_set_context(mpack_writer_t* writer, void* context) {
-    writer->context = context;
-}
-
-/**
- * Returns the custom context for writer callbacks.
- *
- * @see mpack_writer_set_context
- * @see mpack_writer_set_flush
- */
-MPACK_INLINE void* mpack_writer_context(mpack_writer_t* writer) {
-    return writer->context;
-}
-
-/**
- * Sets the flush function to write out the data when the buffer is full.
- *
- * If no flush function is used, trying to write past the end of the
- * buffer will result in mpack_error_too_big.
- *
- * This should normally be used with mpack_writer_set_context() to register
- * a custom pointer to pass to the flush function.
- *
- * @param writer The MPack writer.
- * @param flush The function to write out data from the buffer.
- *
- * @see mpack_writer_context()
- */
-void mpack_writer_set_flush(mpack_writer_t* writer, mpack_writer_flush_t flush);
-
-/**
- * Sets the error function to call when an error is flagged on the writer.
- *
- * This should normally be used with mpack_writer_set_context() to register
- * a custom pointer to pass to the error function.
- *
- * See the definition of mpack_writer_error_t for more information about
- * what you can do from an error callback.
- *
- * @see mpack_writer_error_t
- * @param writer The MPack writer.
- * @param error_fn The function to call when an error is flagged on the writer.
- */
-MPACK_INLINE void mpack_writer_set_error_handler(mpack_writer_t* writer, mpack_writer_error_t error_fn) {
-    writer->error_fn = error_fn;
-}
-
-/**
- * Sets the teardown function to call when the writer is destroyed.
- *
- * This should normally be used with mpack_writer_set_context() to register
- * a custom pointer to pass to the teardown function.
- *
- * @param writer The MPack writer.
- * @param teardown The function to call when the writer is destroyed.
- */
-MPACK_INLINE void mpack_writer_set_teardown(mpack_writer_t* writer, mpack_writer_teardown_t teardown) {
-    writer->teardown = teardown;
-}
-
-/**
- * @}
- */
-
-/**
- * @name Core Writer Functions
- * @{
- */
-
-/**
- * Flushes any buffered data to the underlying stream.
- *
- * If write tracking is enabled, this will break and flag @ref
- * mpack_error_bug if the writer has any open compound types, ensuring
- * that no compound types are still open. This prevents a "missing
- * finish" bug from causing a never-ending message.
- *
- * If the writer is connected to a socket and you are keeping it open,
- * you will want to call this after writing a message (or set of
- * messages) so that the data is actually sent.
- *
- * It is not necessary to call this if you are not keeping the writer
- * open afterwards. You can just call `mpack_writer_destroy()`, and it
- * will flush before cleaning up.
- *
- * This will assert if no flush function is assigned to the writer.
- */
-void mpack_writer_flush_message(mpack_writer_t* writer);
-
-/**
- * Returns the number of bytes currently stored in the buffer. This
- * may be less than the total number of bytes written if bytes have
- * been flushed to an underlying stream.
- */
-MPACK_INLINE size_t mpack_writer_buffer_used(mpack_writer_t* writer) {
-    return (size_t)(writer->current - writer->buffer);
-}
-
-/**
- * Returns the amount of space left in the buffer. This may be reset
- * after a write if bytes are flushed to an underlying stream.
- */
-MPACK_INLINE size_t mpack_writer_buffer_left(mpack_writer_t* writer) {
-    return (size_t)(writer->end - writer->current);
-}
-
-/**
- * Returns the (current) size of the buffer. This may change after a write if
- * the flush callback changes the buffer.
- */
-MPACK_INLINE size_t mpack_writer_buffer_size(mpack_writer_t* writer) {
-    return (size_t)(writer->end - writer->buffer);
-}
-
-/**
- * Places the writer in the given error state, calling the error callback if one
- * is set.
- *
- * This allows you to externally flag errors, for example if you are validating
- * data as you write it, or if you want to cancel writing in the middle of a
- * document. (The writer will assert if you try to destroy it without error and
- * with unclosed compound types. In this case you should flag mpack_error_data
- * before destroying it.)
- *
- * If the writer is already in an error state, this call is ignored and no
- * error callback is called.
- *
- * @see mpack_writer_destroy
- * @see mpack_error_data
- */
-void mpack_writer_flag_error(mpack_writer_t* writer, mpack_error_t error);
-
-/**
- * Queries the error state of the MPack writer.
- *
- * If a writer is in an error state, you should discard all data since the
- * last time the error flag was checked. The error flag cannot be cleared.
- */
-MPACK_INLINE mpack_error_t mpack_writer_error(mpack_writer_t* writer) {
-    return writer->error;
-}
-
-/**
- * Writes a MessagePack object header (an MPack Tag.)
- *
- * If the value is a map, array, string, binary or extension type, the
- * containing elements or bytes must be written separately and the
- * appropriate finish function must be called (as though one of the
- * mpack_start_*() functions was called.)
- *
- * @see mpack_write_bytes()
- * @see mpack_finish_map()
- * @see mpack_finish_array()
- * @see mpack_finish_str()
- * @see mpack_finish_bin()
- * @see mpack_finish_ext()
- * @see mpack_finish_type()
- */
-void mpack_write_tag(mpack_writer_t* writer, mpack_tag_t tag);
-
-/**
- * @}
- */
-
-/**
- * @name Integers
- * @{
- */
-
-/** Writes an 8-bit integer in the most efficient packing available. */
-void mpack_write_i8(mpack_writer_t* writer, int8_t value);
-
-/** Writes a 16-bit integer in the most efficient packing available. */
-void mpack_write_i16(mpack_writer_t* writer, int16_t value);
-
-/** Writes a 32-bit integer in the most efficient packing available. */
-void mpack_write_i32(mpack_writer_t* writer, int32_t value);
-
-/** Writes a 64-bit integer in the most efficient packing available. */
-void mpack_write_i64(mpack_writer_t* writer, int64_t value);
-
-/** Writes an integer in the most efficient packing available. */
-MPACK_INLINE void mpack_write_int(mpack_writer_t* writer, int64_t value) {
-    mpack_write_i64(writer, value);
-}
-
-/** Writes an 8-bit unsigned integer in the most efficient packing available. */
-void mpack_write_u8(mpack_writer_t* writer, uint8_t value);
-
-/** Writes an 16-bit unsigned integer in the most efficient packing available. */
-void mpack_write_u16(mpack_writer_t* writer, uint16_t value);
-
-/** Writes an 32-bit unsigned integer in the most efficient packing available. */
-void mpack_write_u32(mpack_writer_t* writer, uint32_t value);
-
-/** Writes an 64-bit unsigned integer in the most efficient packing available. */
-void mpack_write_u64(mpack_writer_t* writer, uint64_t value);
-
-/** Writes an unsigned integer in the most efficient packing available. */
-MPACK_INLINE void mpack_write_uint(mpack_writer_t* writer, uint64_t value) {
-    mpack_write_u64(writer, value);
-}
-
-/**
- * @}
- */
-
-/**
- * @name Other Basic Types
- * @{
- */
-
-/** Writes a float. */
-void mpack_write_float(mpack_writer_t* writer, float value);
-
-/** Writes a double. */
-void mpack_write_double(mpack_writer_t* writer, double value);
-
-/** Writes a boolean. */
-void mpack_write_bool(mpack_writer_t* writer, bool value);
-
-/** Writes a boolean with value true. */
-void mpack_write_true(mpack_writer_t* writer);
-
-/** Writes a boolean with value false. */
-void mpack_write_false(mpack_writer_t* writer);
-
-/** Writes a nil. */
-void mpack_write_nil(mpack_writer_t* writer);
-
-/** Write a pre-encoded messagepack object */
-void mpack_write_object_bytes(mpack_writer_t* writer, const char* data, size_t bytes);
-
-#if MPACK_EXTENSIONS
-/**
- * Writes a timestamp.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- *
- * @param writer The writer
- * @param seconds The (signed) number of seconds since 1970-01-01T00:00:00Z.
- * @param nanoseconds The additional number of nanoseconds from 0 to 999,999,999 inclusive.
- */
-void mpack_write_timestamp(mpack_writer_t* writer, int64_t seconds, uint32_t nanoseconds);
-
-/**
- * Writes a timestamp with the given number of seconds (and zero nanoseconds).
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- *
- * @param writer The writer
- * @param seconds The (signed) number of seconds since 1970-01-01T00:00:00Z.
- */
-MPACK_INLINE void mpack_write_timestamp_seconds(mpack_writer_t* writer, int64_t seconds) {
-    mpack_write_timestamp(writer, seconds, 0);
-}
-
-/**
- * Writes a timestamp.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- */
-MPACK_INLINE void mpack_write_timestamp_struct(mpack_writer_t* writer, mpack_timestamp_t timestamp) {
-    mpack_write_timestamp(writer, timestamp.seconds, timestamp.nanoseconds);
-}
-#endif
-
-/**
- * @}
- */
-
-/**
- * @name Map and Array Functions
- * @{
- */
-
-/**
- * Opens an array.
- *
- * `count` elements must follow, and mpack_finish_array() must be called
- * when done.
- *
- * @see mpack_finish_array()
- */
-void mpack_start_array(mpack_writer_t* writer, uint32_t count);
-
-/**
- * Opens a map.
- *
- * `count * 2` elements must follow, and mpack_finish_map() must be called
- * when done.
- *
- * Remember that while map elements in MessagePack are implicitly ordered,
- * they are not ordered in JSON. If you need elements to be read back
- * in the order they are written, consider use an array instead.
- *
- * @see mpack_finish_map()
- */
-void mpack_start_map(mpack_writer_t* writer, uint32_t count);
-
-/**
- * Finishes writing an array.
- *
- * This should be called only after a corresponding call to mpack_start_array()
- * and after the array contents are written.
- *
- * This will track writes to ensure that the correct number of elements are written.
- *
- * @see mpack_start_array()
- */
-MPACK_INLINE void mpack_finish_array(mpack_writer_t* writer) {
-    mpack_writer_track_pop(writer, mpack_type_array);
-}
-
-/**
- * Finishes writing a map.
- *
- * This should be called only after a corresponding call to mpack_start_map()
- * and after the map contents are written.
- *
- * This will track writes to ensure that the correct number of elements are written.
- *
- * @see mpack_start_map()
- */
-MPACK_INLINE void mpack_finish_map(mpack_writer_t* writer) {
-    mpack_writer_track_pop(writer, mpack_type_map);
-}
-
-/**
- * @}
- */
-
-/**
- * @name Data Helpers
- * @{
- */
-
-/**
- * Writes a string.
- *
- * To stream a string in chunks, use mpack_start_str() instead.
- *
- * MPack does not care about the underlying encoding, but UTF-8 is highly
- * recommended, especially for compatibility with JSON. You should consider
- * calling mpack_write_utf8() instead, especially if you will be reading
- * it back as UTF-8.
- *
- * You should not call mpack_finish_str() after calling this; this
- * performs both start and finish.
- */
-void mpack_write_str(mpack_writer_t* writer, const char* str, uint32_t length);
-
-/**
- * Writes a string, ensuring that it is valid UTF-8.
- *
- * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or
- * WTF-8. Only pure UTF-8 is allowed.
- *
- * You should not call mpack_finish_str() after calling this; this
- * performs both start and finish.
- *
- * @throws mpack_error_invalid if the string is not valid UTF-8
- */
-void mpack_write_utf8(mpack_writer_t* writer, const char* str, uint32_t length);
-
-/**
- * Writes a null-terminated string. (The null-terminator is not written.)
- *
- * MPack does not care about the underlying encoding, but UTF-8 is highly
- * recommended, especially for compatibility with JSON. You should consider
- * calling mpack_write_utf8_cstr() instead, especially if you will be reading
- * it back as UTF-8.
- *
- * You should not call mpack_finish_str() after calling this; this
- * performs both start and finish.
- */
-void mpack_write_cstr(mpack_writer_t* writer, const char* cstr);
-
-/**
- * Writes a null-terminated string, or a nil node if the given cstr pointer
- * is NULL. (The null-terminator is not written.)
- *
- * MPack does not care about the underlying encoding, but UTF-8 is highly
- * recommended, especially for compatibility with JSON. You should consider
- * calling mpack_write_utf8_cstr_or_nil() instead, especially if you will
- * be reading it back as UTF-8.
- *
- * You should not call mpack_finish_str() after calling this; this
- * performs both start and finish.
- */
-void mpack_write_cstr_or_nil(mpack_writer_t* writer, const char* cstr);
-
-/**
- * Writes a null-terminated string, ensuring that it is valid UTF-8. (The
- * null-terminator is not written.)
- *
- * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or
- * WTF-8. Only pure UTF-8 is allowed.
- *
- * You should not call mpack_finish_str() after calling this; this
- * performs both start and finish.
- *
- * @throws mpack_error_invalid if the string is not valid UTF-8
- */
-void mpack_write_utf8_cstr(mpack_writer_t* writer, const char* cstr);
-
-/**
- * Writes a null-terminated string ensuring that it is valid UTF-8, or
- * writes nil if the given cstr pointer is NULL. (The null-terminator
- * is not written.)
- *
- * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or
- * WTF-8. Only pure UTF-8 is allowed.
- *
- * You should not call mpack_finish_str() after calling this; this
- * performs both start and finish.
- *
- * @throws mpack_error_invalid if the string is not valid UTF-8
- */
-void mpack_write_utf8_cstr_or_nil(mpack_writer_t* writer, const char* cstr);
-
-/**
- * Writes a binary blob.
- *
- * To stream a binary blob in chunks, use mpack_start_bin() instead.
- *
- * You should not call mpack_finish_bin() after calling this; this
- * performs both start and finish.
- */
-void mpack_write_bin(mpack_writer_t* writer, const char* data, uint32_t count);
-
-#if MPACK_EXTENSIONS
-/**
- * Writes an extension type.
- *
- * To stream an extension blob in chunks, use mpack_start_ext() instead.
- *
- * Extension types [0, 127] are available for application-specific types. Extension
- * types [-128, -1] are reserved for future extensions of MessagePack.
- *
- * You should not call mpack_finish_ext() after calling this; this
- * performs both start and finish.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- */
-void mpack_write_ext(mpack_writer_t* writer, int8_t exttype, const char* data, uint32_t count);
-#endif
-
-/**
- * @}
- */
-
-/**
- * @name Chunked Data Functions
- * @{
- */
-
-/**
- * Opens a string. `count` bytes should be written with calls to
- * mpack_write_bytes(), and mpack_finish_str() should be called
- * when done.
- *
- * To write an entire string at once, use mpack_write_str() or
- * mpack_write_cstr() instead.
- *
- * MPack does not care about the underlying encoding, but UTF-8 is highly
- * recommended, especially for compatibility with JSON.
- */
-void mpack_start_str(mpack_writer_t* writer, uint32_t count);
-
-/**
- * Opens a binary blob. `count` bytes should be written with calls to
- * mpack_write_bytes(), and mpack_finish_bin() should be called
- * when done.
- */
-void mpack_start_bin(mpack_writer_t* writer, uint32_t count);
-
-#if MPACK_EXTENSIONS
-/**
- * Opens an extension type. `count` bytes should be written with calls
- * to mpack_write_bytes(), and mpack_finish_ext() should be called
- * when done.
- *
- * Extension types [0, 127] are available for application-specific types. Extension
- * types [-128, -1] are reserved for future extensions of MessagePack.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- */
-void mpack_start_ext(mpack_writer_t* writer, int8_t exttype, uint32_t count);
-#endif
-
-/**
- * Writes a portion of bytes for a string, binary blob or extension type which
- * was opened by mpack_write_tag() or one of the mpack_start_*() functions.
- *
- * This can be called multiple times to write the data in chunks, as long as
- * the total amount of bytes written matches the count given when the compound
- * type was started.
- *
- * The corresponding mpack_finish_*() function must be called when done.
- *
- * To write an entire string, binary blob or extension type at
- * once, use one of the mpack_write_*() functions instead.
- *
- * @see mpack_write_tag()
- * @see mpack_start_str()
- * @see mpack_start_bin()
- * @see mpack_start_ext()
- * @see mpack_finish_str()
- * @see mpack_finish_bin()
- * @see mpack_finish_ext()
- * @see mpack_finish_type()
- */
-void mpack_write_bytes(mpack_writer_t* writer, const char* data, size_t count);
-
-/**
- * Finishes writing a string.
- *
- * This should be called only after a corresponding call to mpack_start_str()
- * and after the string bytes are written with mpack_write_bytes().
- *
- * This will track writes to ensure that the correct number of elements are written.
- *
- * @see mpack_start_str()
- * @see mpack_write_bytes()
- */
-MPACK_INLINE void mpack_finish_str(mpack_writer_t* writer) {
-    mpack_writer_track_pop(writer, mpack_type_str);
-}
-
-/**
- * Finishes writing a binary blob.
- *
- * This should be called only after a corresponding call to mpack_start_bin()
- * and after the binary bytes are written with mpack_write_bytes().
- *
- * This will track writes to ensure that the correct number of bytes are written.
- *
- * @see mpack_start_bin()
- * @see mpack_write_bytes()
- */
-MPACK_INLINE void mpack_finish_bin(mpack_writer_t* writer) {
-    mpack_writer_track_pop(writer, mpack_type_bin);
-}
-
-#if MPACK_EXTENSIONS
-/**
- * Finishes writing an extended type binary data blob.
- *
- * This should be called only after a corresponding call to mpack_start_bin()
- * and after the binary bytes are written with mpack_write_bytes().
- *
- * This will track writes to ensure that the correct number of bytes are written.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- *
- * @see mpack_start_ext()
- * @see mpack_write_bytes()
- */
-MPACK_INLINE void mpack_finish_ext(mpack_writer_t* writer) {
-    mpack_writer_track_pop(writer, mpack_type_ext);
-}
-#endif
-
-/**
- * Finishes writing the given compound type.
- *
- * This will track writes to ensure that the correct number of elements
- * or bytes are written.
- *
- * This can be called with the appropriate type instead the corresponding
- * mpack_finish_*() function if you want to finish a dynamic type.
- */
-MPACK_INLINE void mpack_finish_type(mpack_writer_t* writer, mpack_type_t type) {
-    mpack_writer_track_pop(writer, type);
-}
-
-/**
- * @}
- */
-
-#if MPACK_WRITER && MPACK_HAS_GENERIC && !defined(__cplusplus)
-
-/**
- * @name Type-Generic Writers
- * @{
- */
-
-/**
- * @def mpack_write(writer, value)
- *
- * Type-generic writer for primitive types.
- *
- * The compiler will dispatch to an appropriate write function based
- * on the type of the @a value parameter.
- *
- * @note This requires C11 `_Generic` support. (A set of inline overloads
- * are used in C++ to provide the same functionality.)
- *
- * @warning In C11, the indentifiers `true`, `false` and `NULL` are
- * all of type `int`, not `bool` or `void*`! They will emit unexpected
- * types when passed uncast, so be careful when using them.
- */
-#define mpack_write(writer, value) \
-    _Generic(((void)0, value),                      \
-              int8_t: mpack_write_i8,               \
-             int16_t: mpack_write_i16,              \
-             int32_t: mpack_write_i32,              \
-             int64_t: mpack_write_i64,              \
-             uint8_t: mpack_write_u8,               \
-            uint16_t: mpack_write_u16,              \
-            uint32_t: mpack_write_u32,              \
-            uint64_t: mpack_write_u64,              \
-                bool: mpack_write_bool,             \
-               float: mpack_write_float,            \
-              double: mpack_write_double,           \
-              char *: mpack_write_cstr_or_nil,      \
-        const char *: mpack_write_cstr_or_nil       \
-    )(writer, value)
-
-/**
- * @def mpack_write_kv(writer, key, value)
- *
- * Type-generic writer for key-value pairs of null-terminated string
- * keys and primitive values.
- *
- * @warning @a writer may be evaluated multiple times.
- *
- * @warning In C11, the indentifiers `true`, `false` and `NULL` are
- * all of type `int`, not `bool` or `void*`! They will emit unexpected
- * types when passed uncast, so be careful when using them.
- *
- * @param writer The writer.
- * @param key A null-terminated C string.
- * @param value A primitive type supported by mpack_write().
- */
-#define mpack_write_kv(writer, key, value) do {     \
-    mpack_write_cstr(writer, key);                  \
-    mpack_write(writer, value);                     \
-} while (0)
-
-/**
- * @}
- */
-
-#endif
-
-/**
- * @}
- */
-
-#endif
-
-MPACK_HEADER_END
-
-#if defined(__cplusplus) || defined(MPACK_DOXYGEN)
-
-/*
- * C++ generic writers for primitive values
- *
- * These currently sit outside of MPACK_HEADER_END because it defines
- * extern "C". They'll be moved to a C++-specific header soon.
- */
-
-#ifdef MPACK_DOXYGEN
-#undef mpack_write
-#undef mpack_write_kv
-#endif
-
-MPACK_INLINE void mpack_write(mpack_writer_t* writer, int8_t value) {
-    mpack_write_i8(writer, value);
-}
-
-MPACK_INLINE void mpack_write(mpack_writer_t* writer, int16_t value) {
-    mpack_write_i16(writer, value);
-}
-
-MPACK_INLINE void mpack_write(mpack_writer_t* writer, int32_t value) {
-    mpack_write_i32(writer, value);
-}
-
-MPACK_INLINE void mpack_write(mpack_writer_t* writer, int64_t value) {
-    mpack_write_i64(writer, value);
-}
-
-MPACK_INLINE void mpack_write(mpack_writer_t* writer, uint8_t value) {
-    mpack_write_u8(writer, value);
-}
-
-MPACK_INLINE void mpack_write(mpack_writer_t* writer, uint16_t value) {
-    mpack_write_u16(writer, value);
-}
-
-MPACK_INLINE void mpack_write(mpack_writer_t* writer, uint32_t value) {
-    mpack_write_u32(writer, value);
-}
-
-MPACK_INLINE void mpack_write(mpack_writer_t* writer, uint64_t value) {
-    mpack_write_u64(writer, value);
-}
-
-MPACK_INLINE void mpack_write(mpack_writer_t* writer, bool value) {
-    mpack_write_bool(writer, value);
-}
-
-MPACK_INLINE void mpack_write(mpack_writer_t* writer, float value) {
-    mpack_write_float(writer, value);
-}
-
-MPACK_INLINE void mpack_write(mpack_writer_t* writer, double value) {
-    mpack_write_double(writer, value);
-}
-
-MPACK_INLINE void mpack_write(mpack_writer_t* writer, char *value) {
-    mpack_write_cstr_or_nil(writer, value);
-}
-
-MPACK_INLINE void mpack_write(mpack_writer_t* writer, const char *value) {
-    mpack_write_cstr_or_nil(writer, value);
-}
-
-/* C++ generic write for key-value pairs */
-
-MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, int8_t value) {
-    mpack_write_cstr(writer, key);
-    mpack_write_i8(writer, value);
-}
-
-MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, int16_t value) {
-    mpack_write_cstr(writer, key);
-    mpack_write_i16(writer, value);
-}
-
-MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, int32_t value) {
-    mpack_write_cstr(writer, key);
-    mpack_write_i32(writer, value);
-}
-
-MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, int64_t value) {
-    mpack_write_cstr(writer, key);
-    mpack_write_i64(writer, value);
-}
-
-MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, uint8_t value) {
-    mpack_write_cstr(writer, key);
-    mpack_write_u8(writer, value);
-}
-
-MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, uint16_t value) {
-    mpack_write_cstr(writer, key);
-    mpack_write_u16(writer, value);
-}
-
-MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, uint32_t value) {
-    mpack_write_cstr(writer, key);
-    mpack_write_u32(writer, value);
-}
-
-MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, uint64_t value) {
-    mpack_write_cstr(writer, key);
-    mpack_write_u64(writer, value);
-}
-
-MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, bool value) {
-    mpack_write_cstr(writer, key);
-    mpack_write_bool(writer, value);
-}
-
-MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, float value) {
-    mpack_write_cstr(writer, key);
-    mpack_write_float(writer, value);
-}
-
-MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, double value) {
-    mpack_write_cstr(writer, key);
-    mpack_write_double(writer, value);
-}
-
-MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, char *value) {
-    mpack_write_cstr(writer, key);
-    mpack_write_cstr_or_nil(writer, value);
-}
-
-MPACK_INLINE void mpack_write_kv(mpack_writer_t* writer, const char *key, const char *value) {
-    mpack_write_cstr(writer, key);
-    mpack_write_cstr_or_nil(writer, value);
-}
-#endif /* __cplusplus */
-
-#endif
-
-/* mpack/mpack-reader.h.h */
-
-/**
- * @file
- *
- * Declares the core MPack Tag Reader.
- */
-
-#ifndef MPACK_READER_H
-#define MPACK_READER_H 1
-
-/* #include "mpack-common.h" */
-
-MPACK_HEADER_START
-
-#if MPACK_READER
-
-#if MPACK_READ_TRACKING
-struct mpack_track_t;
-#endif
-
-// The denominator to determine whether a read is a small
-// fraction of the buffer size.
-#define MPACK_READER_SMALL_FRACTION_DENOMINATOR 32
-
-/**
- * @defgroup reader Reader API
- *
- * The MPack Reader API contains functions for imperatively reading dynamically
- * typed data from a MessagePack stream.
- *
- * See @ref docs/reader.md for examples.
- *
- * @note If you are not writing code for an embedded device (or otherwise do
- * not need maximum performance with minimal memory usage), you should not use
- * this. You probably want to use the @link node Node API@endlink instead.
- *
- * This forms the basis of the @link expect Expect API@endlink, which can be
- * used to interpret the stream of elements in expected types and value ranges.
- *
- * @{
- */
-
-/**
- * @def MPACK_READER_MINIMUM_BUFFER_SIZE
- *
- * The minimum buffer size for a reader with a fill function.
- */
-#define MPACK_READER_MINIMUM_BUFFER_SIZE 32
-
-/**
- * A buffered MessagePack decoder.
- *
- * The decoder wraps an existing buffer and, optionally, a fill function.
- * This allows efficiently decoding data from existing memory buffers, files,
- * streams, etc.
- *
- * All read operations are synchronous; they will block until the
- * requested data is fully read, or an error occurs.
- *
- * This structure is opaque; its fields should not be accessed outside
- * of MPack.
- */
-typedef struct mpack_reader_t mpack_reader_t;
-
-/**
- * The MPack reader's fill function. It should fill the buffer with at
- * least one byte and at most the given @c count, returning the number
- * of bytes written to the buffer.
- *
- * In case of error, it should flag an appropriate error on the reader
- * (usually @ref mpack_error_io), or simply return zero. If zero is
- * returned, mpack_error_io is raised.
- *
- * @note When reading from a stream, you should only copy and return
- * the bytes that are immediately available. It is always safe to return
- * less than the requested count as long as some non-zero number of bytes
- * are read; if more bytes are needed, the read function will simply be
- * called again.
- *
- * @see mpack_reader_context()
- */
-typedef size_t (*mpack_reader_fill_t)(mpack_reader_t* reader, char* buffer, size_t count);
-
-/**
- * The MPack reader's skip function. It should discard the given number
- * of bytes from the source (for example by seeking forward.)
- *
- * In case of error, it should flag an appropriate error on the reader.
- *
- * @see mpack_reader_context()
- */
-typedef void (*mpack_reader_skip_t)(mpack_reader_t* reader, size_t count);
-
-/**
- * An error handler function to be called when an error is flagged on
- * the reader.
- *
- * The error handler will only be called once on the first error flagged;
- * any subsequent reads and errors are ignored, and the reader is
- * permanently in that error state.
- *
- * MPack is safe against non-local jumps out of error handler callbacks.
- * This means you are allowed to longjmp or throw an exception (in C++,
- * Objective-C, or with SEH) out of this callback.
- *
- * Bear in mind when using longjmp that local non-volatile variables that
- * have changed are undefined when setjmp() returns, so you can't put the
- * reader on the stack in the same activation frame as the setjmp without
- * declaring it volatile.
- *
- * You must still eventually destroy the reader. It is not destroyed
- * automatically when an error is flagged. It is safe to destroy the
- * reader within this error callback, but you will either need to perform
- * a non-local jump, or store something in your context to identify
- * that the reader is destroyed since any future accesses to it cause
- * undefined behavior.
- */
-typedef void (*mpack_reader_error_t)(mpack_reader_t* reader, mpack_error_t error);
-
-/**
- * A teardown function to be called when the reader is destroyed.
- */
-typedef void (*mpack_reader_teardown_t)(mpack_reader_t* reader);
-
-/* Hide internals from documentation */
-/** @cond */
-
-struct mpack_reader_t {
-    void* context;                    /* Context for reader callbacks */
-    mpack_reader_fill_t fill;         /* Function to read bytes into the buffer */
-    mpack_reader_error_t error_fn;    /* Function to call on error */
-    mpack_reader_teardown_t teardown; /* Function to teardown the context on destroy */
-    mpack_reader_skip_t skip;         /* Function to skip bytes from the source */
-
-    char* buffer;       /* Writeable byte buffer */
-    size_t size;        /* Size of the buffer */
-
-    const char* data;   /* Current data pointer (in the buffer, if it is used) */
-    const char* end;    /* The end of available data (in the buffer, if it is used) */
-
-    mpack_error_t error;  /* Error state */
-
-    #if MPACK_READ_TRACKING
-    mpack_track_t track; /* Stack of map/array/str/bin/ext reads */
-    #endif
-};
-
-/** @endcond */
-
-/**
- * @name Lifecycle Functions
- * @{
- */
-
-/**
- * Initializes an MPack reader with the given buffer. The reader does
- * not assume ownership of the buffer, but the buffer must be writeable
- * if a fill function will be used to refill it.
- *
- * @param reader The MPack reader.
- * @param buffer The buffer with which to read MessagePack data.
- * @param size The size of the buffer.
- * @param count The number of bytes already in the buffer.
- */
-void mpack_reader_init(mpack_reader_t* reader, char* buffer, size_t size, size_t count);
-
-/**
- * Initializes an MPack reader directly into an error state. Use this if you
- * are writing a wrapper to mpack_reader_init() which can fail its setup.
- */
-void mpack_reader_init_error(mpack_reader_t* reader, mpack_error_t error);
-
-/**
- * Initializes an MPack reader to parse a pre-loaded contiguous chunk of data. The
- * reader does not assume ownership of the data.
- *
- * @param reader The MPack reader.
- * @param data The data to parse.
- * @param count The number of bytes pointed to by data.
- */
-void mpack_reader_init_data(mpack_reader_t* reader, const char* data, size_t count);
-
-#if MPACK_STDIO
-/**
- * Initializes an MPack reader that reads from a file.
- *
- * The file will be automatically opened and closed by the reader.
- */
-void mpack_reader_init_filename(mpack_reader_t* reader, const char* filename);
-
-/**
- * Deprecated.
- *
- * \deprecated Renamed to mpack_reader_init_filename().
- */
-MPACK_INLINE void mpack_reader_init_file(mpack_reader_t* reader, const char* filename) {
-    mpack_reader_init_filename(reader, filename);
-}
-
-/**
- * Initializes an MPack reader that reads from a libc FILE. This can be used to
- * read from stdin, or from a file opened separately.
- *
- * @param reader The MPack reader.
- * @param stdfile The FILE.
- * @param close_when_done If true, fclose() will be called on the FILE when it
- *         is no longer needed. If false, the file will not be closed when
- *         reading is done.
- *
- * @warning The reader is buffered. It will read data in advance of parsing it,
- * and it may read more data than it parsed. See mpack_reader_remaining() to
- * access the extra data.
- */
-void mpack_reader_init_stdfile(mpack_reader_t* reader, FILE* stdfile, bool close_when_done);
-#endif
-
-/**
- * @def mpack_reader_init_stack(reader)
- * @hideinitializer
- *
- * Initializes an MPack reader using stack space as a buffer. A fill function
- * should be added to the reader to fill the buffer.
- *
- * @see mpack_reader_set_fill
- */
-
-/** @cond */
-#define mpack_reader_init_stack_line_ex(line, reader) \
-    char mpack_buf_##line[MPACK_STACK_SIZE]; \
-    mpack_reader_init((reader), mpack_buf_##line, sizeof(mpack_buf_##line), 0)
-
-#define mpack_reader_init_stack_line(line, reader) \
-    mpack_reader_init_stack_line_ex(line, reader)
-/** @endcond */
-
-#define mpack_reader_init_stack(reader) \
-    mpack_reader_init_stack_line(__LINE__, (reader))
-
-/**
- * Cleans up the MPack reader, ensuring that all compound elements
- * have been completely read. Returns the final error state of the
- * reader.
- *
- * This will assert in tracking mode if the reader is not in an error
- * state and has any incomplete reads. If you want to cancel reading
- * in the middle of a document, you need to flag an error on the reader
- * before destroying it (such as mpack_error_data).
- *
- * @see mpack_read_tag()
- * @see mpack_reader_flag_error()
- * @see mpack_error_data
- */
-mpack_error_t mpack_reader_destroy(mpack_reader_t* reader);
-
-/**
- * @}
- */
-
-/**
- * @name Callbacks
- * @{
- */
-
-/**
- * Sets the custom pointer to pass to the reader callbacks, such as fill
- * or teardown.
- *
- * @param reader The MPack reader.
- * @param context User data to pass to the reader callbacks.
- *
- * @see mpack_reader_context()
- */
-MPACK_INLINE void mpack_reader_set_context(mpack_reader_t* reader, void* context) {
-    reader->context = context;
-}
-
-/**
- * Returns the custom context for reader callbacks.
- *
- * @see mpack_reader_set_context
- * @see mpack_reader_set_fill
- * @see mpack_reader_set_skip
- */
-MPACK_INLINE void* mpack_reader_context(mpack_reader_t* reader) {
-    return reader->context;
-}
-
-/**
- * Sets the fill function to refill the data buffer when it runs out of data.
- *
- * If no fill function is used, truncated MessagePack data results in
- * mpack_error_invalid (since the buffer is assumed to contain a
- * complete MessagePack object.)
- *
- * If a fill function is used, truncated MessagePack data usually
- * results in mpack_error_io (since the fill function fails to get
- * the missing data.)
- *
- * This should normally be used with mpack_reader_set_context() to register
- * a custom pointer to pass to the fill function.
- *
- * @param reader The MPack reader.
- * @param fill The function to fetch additional data into the buffer.
- */
-void mpack_reader_set_fill(mpack_reader_t* reader, mpack_reader_fill_t fill);
-
-/**
- * Sets the skip function to discard bytes from the source stream.
- *
- * It's not necessary to implement this function. If the stream is not
- * seekable, don't set a skip callback. The reader will fall back to
- * using the fill function instead.
- *
- * This should normally be used with mpack_reader_set_context() to register
- * a custom pointer to pass to the skip function.
- *
- * The skip function is ignored in size-optimized builds to reduce code
- * size. Data will be skipped with the fill function when necessary.
- *
- * @param reader The MPack reader.
- * @param skip The function to discard bytes from the source stream.
- */
-void mpack_reader_set_skip(mpack_reader_t* reader, mpack_reader_skip_t skip);
-
-/**
- * Sets the error function to call when an error is flagged on the reader.
- *
- * This should normally be used with mpack_reader_set_context() to register
- * a custom pointer to pass to the error function.
- *
- * See the definition of mpack_reader_error_t for more information about
- * what you can do from an error callback.
- *
- * @see mpack_reader_error_t
- * @param reader The MPack reader.
- * @param error_fn The function to call when an error is flagged on the reader.
- */
-MPACK_INLINE void mpack_reader_set_error_handler(mpack_reader_t* reader, mpack_reader_error_t error_fn) {
-    reader->error_fn = error_fn;
-}
-
-/**
- * Sets the teardown function to call when the reader is destroyed.
- *
- * This should normally be used with mpack_reader_set_context() to register
- * a custom pointer to pass to the teardown function.
- *
- * @param reader The MPack reader.
- * @param teardown The function to call when the reader is destroyed.
- */
-MPACK_INLINE void mpack_reader_set_teardown(mpack_reader_t* reader, mpack_reader_teardown_t teardown) {
-    reader->teardown = teardown;
-}
-
-/**
- * @}
- */
-
-/**
- * @name Core Reader Functions
- * @{
- */
-
-/**
- * Queries the error state of the MPack reader.
- *
- * If a reader is in an error state, you should discard all data since the
- * last time the error flag was checked. The error flag cannot be cleared.
- */
-MPACK_INLINE mpack_error_t mpack_reader_error(mpack_reader_t* reader) {
-    return reader->error;
-}
-
-/**
- * Places the reader in the given error state, calling the error callback if one
- * is set.
- *
- * This allows you to externally flag errors, for example if you are validating
- * data as you read it.
- *
- * If the reader is already in an error state, this call is ignored and no
- * error callback is called.
- */
-void mpack_reader_flag_error(mpack_reader_t* reader, mpack_error_t error);
-
-/**
- * Places the reader in the given error state if the given error is not mpack_ok,
- * returning the resulting error state of the reader.
- *
- * This allows you to externally flag errors, for example if you are validating
- * data as you read it.
- *
- * If the given error is mpack_ok or if the reader is already in an error state,
- * this call is ignored and the actual error state of the reader is returned.
- */
-MPACK_INLINE mpack_error_t mpack_reader_flag_if_error(mpack_reader_t* reader, mpack_error_t error) {
-    if (error != mpack_ok)
-        mpack_reader_flag_error(reader, error);
-    return mpack_reader_error(reader);
-}
-
-/**
- * Returns bytes left in the reader's buffer.
- *
- * If you are done reading MessagePack data but there is other interesting data
- * following it, the reader may have buffered too much data. The number of bytes
- * remaining in the buffer and a pointer to the position of those bytes can be
- * queried here.
- *
- * If you know the length of the MPack chunk beforehand, it's better to instead
- * have your fill function limit the data it reads so that the reader does not
- * have extra data. In this case you can simply check that this returns zero.
- *
- * Returns 0 if the reader is in an error state.
- *
- * @param reader The MPack reader from which to query remaining data.
- * @param data [out] A pointer to the remaining data, or NULL.
- * @return The number of bytes remaining in the buffer.
- */
-size_t mpack_reader_remaining(mpack_reader_t* reader, const char** data);
-
-/**
- * Reads a MessagePack object header (an MPack tag.)
- *
- * If an error occurs, the reader is placed in an error state and a
- * nil tag is returned. If the reader is already in an error state,
- * a nil tag is returned.
- *
- * If the type is compound (i.e. is a map, array, string, binary or
- * extension type), additional reads are required to get the contained
- * data, and the corresponding done function must be called when done.
- *
- * @note Maps in JSON are unordered, so it is recommended not to expect
- * a specific ordering for your map values in case your data is converted
- * to/from JSON.
- * 
- * @see mpack_read_bytes()
- * @see mpack_done_array()
- * @see mpack_done_map()
- * @see mpack_done_str()
- * @see mpack_done_bin()
- * @see mpack_done_ext()
- */
-mpack_tag_t mpack_read_tag(mpack_reader_t* reader);
-
-/**
- * Parses the next MessagePack object header (an MPack tag) without
- * advancing the reader.
- *
- * If an error occurs, the reader is placed in an error state and a
- * nil tag is returned. If the reader is already in an error state,
- * a nil tag is returned.
- *
- * @note Maps in JSON are unordered, so it is recommended not to expect
- * a specific ordering for your map values in case your data is converted
- * to/from JSON.
- *
- * @see mpack_read_tag()
- * @see mpack_discard()
- */
-mpack_tag_t mpack_peek_tag(mpack_reader_t* reader);
-
-/**
- * @}
- */
-
-/**
- * @name String and Data Functions
- * @{
- */
-
-/**
- * Skips bytes from the underlying stream. This is used only to
- * skip the contents of a string, binary blob or extension object.
- */
-void mpack_skip_bytes(mpack_reader_t* reader, size_t count);
-
-/**
- * Reads bytes from a string, binary blob or extension object, copying
- * them into the given buffer.
- *
- * A str, bin or ext must have been opened by a call to mpack_read_tag()
- * which yielded one of these types, or by a call to an expect function
- * such as mpack_expect_str() or mpack_expect_bin().
- *
- * If an error occurs, the buffer contents are undefined.
- *
- * This can be called multiple times for a single str, bin or ext
- * to read the data in chunks. The total data read must add up
- * to the size of the object.
- *
- * @param reader The MPack reader
- * @param p The buffer in which to copy the bytes
- * @param count The number of bytes to read
- */
-void mpack_read_bytes(mpack_reader_t* reader, char* p, size_t count);
-
-/**
- * Reads bytes from a string, ensures that the string is valid UTF-8,
- * and copies the bytes into the given buffer.
- *
- * A string must have been opened by a call to mpack_read_tag() which
- * yielded a string, or by a call to an expect function such as
- * mpack_expect_str().
- *
- * The given byte count must match the complete size of the string as
- * returned by the tag or expect function. You must ensure that the
- * buffer fits the data.
- *
- * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or
- * WTF-8. Only pure UTF-8 is allowed.
- *
- * If an error occurs, the buffer contents are undefined.
- *
- * Unlike mpack_read_bytes(), this cannot be used to read the data in
- * chunks (since this might split a character's UTF-8 bytes, and the
- * reader does not keep track of the UTF-8 decoding state between reads.)
- *
- * @throws mpack_error_type if the string contains invalid UTF-8.
- */
-void mpack_read_utf8(mpack_reader_t* reader, char* p, size_t byte_count);
-
-/**
- * Reads bytes from a string, ensures that the string contains no NUL
- * bytes, copies the bytes into the given buffer and adds a null-terminator.
- *
- * A string must have been opened by a call to mpack_read_tag() which
- * yielded a string, or by a call to an expect function such as
- * mpack_expect_str().
- *
- * The given byte count must match the size of the string as returned
- * by the tag or expect function. The string will only be copied if
- * the buffer is large enough to store it.
- *
- * If an error occurs, the buffer will contain an empty string.
- *
- * @note If you know the object will be a string before reading it,
- * it is highly recommended to use mpack_expect_cstr() instead.
- * Alternatively you could use mpack_peek_tag() and call
- * mpack_expect_cstr() if it's a string.
- *
- * @throws mpack_error_too_big if the string plus null-terminator is larger than the given buffer size
- * @throws mpack_error_type if the string contains a null byte.
- *
- * @see mpack_peek_tag()
- * @see mpack_expect_cstr()
- * @see mpack_expect_utf8_cstr()
- */
-void mpack_read_cstr(mpack_reader_t* reader, char* buf, size_t buffer_size, size_t byte_count);
-
-/**
- * Reads bytes from a string, ensures that the string is valid UTF-8
- * with no NUL bytes, copies the bytes into the given buffer and adds a
- * null-terminator.
- *
- * A string must have been opened by a call to mpack_read_tag() which
- * yielded a string, or by a call to an expect function such as
- * mpack_expect_str().
- *
- * The given byte count must match the size of the string as returned
- * by the tag or expect function. The string will only be copied if
- * the buffer is large enough to store it.
- *
- * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or
- * WTF-8. Only pure UTF-8 is allowed, but without the NUL character, since
- * it cannot be represented in a null-terminated string.
- *
- * If an error occurs, the buffer will contain an empty string.
- *
- * @note If you know the object will be a string before reading it,
- * it is highly recommended to use mpack_expect_utf8_cstr() instead.
- * Alternatively you could use mpack_peek_tag() and call
- * mpack_expect_utf8_cstr() if it's a string.
- *
- * @throws mpack_error_too_big if the string plus null-terminator is larger than the given buffer size
- * @throws mpack_error_type if the string contains invalid UTF-8 or a null byte.
- *
- * @see mpack_peek_tag()
- * @see mpack_expect_utf8_cstr()
- */
-void mpack_read_utf8_cstr(mpack_reader_t* reader, char* buf, size_t buffer_size, size_t byte_count);
-
-#ifdef MPACK_MALLOC
-/** @cond */
-// This can optionally add a null-terminator, but it does not check
-// whether the data contains null bytes. This must be done separately
-// in a cstring read function (possibly as part of a UTF-8 check.)
-char* mpack_read_bytes_alloc_impl(mpack_reader_t* reader, size_t count, bool null_terminated);
-/** @endcond */
-
-/**
- * Reads bytes from a string, binary blob or extension object, allocating
- * storage for them and returning the allocated pointer.
- *
- * The allocated string must be freed with MPACK_FREE() (or simply free()
- * if MPack's allocator hasn't been customized.)
- *
- * Returns NULL if any error occurs, or if count is zero.
- */
-MPACK_INLINE char* mpack_read_bytes_alloc(mpack_reader_t* reader, size_t count) {
-    return mpack_read_bytes_alloc_impl(reader, count, false);
-}
-#endif
-
-/**
- * Reads bytes from a string, binary blob or extension object in-place in
- * the buffer. This can be used to avoid copying the data.
- *
- * A str, bin or ext must have been opened by a call to mpack_read_tag()
- * which yielded one of these types, or by a call to an expect function
- * such as mpack_expect_str() or mpack_expect_bin().
- *
- * If the bytes are from a string, the string is not null-terminated! Use
- * mpack_read_cstr() to copy the string into a buffer and add a null-terminator.
- *
- * The returned pointer is invalidated on the next read, or when the buffer
- * is destroyed.
- *
- * The reader will move data around in the buffer if needed to ensure that
- * the pointer can always be returned, so this should only be used if
- * count is very small compared to the buffer size. If you need to check
- * whether a small size is reasonable (for example you intend to handle small and
- * large sizes differently), you can call mpack_should_read_bytes_inplace().
- *
- * This can be called multiple times for a single str, bin or ext
- * to read the data in chunks. The total data read must add up
- * to the size of the object.
- *
- * NULL is returned if the reader is in an error state.
- *
- * @throws mpack_error_too_big if the requested size is larger than the buffer size
- *
- * @see mpack_should_read_bytes_inplace()
- */
-const char* mpack_read_bytes_inplace(mpack_reader_t* reader, size_t count);
-
-/**
- * Reads bytes from a string in-place in the buffer and ensures they are
- * valid UTF-8. This can be used to avoid copying the data.
- *
- * A string must have been opened by a call to mpack_read_tag() which
- * yielded a string, or by a call to an expect function such as
- * mpack_expect_str().
- *
- * The string is not null-terminated! Use mpack_read_utf8_cstr() to
- * copy the string into a buffer and add a null-terminator.
- *
- * The returned pointer is invalidated on the next read, or when the buffer
- * is destroyed.
- *
- * The reader will move data around in the buffer if needed to ensure that
- * the pointer can always be returned, so this should only be used if
- * count is very small compared to the buffer size. If you need to check
- * whether a small size is reasonable (for example you intend to handle small and
- * large sizes differently), you can call mpack_should_read_bytes_inplace().
- *
- * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or
- * WTF-8. Only pure UTF-8 is allowed.
- *
- * Unlike mpack_read_bytes_inplace(), this cannot be used to read the data in
- * chunks (since this might split a character's UTF-8 bytes, and the
- * reader does not keep track of the UTF-8 decoding state between reads.)
- *
- * NULL is returned if the reader is in an error state.
- *
- * @throws mpack_error_type if the string contains invalid UTF-8
- * @throws mpack_error_too_big if the requested size is larger than the buffer size
- *
- * @see mpack_should_read_bytes_inplace()
- */
-const char* mpack_read_utf8_inplace(mpack_reader_t* reader, size_t count);
-
-/**
- * Returns true if it's a good idea to read the given number of bytes
- * in-place.
- *
- * If the read will be larger than some small fraction of the buffer size,
- * this will return false to avoid shuffling too much data back and forth
- * in the buffer.
- *
- * Use this if you're expecting arbitrary size data, and you want to read
- * in-place for the best performance when possible but will fall back to
- * a normal read if the data is too large.
- *
- * @see mpack_read_bytes_inplace()
- */
-MPACK_INLINE bool mpack_should_read_bytes_inplace(mpack_reader_t* reader, size_t count) {
-    return (reader->size == 0 || count <= reader->size / MPACK_READER_SMALL_FRACTION_DENOMINATOR);
-}
-
-#if MPACK_EXTENSIONS
-/**
- * Reads a timestamp contained in an ext object of the given size, closing the
- * ext type.
- *
- * An ext object of exttype @ref MPACK_EXTTYPE_TIMESTAMP must have been opened
- * by a call to e.g. mpack_read_tag() or mpack_expect_ext().
- *
- * You must NOT call mpack_done_ext() after calling this. A timestamp ext
- * object can only contain a single timestamp value, so this calls
- * mpack_done_ext() automatically.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- *
- * @throws mpack_error_invalid if the size is not one of the supported
- * timestamp sizes, or if the nanoseconds are out of range.
- */
-mpack_timestamp_t mpack_read_timestamp(mpack_reader_t* reader, size_t size);
-#endif
-
-/**
- * @}
- */
-
-/**
- * @name Core Reader Functions
- * @{
- */
-
-#if MPACK_READ_TRACKING
-/**
- * Finishes reading the given type.
- *
- * This will track reads to ensure that the correct number of elements
- * or bytes are read.
- */
-void mpack_done_type(mpack_reader_t* reader, mpack_type_t type);
-#else
-MPACK_INLINE void mpack_done_type(mpack_reader_t* reader, mpack_type_t type) {
-    MPACK_UNUSED(reader);
-    MPACK_UNUSED(type);
-}
-#endif
-
-/**
- * Finishes reading an array.
- *
- * This will track reads to ensure that the correct number of elements are read.
- */
-MPACK_INLINE void mpack_done_array(mpack_reader_t* reader) {
-    mpack_done_type(reader, mpack_type_array);
-}
-
-/**
- * @fn mpack_done_map(mpack_reader_t* reader)
- *
- * Finishes reading a map.
- *
- * This will track reads to ensure that the correct number of elements are read.
- */
-MPACK_INLINE void mpack_done_map(mpack_reader_t* reader) {
-    mpack_done_type(reader, mpack_type_map);
-}
-
-/**
- * @fn mpack_done_str(mpack_reader_t* reader)
- *
- * Finishes reading a string.
- *
- * This will track reads to ensure that the correct number of bytes are read.
- */
-MPACK_INLINE void mpack_done_str(mpack_reader_t* reader) {
-    mpack_done_type(reader, mpack_type_str);
-}
-
-/**
- * @fn mpack_done_bin(mpack_reader_t* reader)
- *
- * Finishes reading a binary data blob.
- *
- * This will track reads to ensure that the correct number of bytes are read.
- */
-MPACK_INLINE void mpack_done_bin(mpack_reader_t* reader) {
-    mpack_done_type(reader, mpack_type_bin);
-}
-
-#if MPACK_EXTENSIONS
-/**
- * @fn mpack_done_ext(mpack_reader_t* reader)
- *
- * Finishes reading an extended type binary data blob.
- *
- * This will track reads to ensure that the correct number of bytes are read.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- */
-MPACK_INLINE void mpack_done_ext(mpack_reader_t* reader) {
-    mpack_done_type(reader, mpack_type_ext);
-}
-#endif
-
-/**
- * Reads and discards the next object. This will read and discard all
- * contained data as well if it is a compound type.
- */
-void mpack_discard(mpack_reader_t* reader);
-
-/**
- * @}
- */
-
-/** @cond */
-
-#if MPACK_DEBUG && MPACK_STDIO
-/**
- * @name Debugging Functions
- * @{
- */
-/*
- * Converts a blob of MessagePack to a pseudo-JSON string for debugging
- * purposes, placing the result in the given buffer with a null-terminator.
- *
- * If the buffer does not have enough space, the result will be truncated (but
- * it is guaranteed to be null-terminated.)
- *
- * This is only available in debug mode, and only if stdio is available (since
- * it uses snprintf().) It's strictly for debugging purposes.
- */
-void mpack_print_data_to_buffer(const char* data, size_t data_size, char* buffer, size_t buffer_size);
-
-/*
- * Converts a node to pseudo-JSON for debugging purposes, calling the given
- * callback as many times as is necessary to output the character data.
- *
- * No null-terminator or trailing newline will be written.
- *
- * This is only available in debug mode, and only if stdio is available (since
- * it uses snprintf().) It's strictly for debugging purposes.
- */
-void mpack_print_data_to_callback(const char* data, size_t size, mpack_print_callback_t callback, void* context);
-
-/*
- * Converts a blob of MessagePack to pseudo-JSON for debugging purposes
- * and pretty-prints it to the given file.
- */
-void mpack_print_data_to_file(const char* data, size_t len, FILE* file);
-
-/*
- * Converts a blob of MessagePack to pseudo-JSON for debugging purposes
- * and pretty-prints it to stdout.
- */
-MPACK_INLINE void mpack_print_data_to_stdout(const char* data, size_t len) {
-    mpack_print_data_to_file(data, len, stdout);
-}
-
-/*
- * Converts the MessagePack contained in the given `FILE*` to pseudo-JSON for
- * debugging purposes, calling the given callback as many times as is necessary
- * to output the character data.
- */
-void mpack_print_stdfile_to_callback(FILE* file, mpack_print_callback_t callback, void* context);
-
-/*
- * Deprecated.
- *
- * \deprecated Renamed to mpack_print_data_to_stdout().
- */
-MPACK_INLINE void mpack_print(const char* data, size_t len) {
-    mpack_print_data_to_stdout(data, len);
-}
-
-/**
- * @}
- */
-#endif
-
-/** @endcond */
-
-/**
- * @}
- */
-
-
-
-#if MPACK_INTERNAL
-
-bool mpack_reader_ensure_straddle(mpack_reader_t* reader, size_t count);
-
-/*
- * Ensures there are at least @c count bytes left in the
- * data, raising an error and returning false if more
- * data cannot be made available.
- */
-MPACK_INLINE bool mpack_reader_ensure(mpack_reader_t* reader, size_t count) {
-    mpack_assert(count != 0, "cannot ensure zero bytes!");
-    mpack_assert(reader->error == mpack_ok, "reader cannot be in an error state!");
-
-    if (count <= (size_t)(reader->end - reader->data))
-        return true;
-    return mpack_reader_ensure_straddle(reader, count);
-}
-
-void mpack_read_native_straddle(mpack_reader_t* reader, char* p, size_t count);
-
-// Reads count bytes into p, deferring to mpack_read_native_straddle() if more
-// bytes are needed than are available in the buffer.
-MPACK_INLINE void mpack_read_native(mpack_reader_t* reader, char* p, size_t count) {
-    mpack_assert(count == 0 || p != NULL, "data pointer for %i bytes is NULL", (int)count);
-
-    if (count > (size_t)(reader->end - reader->data)) {
-        mpack_read_native_straddle(reader, p, count);
-    } else {
-        mpack_memcpy(p, reader->data, count);
-        reader->data += count;
-    }
-}
-
-#if MPACK_READ_TRACKING
-#define MPACK_READER_TRACK(reader, error_expr) \
-    (((reader)->error == mpack_ok) ? mpack_reader_flag_if_error((reader), (error_expr)) : (reader)->error)
-#else
-#define MPACK_READER_TRACK(reader, error_expr) (MPACK_UNUSED(reader), mpack_ok)
-#endif
-
-MPACK_INLINE mpack_error_t mpack_reader_track_element(mpack_reader_t* reader) {
-    return MPACK_READER_TRACK(reader, mpack_track_element(&reader->track, true));
-}
-
-MPACK_INLINE mpack_error_t mpack_reader_track_peek_element(mpack_reader_t* reader) {
-    return MPACK_READER_TRACK(reader, mpack_track_peek_element(&reader->track, true));
-}
-
-MPACK_INLINE mpack_error_t mpack_reader_track_bytes(mpack_reader_t* reader, uint64_t count) {
-    MPACK_UNUSED(count);
-    return MPACK_READER_TRACK(reader, mpack_track_bytes(&reader->track, true, count));
-}
-
-MPACK_INLINE mpack_error_t mpack_reader_track_str_bytes_all(mpack_reader_t* reader, uint64_t count) {
-    MPACK_UNUSED(count);
-    return MPACK_READER_TRACK(reader, mpack_track_str_bytes_all(&reader->track, true, count));
-}
-
-#endif
-
-
-
-#endif
-
-MPACK_HEADER_END
-
-#endif
-
-
-/* mpack/mpack-expect.h.h */
-
-/**
- * @file
- *
- * Declares the MPack static Expect API.
- */
-
-#ifndef MPACK_EXPECT_H
-#define MPACK_EXPECT_H 1
-
-/* #include "mpack-reader.h" */
-
-MPACK_HEADER_START
-
-#if MPACK_EXPECT
-
-#if !MPACK_READER
-#error "MPACK_EXPECT requires MPACK_READER."
-#endif
-
-/**
- * @defgroup expect Expect API
- *
- * The MPack Expect API allows you to easily read MessagePack data when you
- * expect it to follow a predefined schema.
- *
- * @note If you are not writing code for an embedded device (or otherwise do
- * not need maximum performance with minimal memory usage), you should not use
- * this. You probably want to use the @link node Node API@endlink instead.
- *
- * See @ref docs/expect.md for examples.
- *
- * The main purpose of the Expect API is convenience, so the API is lax. It
- * automatically converts between similar types where there is no loss of
- * precision.
- *
- * When using any of the expect functions, if the type or value of what was
- * read does not match what is expected, @ref mpack_error_type is raised.
- *
- * @{
- */
-
-/**
- * @name Basic Number Functions
- * @{
- */
-
-/**
- * Reads an 8-bit unsigned integer.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in an 8-bit unsigned int.
- *
- * Returns zero if an error occurs.
- */
-uint8_t mpack_expect_u8(mpack_reader_t* reader);
-
-/**
- * Reads a 16-bit unsigned integer.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a 16-bit unsigned int.
- *
- * Returns zero if an error occurs.
- */
-uint16_t mpack_expect_u16(mpack_reader_t* reader);
-
-/**
- * Reads a 32-bit unsigned integer.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a 32-bit unsigned int.
- *
- * Returns zero if an error occurs.
- */
-uint32_t mpack_expect_u32(mpack_reader_t* reader);
-
-/**
- * Reads a 64-bit unsigned integer.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a 64-bit unsigned int.
- *
- * Returns zero if an error occurs.
- */
-uint64_t mpack_expect_u64(mpack_reader_t* reader);
-
-/**
- * Reads an 8-bit signed integer.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in an 8-bit signed int.
- *
- * Returns zero if an error occurs.
- */
-int8_t mpack_expect_i8(mpack_reader_t* reader);
-
-/**
- * Reads a 16-bit signed integer.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a 16-bit signed int.
- *
- * Returns zero if an error occurs.
- */
-int16_t mpack_expect_i16(mpack_reader_t* reader);
-
-/**
- * Reads a 32-bit signed integer.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a 32-bit signed int.
- *
- * Returns zero if an error occurs.
- */
-int32_t mpack_expect_i32(mpack_reader_t* reader);
-
-/**
- * Reads a 64-bit signed integer.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a 64-bit signed int.
- *
- * Returns zero if an error occurs.
- */
-int64_t mpack_expect_i64(mpack_reader_t* reader);
-
-/**
- * Reads a number, returning the value as a float. The underlying value can be an
- * integer, float or double; the value is converted to a float.
- *
- * @note Reading a double or a large integer with this function can incur a
- * loss of precision.
- *
- * @throws mpack_error_type if the underlying value is not a float, double or integer.
- */
-float mpack_expect_float(mpack_reader_t* reader);
-
-/**
- * Reads a number, returning the value as a double. The underlying value can be an
- * integer, float or double; the value is converted to a double.
- *
- * @note Reading a very large integer with this function can incur a
- * loss of precision.
- *
- * @throws mpack_error_type if the underlying value is not a float, double or integer.
- */
-double mpack_expect_double(mpack_reader_t* reader);
-
-/**
- * Reads a float. The underlying value must be a float, not a double or an integer.
- * This ensures no loss of precision can occur.
- *
- * @throws mpack_error_type if the underlying value is not a float.
- */
-float mpack_expect_float_strict(mpack_reader_t* reader);
-
-/**
- * Reads a double. The underlying value must be a float or double, not an integer.
- * This ensures no loss of precision can occur.
- *
- * @throws mpack_error_type if the underlying value is not a float or double.
- */
-double mpack_expect_double_strict(mpack_reader_t* reader);
-
-/**
- * @}
- */
-
-/**
- * @name Ranged Number Functions
- * @{
- */
-
-/**
- * Reads an 8-bit unsigned integer, ensuring that it falls within the given range.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in an 8-bit unsigned int.
- *
- * Returns min_value if an error occurs.
- */
-uint8_t mpack_expect_u8_range(mpack_reader_t* reader, uint8_t min_value, uint8_t max_value);
-
-/**
- * Reads a 16-bit unsigned integer, ensuring that it falls within the given range.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a 16-bit unsigned int.
- *
- * Returns min_value if an error occurs.
- */
-uint16_t mpack_expect_u16_range(mpack_reader_t* reader, uint16_t min_value, uint16_t max_value);
-
-/**
- * Reads a 32-bit unsigned integer, ensuring that it falls within the given range.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a 32-bit unsigned int.
- *
- * Returns min_value if an error occurs.
- */
-uint32_t mpack_expect_u32_range(mpack_reader_t* reader, uint32_t min_value, uint32_t max_value);
-
-/**
- * Reads a 64-bit unsigned integer, ensuring that it falls within the given range.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a 64-bit unsigned int.
- *
- * Returns min_value if an error occurs.
- */
-uint64_t mpack_expect_u64_range(mpack_reader_t* reader, uint64_t min_value, uint64_t max_value);
-
-/**
- * Reads an unsigned integer, ensuring that it falls within the given range.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in an unsigned int.
- *
- * Returns min_value if an error occurs.
- */
-MPACK_INLINE unsigned int mpack_expect_uint_range(mpack_reader_t* reader, unsigned int min_value, unsigned int max_value) {
-    // This should be true at compile-time, so this just wraps the 32-bit
-    // function. We fallback to 64-bit if for some reason sizeof(int) isn't 4.
-    if (sizeof(unsigned int) == 4)
-        return (unsigned int)mpack_expect_u32_range(reader, (uint32_t)min_value, (uint32_t)max_value);
-    return (unsigned int)mpack_expect_u64_range(reader, min_value, max_value);
-}
-
-/**
- * Reads an 8-bit unsigned integer, ensuring that it is at most @a max_value.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in an 8-bit unsigned int.
- *
- * Returns 0 if an error occurs.
- */
-MPACK_INLINE uint8_t mpack_expect_u8_max(mpack_reader_t* reader, uint8_t max_value) {
-    return mpack_expect_u8_range(reader, 0, max_value);
-}
-
-/**
- * Reads a 16-bit unsigned integer, ensuring that it is at most @a max_value.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a 16-bit unsigned int.
- *
- * Returns 0 if an error occurs.
- */
-MPACK_INLINE uint16_t mpack_expect_u16_max(mpack_reader_t* reader, uint16_t max_value) {
-    return mpack_expect_u16_range(reader, 0, max_value);
-}
-
-/**
- * Reads a 32-bit unsigned integer, ensuring that it is at most @a max_value.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a 32-bit unsigned int.
- *
- * Returns 0 if an error occurs.
- */
-MPACK_INLINE uint32_t mpack_expect_u32_max(mpack_reader_t* reader, uint32_t max_value) {
-    return mpack_expect_u32_range(reader, 0, max_value);
-}
-
-/**
- * Reads a 64-bit unsigned integer, ensuring that it is at most @a max_value.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a 64-bit unsigned int.
- *
- * Returns 0 if an error occurs.
- */
-MPACK_INLINE uint64_t mpack_expect_u64_max(mpack_reader_t* reader, uint64_t max_value) {
-    return mpack_expect_u64_range(reader, 0, max_value);
-}
-
-/**
- * Reads an unsigned integer, ensuring that it is at most @a max_value.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in an unsigned int.
- *
- * Returns 0 if an error occurs.
- */
-MPACK_INLINE unsigned int mpack_expect_uint_max(mpack_reader_t* reader, unsigned int max_value) {
-    return mpack_expect_uint_range(reader, 0, max_value);
-}
-
-/**
- * Reads an 8-bit signed integer, ensuring that it falls within the given range.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in an 8-bit signed int.
- *
- * Returns min_value if an error occurs.
- */
-int8_t mpack_expect_i8_range(mpack_reader_t* reader, int8_t min_value, int8_t max_value);
-
-/**
- * Reads a 16-bit signed integer, ensuring that it falls within the given range.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a 16-bit signed int.
- *
- * Returns min_value if an error occurs.
- */
-int16_t mpack_expect_i16_range(mpack_reader_t* reader, int16_t min_value, int16_t max_value);
-
-/**
- * Reads a 32-bit signed integer, ensuring that it falls within the given range.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a 32-bit signed int.
- *
- * Returns min_value if an error occurs.
- */
-int32_t mpack_expect_i32_range(mpack_reader_t* reader, int32_t min_value, int32_t max_value);
-
-/**
- * Reads a 64-bit signed integer, ensuring that it falls within the given range.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a 64-bit signed int.
- *
- * Returns min_value if an error occurs.
- */
-int64_t mpack_expect_i64_range(mpack_reader_t* reader, int64_t min_value, int64_t max_value);
-
-/**
- * Reads a signed integer, ensuring that it falls within the given range.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a signed int.
- *
- * Returns min_value if an error occurs.
- */
-MPACK_INLINE int mpack_expect_int_range(mpack_reader_t* reader, int min_value, int max_value) {
-    // This should be true at compile-time, so this just wraps the 32-bit
-    // function. We fallback to 64-bit if for some reason sizeof(int) isn't 4.
-    if (sizeof(int) == 4)
-        return (int)mpack_expect_i32_range(reader, (int32_t)min_value, (int32_t)max_value);
-    return (int)mpack_expect_i64_range(reader, min_value, max_value);
-}
-
-/**
- * Reads an 8-bit signed integer, ensuring that it is at least zero and at
- * most @a max_value.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in an 8-bit signed int.
- *
- * Returns 0 if an error occurs.
- */
-MPACK_INLINE int8_t mpack_expect_i8_max(mpack_reader_t* reader, int8_t max_value) {
-    return mpack_expect_i8_range(reader, 0, max_value);
-}
-
-/**
- * Reads a 16-bit signed integer, ensuring that it is at least zero and at
- * most @a max_value.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a 16-bit signed int.
- *
- * Returns 0 if an error occurs.
- */
-MPACK_INLINE int16_t mpack_expect_i16_max(mpack_reader_t* reader, int16_t max_value) {
-    return mpack_expect_i16_range(reader, 0, max_value);
-}
-
-/**
- * Reads a 32-bit signed integer, ensuring that it is at least zero and at
- * most @a max_value.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a 32-bit signed int.
- *
- * Returns 0 if an error occurs.
- */
-MPACK_INLINE int32_t mpack_expect_i32_max(mpack_reader_t* reader, int32_t max_value) {
-    return mpack_expect_i32_range(reader, 0, max_value);
-}
-
-/**
- * Reads a 64-bit signed integer, ensuring that it is at least zero and at
- * most @a max_value.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a 64-bit signed int.
- *
- * Returns 0 if an error occurs.
- */
-MPACK_INLINE int64_t mpack_expect_i64_max(mpack_reader_t* reader, int64_t max_value) {
-    return mpack_expect_i64_range(reader, 0, max_value);
-}
-
-/**
- * Reads an int, ensuring that it is at least zero and at most @a max_value.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a signed int.
- *
- * Returns 0 if an error occurs.
- */
-MPACK_INLINE int mpack_expect_int_max(mpack_reader_t* reader, int max_value) {
-    return mpack_expect_int_range(reader, 0, max_value);
-}
-
-/**
- * Reads a number, ensuring that it falls within the given range and returning
- * the value as a float. The underlying value can be an integer, float or
- * double; the value is converted to a float.
- *
- * @note Reading a double or a large integer with this function can incur a
- * loss of precision.
- *
- * @throws mpack_error_type if the underlying value is not a float, double or integer.
- */
-float mpack_expect_float_range(mpack_reader_t* reader, float min_value, float max_value);
-
-/**
- * Reads a number, ensuring that it falls within the given range and returning
- * the value as a double. The underlying value can be an integer, float or
- * double; the value is converted to a double.
- *
- * @note Reading a very large integer with this function can incur a
- * loss of precision.
- *
- * @throws mpack_error_type if the underlying value is not a float, double or integer.
- */
-double mpack_expect_double_range(mpack_reader_t* reader, double min_value, double max_value);
-
-/**
- * @}
- */
-
-
-
-// These are additional Basic Number functions that wrap inline range functions.
-
-/**
- * @name Basic Number Functions
- * @{
- */
-
-/**
- * Reads an unsigned int.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in an unsigned int.
- *
- * Returns zero if an error occurs.
- */
-MPACK_INLINE unsigned int mpack_expect_uint(mpack_reader_t* reader) {
-
-    // This should be true at compile-time, so this just wraps the 32-bit function.
-    if (sizeof(unsigned int) == 4)
-        return (unsigned int)mpack_expect_u32(reader);
-
-    // Otherwise we wrap the max function to ensure it fits.
-    return (unsigned int)mpack_expect_u64_max(reader, UINT_MAX);
-
-}
-
-/**
- * Reads a signed int.
- *
- * The underlying type may be an integer type of any size and signedness,
- * as long as the value can be represented in a signed int.
- *
- * Returns zero if an error occurs.
- */
-MPACK_INLINE int mpack_expect_int(mpack_reader_t* reader) {
-
-    // This should be true at compile-time, so this just wraps the 32-bit function.
-    if (sizeof(int) == 4)
-        return (int)mpack_expect_i32(reader);
-
-    // Otherwise we wrap the range function to ensure it fits.
-    return (int)mpack_expect_i64_range(reader, INT_MIN, INT_MAX);
-
-}
-
-/**
- * @}
- */
-
-
-
-/**
- * @name Matching Number Functions
- * @{
- */
-
-/**
- * Reads an unsigned integer, ensuring that it exactly matches the given value.
- *
- * mpack_error_type is raised if the value is not representable as an unsigned
- * integer or if it does not exactly match the given value.
- */
-void mpack_expect_uint_match(mpack_reader_t* reader, uint64_t value);
-
-/**
- * Reads a signed integer, ensuring that it exactly matches the given value.
- *
- * mpack_error_type is raised if the value is not representable as a signed
- * integer or if it does not exactly match the given value.
- */
-void mpack_expect_int_match(mpack_reader_t* reader, int64_t value);
-
-/**
- * @name Other Basic Types
- * @{
- */
-
-/**
- * Reads a nil, raising @ref mpack_error_type if the value is not nil.
- */
-void mpack_expect_nil(mpack_reader_t* reader);
-
-/**
- * Reads a boolean.
- *
- * @note Integers will raise mpack_error_type; the value must be strictly a boolean.
- */
-bool mpack_expect_bool(mpack_reader_t* reader);
-
-/**
- * Reads a boolean, raising @ref mpack_error_type if its value is not @c true.
- */
-void mpack_expect_true(mpack_reader_t* reader);
-
-/**
- * Reads a boolean, raising @ref mpack_error_type if its value is not @c false.
- */
-void mpack_expect_false(mpack_reader_t* reader);
-
-/**
- * @}
- */
-
-/**
- * @name Extension Functions
- * @{
- */
-
-#if MPACK_EXTENSIONS
-/**
- * Reads a timestamp.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- */
-mpack_timestamp_t mpack_expect_timestamp(mpack_reader_t* reader);
-
-/**
- * Reads a timestamp in seconds, truncating the nanoseconds (if any).
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- */
-int64_t mpack_expect_timestamp_truncate(mpack_reader_t* reader);
-#endif
-
-/**
- * @}
- */
-
-/**
- * @name Compound Types
- * @{
- */
-
-/**
- * Reads the start of a map, returning its element count.
- *
- * A number of values follow equal to twice the element count of the map,
- * alternating between keys and values. @ref mpack_done_map() must be called
- * once all elements have been read.
- *
- * @note Maps in JSON are unordered, so it is recommended not to expect
- * a specific ordering for your map values in case your data is converted
- * to/from JSON.
- *
- * @warning This call is dangerous! It does not have a size limit, and it
- * does not have any way of checking whether there is enough data in the
- * message (since the data could be coming from a stream.) When looping
- * through the map's contents, you must check for errors on each iteration
- * of the loop. Otherwise an attacker could craft a message declaring a map
- * of a billion elements which would throw your parsing code into an
- * infinite loop! You should strongly consider using mpack_expect_map_max()
- * with a safe maximum size instead.
- *
- * @throws mpack_error_type if the value is not a map.
- */
-uint32_t mpack_expect_map(mpack_reader_t* reader);
-
-/**
- * Reads the start of a map with a number of elements in the given range, returning
- * its element count.
- *
- * A number of values follow equal to twice the element count of the map,
- * alternating between keys and values. @ref mpack_done_map() must be called
- * once all elements have been read.
- *
- * @note Maps in JSON are unordered, so it is recommended not to expect
- * a specific ordering for your map values in case your data is converted
- * to/from JSON.
- *
- * min_count is returned if an error occurs.
- *
- * @throws mpack_error_type if the value is not a map or if its size does
- * not fall within the given range.
- */
-uint32_t mpack_expect_map_range(mpack_reader_t* reader, uint32_t min_count, uint32_t max_count);
-
-/**
- * Reads the start of a map with a number of elements at most @a max_count,
- * returning its element count.
- *
- * A number of values follow equal to twice the element count of the map,
- * alternating between keys and values. @ref mpack_done_map() must be called
- * once all elements have been read.
- *
- * @note Maps in JSON are unordered, so it is recommended not to expect
- * a specific ordering for your map values in case your data is converted
- * to/from JSON.
- *
- * Zero is returned if an error occurs.
- *
- * @throws mpack_error_type if the value is not a map or if its size is
- * greater than max_count.
- */
-MPACK_INLINE uint32_t mpack_expect_map_max(mpack_reader_t* reader, uint32_t max_count) {
-    return mpack_expect_map_range(reader, 0, max_count);
-}
-
-/**
- * Reads the start of a map of the exact size given.
- *
- * A number of values follow equal to twice the element count of the map,
- * alternating between keys and values. @ref mpack_done_map() must be called
- * once all elements have been read.
- *
- * @note Maps in JSON are unordered, so it is recommended not to expect
- * a specific ordering for your map values in case your data is converted
- * to/from JSON.
- *
- * @throws mpack_error_type if the value is not a map or if its size
- * does not match the given count.
- */
-void mpack_expect_map_match(mpack_reader_t* reader, uint32_t count);
-
-/**
- * Reads a nil node or the start of a map, returning whether a map was
- * read and placing its number of key/value pairs in count.
- *
- * If a map was read, a number of values follow equal to twice the element count
- * of the map, alternating between keys and values. @ref mpack_done_map() should
- * also be called once all elements have been read (only if a map was read.)
- *
- * @note Maps in JSON are unordered, so it is recommended not to expect
- * a specific ordering for your map values in case your data is converted
- * to/from JSON.
- *
- * @warning This call is dangerous! It does not have a size limit, and it
- * does not have any way of checking whether there is enough data in the
- * message (since the data could be coming from a stream.) When looping
- * through the map's contents, you must check for errors on each iteration
- * of the loop. Otherwise an attacker could craft a message declaring a map
- * of a billion elements which would throw your parsing code into an
- * infinite loop! You should strongly consider using mpack_expect_map_max_or_nil()
- * with a safe maximum size instead.
- *
- * @returns @c true if a map was read successfully; @c false if nil was read
- *     or an error occured.
- * @throws mpack_error_type if the value is not a nil or map.
- */
-bool mpack_expect_map_or_nil(mpack_reader_t* reader, uint32_t* count);
-
-/**
- * Reads a nil node or the start of a map with a number of elements at most
- * max_count, returning whether a map was read and placing its number of
- * key/value pairs in count.
- *
- * If a map was read, a number of values follow equal to twice the element count
- * of the map, alternating between keys and values. @ref mpack_done_map() should
- * anlso be called once all elements have been read (only if a map was read.)
- *
- * @note Maps in JSON are unordered, so it is recommended not to expect
- * a specific ordering for your map values in case your data is converted
- * to/from JSON. Consider using mpack_expect_key_cstr() or mpack_expect_key_uint()
- * to switch on the key; see @ref docs/expect.md for examples.
- *
- * @returns @c true if a map was read successfully; @c false if nil was read
- *     or an error occured.
- * @throws mpack_error_type if the value is not a nil or map.
- */
-bool mpack_expect_map_max_or_nil(mpack_reader_t* reader, uint32_t max_count, uint32_t* count);
-
-/**
- * Reads the start of an array, returning its element count.
- *
- * A number of values follow equal to the element count of the array.
- * @ref mpack_done_array() must be called once all elements have been read.
- *
- * @warning This call is dangerous! It does not have a size limit, and it
- * does not have any way of checking whether there is enough data in the
- * message (since the data could be coming from a stream.) When looping
- * through the array's contents, you must check for errors on each iteration
- * of the loop. Otherwise an attacker could craft a message declaring an array
- * of a billion elements which would throw your parsing code into an
- * infinite loop! You should strongly consider using mpack_expect_array_max()
- * with a safe maximum size instead.
- */
-uint32_t mpack_expect_array(mpack_reader_t* reader);
-
-/**
- * Reads the start of an array with a number of elements in the given range,
- * returning its element count.
- *
- * A number of values follow equal to the element count of the array.
- * @ref mpack_done_array() must be called once all elements have been read.
- *
- * min_count is returned if an error occurs.
- *
- * @throws mpack_error_type if the value is not an array or if its size does
- * not fall within the given range.
- */
-uint32_t mpack_expect_array_range(mpack_reader_t* reader, uint32_t min_count, uint32_t max_count);
-
-/**
- * Reads the start of an array with a number of elements at most @a max_count,
- * returning its element count.
- *
- * A number of values follow equal to the element count of the array.
- * @ref mpack_done_array() must be called once all elements have been read.
- *
- * Zero is returned if an error occurs.
- *
- * @throws mpack_error_type if the value is not an array or if its size is
- * greater than max_count.
- */
-MPACK_INLINE uint32_t mpack_expect_array_max(mpack_reader_t* reader, uint32_t max_count) {
-    return mpack_expect_array_range(reader, 0, max_count);
-}
-
-/**
- * Reads the start of an array of the exact size given.
- *
- * A number of values follow equal to the element count of the array.
- * @ref mpack_done_array() must be called once all elements have been read.
- *
- * @throws mpack_error_type if the value is not an array or if its size does
- * not match the given count.
- */
-void mpack_expect_array_match(mpack_reader_t* reader, uint32_t count);
-
-/**
- * Reads a nil node or the start of an array, returning whether an array was
- * read and placing its number of elements in count.
- *
- * If an array was read, a number of values follow equal to the element count
- * of the array. @ref mpack_done_array() should also be called once all elements
- * have been read (only if an array was read.)
- *
- * @warning This call is dangerous! It does not have a size limit, and it
- * does not have any way of checking whether there is enough data in the
- * message (since the data could be coming from a stream.) When looping
- * through the array's contents, you must check for errors on each iteration
- * of the loop. Otherwise an attacker could craft a message declaring an array
- * of a billion elements which would throw your parsing code into an
- * infinite loop! You should strongly consider using mpack_expect_array_max_or_nil()
- * with a safe maximum size instead.
- *
- * @returns @c true if an array was read successfully; @c false if nil was read
- *     or an error occured.
- * @throws mpack_error_type if the value is not a nil or array.
- */
-bool mpack_expect_array_or_nil(mpack_reader_t* reader, uint32_t* count);
-
-/**
- * Reads a nil node or the start of an array with a number of elements at most
- * max_count, returning whether an array was read and placing its number of
- * key/value pairs in count.
- *
- * If an array was read, a number of values follow equal to the element count
- * of the array. @ref mpack_done_array() should also be called once all elements
- * have been read (only if an array was read.)
- *
- * @returns @c true if an array was read successfully; @c false if nil was read
- *     or an error occured.
- * @throws mpack_error_type if the value is not a nil or array.
- */
-bool mpack_expect_array_max_or_nil(mpack_reader_t* reader, uint32_t max_count, uint32_t* count);
-
-#ifdef MPACK_MALLOC
-/**
- * @hideinitializer
- *
- * Reads the start of an array and allocates storage for it, placing its
- * size in out_count. A number of objects follow equal to the element count
- * of the array. You must call @ref mpack_done_array() when done (even
- * if the element count is zero.)
- *
- * If an error occurs, NULL is returned and the reader is placed in an
- * error state.
- *
- * If the count is zero, NULL is returned. This does not indicate error.
- * You should not check the return value for NULL to check for errors; only
- * check the reader's error state.
- *
- * The allocated array must be freed with MPACK_FREE() (or simply free()
- * if MPack's allocator hasn't been customized.)
- *
- * @throws mpack_error_type if the value is not an array or if its size is
- * greater than max_count.
- */
-#define mpack_expect_array_alloc(reader, Type, max_count, out_count) \
-    ((Type*)mpack_expect_array_alloc_impl(reader, sizeof(Type), max_count, out_count, false))
-
-/**
- * @hideinitializer
- *
- * Reads a nil node or the start of an array and allocates storage for it,
- * placing its size in out_count. A number of objects follow equal to the element
- * count of the array if a non-empty array was read.
- *
- * If an error occurs, NULL is returned and the reader is placed in an
- * error state.
- *
- * If a nil node was read, NULL is returned. If an empty array was read,
- * mpack_done_array() is called automatically and NULL is returned. These
- * do not indicate error. You should not check the return value for NULL
- * to check for errors; only check the reader's error state.
- *
- * The allocated array must be freed with MPACK_FREE() (or simply free()
- * if MPack's allocator hasn't been customized.)
- *
- * @warning You must call @ref mpack_done_array() if and only if a non-zero
- * element count is read. This function does not differentiate between nil
- * and an empty array.
- *
- * @throws mpack_error_type if the value is not an array or if its size is
- * greater than max_count.
- */
-#define mpack_expect_array_or_nil_alloc(reader, Type, max_count, out_count) \
-    ((Type*)mpack_expect_array_alloc_impl(reader, sizeof(Type), max_count, out_count, true))
-#endif
-
-/**
- * @}
- */
-
-/** @cond */
-#ifdef MPACK_MALLOC
-void* mpack_expect_array_alloc_impl(mpack_reader_t* reader,
-        size_t element_size, uint32_t max_count, uint32_t* out_count, bool allow_nil);
-#endif
-/** @endcond */
-
-
-/**
- * @name String Functions
- * @{
- */
-
-/**
- * Reads the start of a string, returning its size in bytes.
- *
- * The bytes follow and must be read separately with mpack_read_bytes()
- * or mpack_read_bytes_inplace(). mpack_done_str() must be called
- * once all bytes have been read.
- *
- * NUL bytes are allowed in the string, and no encoding checks are done.
- *
- * mpack_error_type is raised if the value is not a string.
- */
-uint32_t mpack_expect_str(mpack_reader_t* reader);
-
-/**
- * Reads a string of at most the given size, writing it into the
- * given buffer and returning its size in bytes.
- *
- * This does not add a null-terminator! Use mpack_expect_cstr() to
- * add a null-terminator.
- *
- * NUL bytes are allowed in the string, and no encoding checks are done.
- */
-size_t mpack_expect_str_buf(mpack_reader_t* reader, char* buf, size_t bufsize);
-
-/**
- * Reads a string into the given buffer, ensuring it is a valid UTF-8 string
- * and returning its size in bytes.
- *
- * This does not add a null-terminator! Use mpack_expect_utf8_cstr() to
- * add a null-terminator.
- *
- * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or
- * WTF-8. Only pure UTF-8 is allowed.
- *
- * NUL bytes are allowed in the string (as they are in UTF-8.)
- *
- * Raises mpack_error_too_big if there is not enough room for the string.
- * Raises mpack_error_type if the value is not a string or is not a valid UTF-8 string.
- */
-size_t mpack_expect_utf8(mpack_reader_t* reader, char* buf, size_t bufsize);
-
-/**
- * Reads the start of a string, raising an error if its length is not
- * at most the given number of bytes (not including any null-terminator.)
- *
- * The bytes follow and must be read separately with mpack_read_bytes()
- * or mpack_read_bytes_inplace(). @ref mpack_done_str() must be called
- * once all bytes have been read.
- *
- * @throws mpack_error_type If the value is not a string.
- * @throws mpack_error_too_big If the string's length in bytes is larger than the given maximum size.
- */
-MPACK_INLINE uint32_t mpack_expect_str_max(mpack_reader_t* reader, uint32_t maxsize) {
-    uint32_t length = mpack_expect_str(reader);
-    if (length > maxsize) {
-        mpack_reader_flag_error(reader, mpack_error_too_big);
-        return 0;
-    }
-    return length;
-}
-
-/**
- * Reads the start of a string, raising an error if its length is not
- * exactly the given number of bytes (not including any null-terminator.)
- *
- * The bytes follow and must be read separately with mpack_read_bytes()
- * or mpack_read_bytes_inplace(). @ref mpack_done_str() must be called
- * once all bytes have been read.
- *
- * mpack_error_type is raised if the value is not a string or if its
- * length does not match.
- */
-MPACK_INLINE void mpack_expect_str_length(mpack_reader_t* reader, uint32_t count) {
-    if (mpack_expect_str(reader) != count)
-        mpack_reader_flag_error(reader, mpack_error_type);
-}
-
-/**
- * Reads a string, ensuring it exactly matches the given string.
- *
- * Remember that maps are unordered in JSON. Don't use this for map keys
- * unless the map has only a single key!
- */
-void mpack_expect_str_match(mpack_reader_t* reader, const char* str, size_t length);
-
-/**
- * Reads a string into the given buffer, ensures it has no null bytes,
- * and adds a null-terminator at the end.
- *
- * Raises mpack_error_too_big if there is not enough room for the string and null-terminator.
- * Raises mpack_error_type if the value is not a string or contains a null byte.
- */
-void mpack_expect_cstr(mpack_reader_t* reader, char* buf, size_t size);
-
-/**
- * Reads a string into the given buffer, ensures it is a valid UTF-8 string
- * without NUL characters, and adds a null-terminator at the end.
- *
- * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or
- * WTF-8. Only pure UTF-8 is allowed, but without the NUL character, since
- * it cannot be represented in a null-terminated string.
- *
- * Raises mpack_error_too_big if there is not enough room for the string and null-terminator.
- * Raises mpack_error_type if the value is not a string or is not a valid UTF-8 string.
- */
-void mpack_expect_utf8_cstr(mpack_reader_t* reader, char* buf, size_t size);
-
-#ifdef MPACK_MALLOC
-/**
- * Reads a string with the given total maximum size (including space for a
- * null-terminator), allocates storage for it, ensures it has no null-bytes,
- * and adds a null-terminator at the end. You assume ownership of the
- * returned pointer if reading succeeds.
- *
- * The allocated string must be freed with MPACK_FREE() (or simply free()
- * if MPack's allocator hasn't been customized.)
- *
- * @throws mpack_error_too_big If the string plus null-terminator is larger than the given maxsize.
- * @throws mpack_error_type If the value is not a string or contains a null byte.
- */
-char* mpack_expect_cstr_alloc(mpack_reader_t* reader, size_t maxsize);
-
-/**
- * Reads a string with the given total maximum size (including space for a
- * null-terminator), allocates storage for it, ensures it is valid UTF-8
- * with no null-bytes, and adds a null-terminator at the end. You assume
- * ownership of the returned pointer if reading succeeds.
- *
- * The length in bytes of the string, not including the null-terminator,
- * will be written to size.
- *
- * This does not accept any UTF-8 variant such as Modified UTF-8, CESU-8 or
- * WTF-8. Only pure UTF-8 is allowed, but without the NUL character, since
- * it cannot be represented in a null-terminated string.
- *
- * The allocated string must be freed with MPACK_FREE() (or simply free()
- * if MPack's allocator hasn't been customized.)
- * if you want a null-terminator.
- *
- * @throws mpack_error_too_big If the string plus null-terminator is larger
- *     than the given maxsize.
- * @throws mpack_error_type If the value is not a string or contains
- *     invalid UTF-8 or a null byte.
- */
-char* mpack_expect_utf8_cstr_alloc(mpack_reader_t* reader, size_t maxsize);
-#endif
-
-/**
- * Reads a string, ensuring it exactly matches the given null-terminated
- * string.
- *
- * Remember that maps are unordered in JSON. Don't use this for map keys
- * unless the map has only a single key!
- */
-MPACK_INLINE void mpack_expect_cstr_match(mpack_reader_t* reader, const char* cstr) {
-    mpack_assert(cstr != NULL, "cstr pointer is NULL");
-    mpack_expect_str_match(reader, cstr, mpack_strlen(cstr));
-}
-
-/**
- * @}
- */
-
-/**
- * @name Binary Data
- * @{
- */
-
-/**
- * Reads the start of a binary blob, returning its size in bytes.
- *
- * The bytes follow and must be read separately with mpack_read_bytes()
- * or mpack_read_bytes_inplace(). @ref mpack_done_bin() must be called
- * once all bytes have been read.
- *
- * mpack_error_type is raised if the value is not a binary blob.
- */
-uint32_t mpack_expect_bin(mpack_reader_t* reader);
-
-/**
- * Reads the start of a binary blob, raising an error if its length is not
- * at most the given number of bytes.
- *
- * The bytes follow and must be read separately with mpack_read_bytes()
- * or mpack_read_bytes_inplace(). @ref mpack_done_bin() must be called
- * once all bytes have been read.
- *
- * mpack_error_type is raised if the value is not a binary blob or if its
- * length does not match.
- */
-MPACK_INLINE uint32_t mpack_expect_bin_max(mpack_reader_t* reader, uint32_t maxsize) {
-    uint32_t length = mpack_expect_bin(reader);
-    if (length > maxsize) {
-        mpack_reader_flag_error(reader, mpack_error_type);
-        return 0;
-    }
-    return length;
-}
-
-/**
- * Reads the start of a binary blob, raising an error if its length is not
- * exactly the given number of bytes.
- *
- * The bytes follow and must be read separately with mpack_read_bytes()
- * or mpack_read_bytes_inplace(). @ref mpack_done_bin() must be called
- * once all bytes have been read.
- *
- * mpack_error_type is raised if the value is not a binary blob or if its
- * length does not match.
- */
-MPACK_INLINE void mpack_expect_bin_size(mpack_reader_t* reader, uint32_t count) {
-    if (mpack_expect_bin(reader) != count)
-        mpack_reader_flag_error(reader, mpack_error_type);
-}
-
-/**
- * Reads a binary blob into the given buffer, returning its size in bytes.
- *
- * For compatibility, this will accept if the underlying type is string or
- * binary (since in MessagePack 1.0, strings and binary data were combined
- * under the "raw" type which became string in 1.1.)
- */
-size_t mpack_expect_bin_buf(mpack_reader_t* reader, char* buf, size_t size);
-
-/**
- * Reads a binary blob with the given total maximum size, allocating storage for it.
- */
-char* mpack_expect_bin_alloc(mpack_reader_t* reader, size_t maxsize, size_t* size);
-
-/**
- * @}
- */
-
-/**
- * @name Extension Functions
- * @{
- */
-
-#if MPACK_EXTENSIONS
-/**
- * Reads the start of an extension blob, returning its size in bytes and
- * placing the type into @p type.
- *
- * The bytes follow and must be read separately with mpack_read_bytes()
- * or mpack_read_bytes_inplace(). @ref mpack_done_ext() must be called
- * once all bytes have been read.
- *
- * @p type will be a user-defined type in the range [0,127] or a reserved type
- * in the range [-128,-2].
- *
- * mpack_error_type is raised if the value is not an extension blob. The @p
- * type value is zero if an error occurs.
- *
- * @note This cannot be used to match a timestamp. @ref mpack_error_type will
- * be flagged if the value is a timestamp. Use mpack_expect_timestamp() or
- * mpack_expect_timestamp_truncate() instead.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- *
- * @warning Be careful when using reserved types. They may no longer be ext
- * types in the future, and previously valid data containing reserved types may
- * become invalid in the future.
- */
-uint32_t mpack_expect_ext(mpack_reader_t* reader, int8_t* type);
-
-/**
- * Reads the start of an extension blob, raising an error if its length is not
- * at most the given number of bytes and placing the type into @p type.
- *
- * The bytes follow and must be read separately with mpack_read_bytes()
- * or mpack_read_bytes_inplace(). @ref mpack_done_ext() must be called
- * once all bytes have been read.
- *
- * mpack_error_type is raised if the value is not an extension blob or if its
- * length does not match. The @p type value is zero if an error is raised.
- *
- * @p type will be a user-defined type in the range [0,127] or a reserved type
- * in the range [-128,-2].
- *
- * @note This cannot be used to match a timestamp. @ref mpack_error_type will
- * be flagged if the value is a timestamp. Use mpack_expect_timestamp() or
- * mpack_expect_timestamp_truncate() instead.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- *
- * @warning Be careful when using reserved types. They may no longer be ext
- * types in the future, and previously valid data containing reserved types may
- * become invalid in the future.
- *
- * @see mpack_expect_ext()
- */
-MPACK_INLINE uint32_t mpack_expect_ext_max(mpack_reader_t* reader, int8_t* type, uint32_t maxsize) {
-    uint32_t length = mpack_expect_ext(reader, type);
-    if (length > maxsize) {
-        mpack_reader_flag_error(reader, mpack_error_type);
-        return 0;
-    }
-    return length;
-}
-
-/**
- * Reads the start of an extension blob, raising an error if its length is not
- * exactly the given number of bytes and placing the type into @p type.
- *
- * The bytes follow and must be read separately with mpack_read_bytes()
- * or mpack_read_bytes_inplace(). @ref mpack_done_ext() must be called
- * once all bytes have been read.
- *
- * mpack_error_type is raised if the value is not an extension blob or if its
- * length does not match. The @p type value is zero if an error is raised.
- *
- * @p type will be a user-defined type in the range [0,127] or a reserved type
- * in the range [-128,-2].
- *
- * @note This cannot be used to match a timestamp. @ref mpack_error_type will
- * be flagged if the value is a timestamp. Use mpack_expect_timestamp() or
- * mpack_expect_timestamp_truncate() instead.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- *
- * @warning Be careful when using reserved types. They may no longer be ext
- * types in the future, and previously valid data containing reserved types may
- * become invalid in the future.
- *
- * @see mpack_expect_ext()
- */
-MPACK_INLINE void mpack_expect_ext_size(mpack_reader_t* reader, int8_t* type, uint32_t count) {
-    if (mpack_expect_ext(reader, type) != count) {
-        *type = 0;
-        mpack_reader_flag_error(reader, mpack_error_type);
-    }
-}
-
-/**
- * Reads an extension blob into the given buffer, returning its size in bytes
- * and placing the type into @p type.
- *
- * mpack_error_type is raised if the value is not an extension blob or if its
- * length does not match. The @p type value is zero if an error is raised.
- *
- * @p type will be a user-defined type in the range [0,127] or a reserved type
- * in the range [-128,-2].
- *
- * @note This cannot be used to match a timestamp. @ref mpack_error_type will
- * be flagged if the value is a timestamp. Use mpack_expect_timestamp() or
- * mpack_expect_timestamp_truncate() instead.
- *
- * @warning Be careful when using reserved types. They may no longer be ext
- * types in the future, and previously valid data containing reserved types may
- * become invalid in the future.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- *
- * @see mpack_expect_ext()
- */
-size_t mpack_expect_ext_buf(mpack_reader_t* reader, int8_t* type, char* buf, size_t size);
-#endif
-
-#if MPACK_EXTENSIONS && defined(MPACK_MALLOC)
-/**
- * Reads an extension blob with the given total maximum size, allocating
- * storage for it, and placing the type into @p type.
- *
- * mpack_error_type is raised if the value is not an extension blob or if its
- * length does not match. The @p type value is zero if an error is raised.
- *
- * @p type will be a user-defined type in the range [0,127] or a reserved type
- * in the range [-128,-2].
- *
- * @note This cannot be used to match a timestamp. @ref mpack_error_type will
- * be flagged if the value is a timestamp. Use mpack_expect_timestamp() or
- * mpack_expect_timestamp_truncate() instead.
- *
- * @warning Be careful when using reserved types. They may no longer be ext
- * types in the future, and previously valid data containing reserved types may
- * become invalid in the future.
- *
- * @note This requires @ref MPACK_EXTENSIONS and @ref MPACK_MALLOC.
- *
- * @see mpack_expect_ext()
- */
-char* mpack_expect_ext_alloc(mpack_reader_t* reader, int8_t* type, size_t maxsize, size_t* size);
-#endif
-
-/**
- * @}
- */
-
-/**
- * @name Special Functions
- * @{
- */
-
-/**
- * Reads a MessagePack object header (an MPack tag), expecting it to exactly
- * match the given tag.
- *
- * If the type is compound (i.e. is a map, array, string, binary or
- * extension type), additional reads are required to get the contained
- * data, and the corresponding done function must be called when done.
- *
- * @throws mpack_error_type if the tag does not match
- *
- * @see mpack_read_bytes()
- * @see mpack_done_array()
- * @see mpack_done_map()
- * @see mpack_done_str()
- * @see mpack_done_bin()
- * @see mpack_done_ext()
- */
-void mpack_expect_tag(mpack_reader_t* reader, mpack_tag_t tag);
-
-/**
- * Expects a string matching one of the strings in the given array,
- * returning its array index.
- *
- * If the value does not match any of the given strings,
- * @ref mpack_error_type is flagged. Use mpack_expect_enum_optional()
- * if you want to allow other values than the given strings.
- *
- * If any error occurs or the reader is in an error state, @a count
- * is returned.
- *
- * This can be used to quickly parse a string into an enum when the
- * enum values range from 0 to @a count-1. If the last value in the
- * enum is a special "count" value, it can be passed as the count,
- * and the return value can be cast directly to the enum type.
- *
- * @code{.c}
- * typedef enum           { APPLE ,  BANANA ,  ORANGE , COUNT} fruit_t;
- * const char* fruits[] = {"apple", "banana", "orange"};
- *
- * fruit_t fruit = (fruit_t)mpack_expect_enum(reader, fruits, COUNT);
- * @endcode
- *
- * See @ref docs/expect.md for more examples.
- *
- * The maximum string length is the size of the buffer (strings are read in-place.)
- *
- * @param reader The reader
- * @param strings An array of expected strings of length count
- * @param count The number of strings
- * @return The index of the matched string, or @a count in case of error
- */
-size_t mpack_expect_enum(mpack_reader_t* reader, const char* strings[], size_t count);
-
-/**
- * Expects a string matching one of the strings in the given array
- * returning its array index, or @a count if no strings match.
- *
- * If the value is not a string, or it does not match any of the
- * given strings, @a count is returned and no error is flagged.
- *
- * If any error occurs or the reader is in an error state, @a count
- * is returned.
- *
- * This can be used to quickly parse a string into an enum when the
- * enum values range from 0 to @a count-1. If the last value in the
- * enum is a special "count" value, it can be passed as the count,
- * and the return value can be cast directly to the enum type.
- *
- * @code{.c}
- * typedef enum           { APPLE ,  BANANA ,  ORANGE , COUNT} fruit_t;
- * const char* fruits[] = {"apple", "banana", "orange"};
- *
- * fruit_t fruit = (fruit_t)mpack_expect_enum_optional(reader, fruits, COUNT);
- * @endcode
- *
- * See @ref docs/expect.md for more examples.
- *
- * The maximum string length is the size of the buffer (strings are read in-place.)
- *
- * @param reader The reader
- * @param strings An array of expected strings of length count
- * @param count The number of strings
- *
- * @return The index of the matched string, or @a count if it does not
- * match or an error occurs
- */
-size_t mpack_expect_enum_optional(mpack_reader_t* reader, const char* strings[], size_t count);
-
-/**
- * Expects an unsigned integer map key between 0 and count-1, marking it
- * as found in the given bool array and returning it.
- *
- * This is a helper for switching among int keys in a map. It is
- * typically used with an enum to define the key values. It should
- * be called in the expression of a switch() statement. See @ref
- * docs/expect.md for an example.
- *
- * The found array must be cleared before expecting the first key. If the
- * flag for a given key is already set when found (i.e. the map contains a
- * duplicate key), mpack_error_invalid is flagged.
- *
- * If the key is not a non-negative integer, or if the key is @a count or
- * larger, @a count is returned and no error is flagged. If you want an error
- * on unrecognized keys, flag an error in the default case in your switch;
- * otherwise you must call mpack_discard() to discard its content.
- *
- * @param reader The reader
- * @param found An array of bool flags of length count
- * @param count The number of values in the found array, and one more than the
- *              maximum allowed key
- *
- * @see @ref docs/expect.md
- */
-size_t mpack_expect_key_uint(mpack_reader_t* reader, bool found[], size_t count);
-
-/**
- * Expects a string map key matching one of the strings in the given key list,
- * marking it as found in the given bool array and returning its index.
- *
- * This is a helper for switching among string keys in a map. It is
- * typically used with an enum with names matching the strings in the
- * array to define the key indices. It should be called in the expression
- * of a switch() statement. See @ref docs/expect.md for an example.
- *
- * The found array must be cleared before expecting the first key. If the
- * flag for a given key is already set when found (i.e. the map contains a
- * duplicate key), mpack_error_invalid is flagged.
- *
- * If the key is unrecognized, count is returned and no error is flagged. If
- * you want an error on unrecognized keys, flag an error in the default case
- * in your switch; otherwise you must call mpack_discard() to discard its content.
- *
- * The maximum key length is the size of the buffer (keys are read in-place.)
- *
- * @param reader The reader
- * @param keys An array of expected string keys of length count
- * @param found An array of bool flags of length count
- * @param count The number of values in the keys and found arrays
- *
- * @see @ref docs/expect.md
- */
-size_t mpack_expect_key_cstr(mpack_reader_t* reader, const char* keys[],
-        bool found[], size_t count);
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-#endif
-
-MPACK_HEADER_END
-
-#endif
-
-
-
-/* mpack/mpack-node.h.h */
-
-/**
- * @file
- *
- * Declares the MPack dynamic Node API.
- */
-
-#ifndef MPACK_NODE_H
-#define MPACK_NODE_H 1
-
-/* #include "mpack-reader.h" */
-
-MPACK_HEADER_START
-
-#if MPACK_NODE
-
-/**
- * @defgroup node Node API
- *
- * The MPack Node API allows you to parse a chunk of MessagePack into a
- * dynamically typed data structure, providing random access to the parsed
- * data.
- *
- * See @ref docs/node.md for examples.
- *
- * @{
- */
-
-/**
- * A handle to node data in a parsed MPack tree.
- *
- * Nodes represent either primitive values or compound types. If a
- * node is a compound type, it contains a pointer to its child nodes,
- * or a pointer to its underlying data.
- *
- * Nodes are immutable.
- *
- * @note @ref mpack_node_t is an opaque reference to the node data, not the
- * node data itself. (It contains pointers to both the node data and the tree.)
- * It is passed by value in the Node API.
- */
-typedef struct mpack_node_t mpack_node_t;
-
-/**
- * The storage for nodes in an MPack tree.
- *
- * You only need to use this if you intend to provide your own storage
- * for nodes instead of letting the tree allocate it.
- *
- * @ref mpack_node_data_t is 16 bytes on most common architectures (32-bit
- * and 64-bit.)
- */
-typedef struct mpack_node_data_t mpack_node_data_t;
-
-/**
- * An MPack tree parser to parse a blob or stream of MessagePack.
- *
- * When a message is parsed, the tree contains a single root node which
- * contains all parsed data. The tree and its nodes are immutable.
- */
-typedef struct mpack_tree_t mpack_tree_t;
-
-/**
- * An error handler function to be called when an error is flagged on
- * the tree.
- *
- * The error handler will only be called once on the first error flagged;
- * any subsequent node reads and errors are ignored, and the tree is
- * permanently in that error state.
- *
- * MPack is safe against non-local jumps out of error handler callbacks.
- * This means you are allowed to longjmp or throw an exception (in C++,
- * Objective-C, or with SEH) out of this callback.
- *
- * Bear in mind when using longjmp that local non-volatile variables that
- * have changed are undefined when setjmp() returns, so you can't put the
- * tree on the stack in the same activation frame as the setjmp without
- * declaring it volatile.
- *
- * You must still eventually destroy the tree. It is not destroyed
- * automatically when an error is flagged. It is safe to destroy the
- * tree within this error callback, but you will either need to perform
- * a non-local jump, or store something in your context to identify
- * that the tree is destroyed since any future accesses to it cause
- * undefined behavior.
- */
-typedef void (*mpack_tree_error_t)(mpack_tree_t* tree, mpack_error_t error);
-
-/**
- * The MPack tree's read function. It should fill the buffer with as many bytes
- * as are immediately available up to the given @c count, returning the number
- * of bytes written to the buffer.
- *
- * In case of error, it should flag an appropriate error on the reader
- * (usually @ref mpack_error_io.)
- *
- * The blocking or non-blocking behaviour of the read should match whether you
- * are using mpack_tree_parse() or mpack_tree_try_parse().
- *
- * If you are using mpack_tree_parse(), the read should block until at least
- * one byte is read. If you return 0, mpack_tree_parse() will raise @ref
- * mpack_error_io.
- *
- * If you are using mpack_tree_try_parse(), the read function can always
- * return 0, and must never block waiting for data (otherwise
- * mpack_tree_try_parse() would be equivalent to mpack_tree_parse().)
- * When you return 0, mpack_tree_try_parse() will return false without flagging
- * an error.
- */
-typedef size_t (*mpack_tree_read_t)(mpack_tree_t* tree, char* buffer, size_t count);
-
-/**
- * A teardown function to be called when the tree is destroyed.
- */
-typedef void (*mpack_tree_teardown_t)(mpack_tree_t* tree);
-
-
-
-/* Hide internals from documentation */
-/** @cond */
-
-struct mpack_node_t {
-    mpack_node_data_t* data;
-    mpack_tree_t* tree;
-};
-
-struct mpack_node_data_t {
-    mpack_type_t type;
-
-    /*
-     * The element count if the type is an array;
-     * the number of key/value pairs if the type is map;
-     * or the number of bytes if the type is str, bin or ext.
-     */
-    uint32_t len;
-
-    union
-    {
-        bool     b; /* The value if the type is bool. */
-        float    f; /* The value if the type is float. */
-        double   d; /* The value if the type is double. */
-        int64_t  i; /* The value if the type is signed int. */
-        uint64_t u; /* The value if the type is unsigned int. */
-        size_t offset; /* The byte offset for str, bin and ext */
-        mpack_node_data_t* children; /* The children for map or array */
-    } value;
-};
-
-typedef struct mpack_tree_page_t {
-    struct mpack_tree_page_t* next;
-    mpack_node_data_t nodes[1]; // variable size
-} mpack_tree_page_t;
-
-typedef enum mpack_tree_parse_state_t {
-    mpack_tree_parse_state_not_started,
-    mpack_tree_parse_state_in_progress,
-    mpack_tree_parse_state_parsed,
-} mpack_tree_parse_state_t;
-
-typedef struct mpack_level_t {
-    mpack_node_data_t* child;
-    size_t left; // children left in level
-} mpack_level_t;
-
-typedef struct mpack_tree_parser_t {
-    mpack_tree_parse_state_t state;
-
-    // We keep track of the number of "possible nodes" left in the data rather
-    // than the number of bytes.
-    //
-    // When a map or array is parsed, we ensure at least one byte for each child
-    // exists and subtract them right away. This ensures that if ever a map or
-    // array declares more elements than could possibly be contained in the data,
-    // we will error out immediately rather than allocating storage for them.
-    //
-    // For example malicious data that repeats 0xDE 0xFF 0xFF (start of a map
-    // with 65536 key-value pairs) would otherwise cause us to run out of
-    // memory. With this, the parser can allocate at most as many nodes as
-    // there are bytes in the data (plus the paging overhead, 12%.) An error
-    // will be flagged immediately if and when there isn't enough data left to
-    // fully read all children of all open compound types on the parsing stack.
-    //
-    // Once an entire message has been parsed (and there are no nodes left to
-    // parse whose bytes have been subtracted), this matches the number of left
-    // over bytes in the data.
-    size_t possible_nodes_left;
-
-    mpack_node_data_t* nodes; // next node in current page/pool
-    size_t nodes_left; // nodes left in current page/pool
-
-    size_t current_node_reserved;
-    size_t level;
-
-    #ifdef MPACK_MALLOC
-    // It's much faster to allocate the initial parsing stack inline within the
-    // parser. We replace it with a heap allocation if we need to grow it.
-    mpack_level_t* stack;
-    size_t stack_capacity;
-    bool stack_owned;
-    mpack_level_t stack_local[MPACK_NODE_INITIAL_DEPTH];
-    #else
-    // Without malloc(), we have to reserve a parsing stack the maximum allowed
-    // parsing depth.
-    mpack_level_t stack[MPACK_NODE_MAX_DEPTH_WITHOUT_MALLOC];
-    #endif
-} mpack_tree_parser_t;
-
-struct mpack_tree_t {
-    mpack_tree_error_t error_fn;    /* Function to call on error */
-    mpack_tree_read_t read_fn;      /* Function to call to read more data */
-    mpack_tree_teardown_t teardown; /* Function to teardown the context on destroy */
-    void* context;                  /* Context for tree callbacks */
-
-    mpack_node_data_t nil_node;     /* a nil node to be returned in case of error */
-    mpack_node_data_t missing_node; /* a missing node to be returned in optional lookups */
-    mpack_error_t error;
-
-    #ifdef MPACK_MALLOC
-    char* buffer;
-    size_t buffer_capacity;
-    #endif
-
-    const char* data;
-    size_t data_length; // length of data (and content of buffer, if used)
-
-    size_t size; // size in bytes of tree (usually matches data_length, but not if tree has trailing data)
-    size_t node_count; // total number of nodes in tree (across all pages)
-
-    size_t max_size;  // maximum message size
-    size_t max_nodes; // maximum nodes in a message
-
-    mpack_tree_parser_t parser;
-    mpack_node_data_t* root;
-
-    mpack_node_data_t* pool; // pool, or NULL if no pool provided
-    size_t pool_count;
-
-    #ifdef MPACK_MALLOC
-    mpack_tree_page_t* next;
-    #endif
-};
-
-// internal functions
-
-MPACK_INLINE mpack_node_t mpack_node(mpack_tree_t* tree, mpack_node_data_t* data) {
-    mpack_node_t node;
-    node.data = data;
-    node.tree = tree;
-    return node;
-}
-
-MPACK_INLINE mpack_node_data_t* mpack_node_child(mpack_node_t node, size_t child) {
-    return node.data->value.children + child;
-}
-
-MPACK_INLINE mpack_node_t mpack_tree_nil_node(mpack_tree_t* tree) {
-    return mpack_node(tree, &tree->nil_node);
-}
-
-MPACK_INLINE mpack_node_t mpack_tree_missing_node(mpack_tree_t* tree) {
-    return mpack_node(tree, &tree->missing_node);
-}
-
-/** @endcond */
-
-
-
-/**
- * @name Tree Initialization
- * @{
- */
-
-#ifdef MPACK_MALLOC
-/**
- * Initializes a tree parser with the given data.
- *
- * Configure the tree if desired, then call mpack_tree_parse() to parse it. The
- * tree will allocate pages of nodes as needed and will free them when
- * destroyed.
- *
- * The tree must be destroyed with mpack_tree_destroy().
- *
- * Any string or blob data types reference the original data, so the given data
- * pointer must remain valid until after the tree is destroyed.
- */
-void mpack_tree_init_data(mpack_tree_t* tree, const char* data, size_t length);
-
-/**
- * Deprecated.
- *
- * \deprecated Renamed to mpack_tree_init_data().
- */
-MPACK_INLINE void mpack_tree_init(mpack_tree_t* tree, const char* data, size_t length) {
-    mpack_tree_init_data(tree, data, length);
-}
-
-/**
- * Initializes a tree parser from an unbounded stream, or a stream of
- * unknown length.
- *
- * The parser can be used to read a single message from a stream of unknown
- * length, or multiple messages from an unbounded stream, allowing it to
- * be used for RPC communication. Call @ref mpack_tree_parse() to parse
- * a message from a blocking stream, or @ref mpack_tree_try_parse() for a
- * non-blocking stream.
- *
- * The stream will use a growable internal buffer to store the most recent
- * message, as well as allocated pages of nodes for the parse tree.
- *
- * Maximum allowances for message size and node count must be specified in this
- * function (since the stream is unbounded.) They can be changed later with
- * @ref mpack_tree_set_limits().
- *
- * @param tree The tree parser
- * @param read_fn The read function
- * @param context The context for the read function
- * @param max_message_size The maximum size of a message in bytes
- * @param max_message_nodes The maximum number of nodes per message. See
- *        @ref mpack_node_data_t for the size of nodes.
- *
- * @see mpack_tree_read_t
- * @see mpack_reader_context()
- */
-void mpack_tree_init_stream(mpack_tree_t* tree, mpack_tree_read_t read_fn, void* context,
-        size_t max_message_size, size_t max_message_nodes);
-#endif
-
-/**
- * Initializes a tree parser with the given data, using the given node data
- * pool to store the results.
- *
- * Configure the tree if desired, then call mpack_tree_parse() to parse it.
- *
- * If the data does not fit in the pool, @ref mpack_error_too_big will be flagged
- * on the tree.
- *
- * The tree must be destroyed with mpack_tree_destroy(), even if parsing fails.
- */
-void mpack_tree_init_pool(mpack_tree_t* tree, const char* data, size_t length,
-        mpack_node_data_t* node_pool, size_t node_pool_count);
-
-/**
- * Initializes an MPack tree directly into an error state. Use this if you
- * are writing a wrapper to another <tt>mpack_tree_init*()</tt> function which
- * can fail its setup.
- */
-void mpack_tree_init_error(mpack_tree_t* tree, mpack_error_t error);
-
-#if MPACK_STDIO
-/**
- * Initializes a tree to parse the given file. The tree must be destroyed with
- * mpack_tree_destroy(), even if parsing fails.
- *
- * The file is opened, loaded fully into memory, and closed before this call
- * returns.
- *
- * @param tree The tree to initialize
- * @param filename The filename passed to fopen() to read the file
- * @param max_bytes The maximum size of file to load, or 0 for unlimited size.
- */
-void mpack_tree_init_filename(mpack_tree_t* tree, const char* filename, size_t max_bytes);
-
-/**
- * Deprecated.
- *
- * \deprecated Renamed to mpack_tree_init_filename().
- */
-MPACK_INLINE void mpack_tree_init_file(mpack_tree_t* tree, const char* filename, size_t max_bytes) {
-    mpack_tree_init_filename(tree, filename, max_bytes);
-}
-
-/**
- * Initializes a tree to parse the given libc FILE. This can be used to
- * read from stdin, or from a file opened separately.
- *
- * The tree must be destroyed with mpack_tree_destroy(), even if parsing fails.
- *
- * The FILE is fully loaded fully into memory (and closed if requested) before
- * this call returns.
- *
- * @param tree The tree to initialize.
- * @param stdfile The FILE.
- * @param max_bytes The maximum size of file to load, or 0 for unlimited size.
- * @param close_when_done If true, fclose() will be called on the FILE when it
- *         is no longer needed. If false, the file will not be closed when
- *         reading is done.
- *
- * @warning The tree will read all data in the FILE before parsing it. If this
- *          is used on stdin, the parser will block until it is closed, even if
- *          a complete message has been written to it!
- */
-void mpack_tree_init_stdfile(mpack_tree_t* tree, FILE* stdfile, size_t max_bytes, bool close_when_done);
-#endif
-
-/**
- * @}
- */
-
-/**
- * @name Tree Functions
- * @{
- */
-
-/**
- * Sets the maximum byte size and maximum number of nodes allowed per message.
- *
- * The default is SIZE_MAX (no limit) unless @ref mpack_tree_init_stream() is
- * called (where maximums are required.)
- *
- * If a pool of nodes is used, the node limit is the lesser of this limit and
- * the pool size.
- *
- * @param tree The tree parser
- * @param max_message_size The maximum size of a message in bytes
- * @param max_message_nodes The maximum number of nodes per message. See
- *        @ref mpack_node_data_t for the size of nodes.
- */
-void mpack_tree_set_limits(mpack_tree_t* tree, size_t max_message_size,
-        size_t max_message_nodes);
-
-/**
- * Parses a MessagePack message into a tree of immutable nodes.
- *
- * If successful, the root node will be available under @ref mpack_tree_root().
- * If not, an appropriate error will be flagged.
- *
- * This can be called repeatedly to parse a series of messages from a data
- * source. When this is called, all previous nodes from this tree and their
- * contents (including the root node) are invalidated.
- *
- * If this is called with a stream (see @ref mpack_tree_init_stream()), the
- * stream must block until data is available. (Otherwise, if this is called on
- * a non-blocking stream, parsing will fail with @ref mpack_error_io when the
- * fill function returns 0.)
- *
- * There is no way to recover a tree in an error state. It must be destroyed.
- */
-void mpack_tree_parse(mpack_tree_t* tree);
-
-/**
- * Attempts to parse a MessagePack message from a non-blocking stream into a
- * tree of immutable nodes.
- *
- * A non-blocking read function must have been passed to the tree in
- * mpack_tree_init_stream().
- *
- * If this returns true, a message is available under
- * @ref mpack_tree_root(). The tree nodes and data will be valid until
- * the next time a parse is started.
- *
- * If this returns false, no message is available, because either not enough
- * data is available yet or an error has occurred. You must check the tree for
- * errors whenever this returns false. If there is no error, you should try
- * again later when more data is available. (You will want to select()/poll()
- * on the underlying socket or use some other asynchronous mechanism to
- * determine when it has data.)
- *
- * There is no way to recover a tree in an error state. It must be destroyed.
- *
- * @see mpack_tree_init_stream()
- */
-bool mpack_tree_try_parse(mpack_tree_t* tree);
-
-/**
- * Returns the root node of the tree, if the tree is not in an error state.
- * Returns a nil node otherwise.
- *
- * @warning You must call mpack_tree_parse() before calling this. If
- * @ref mpack_tree_parse() was never called, the tree will assert.
- */
-mpack_node_t mpack_tree_root(mpack_tree_t* tree);
-
-/**
- * Returns the error state of the tree.
- */
-MPACK_INLINE mpack_error_t mpack_tree_error(mpack_tree_t* tree) {
-    return tree->error;
-}
-
-/**
- * Returns the size in bytes of the current parsed message.
- *
- * If there is something in the buffer after the MessagePack object, this can
- * be used to find it.
- *
- * This is zero if an error occurred during tree parsing (since the
- * portion of the data that the first complete object occupies cannot
- * be determined if the data is invalid or corrupted.)
- */
-MPACK_INLINE size_t mpack_tree_size(mpack_tree_t* tree) {
-    return tree->size;
-}
-
-/**
- * Destroys the tree.
- */
-mpack_error_t mpack_tree_destroy(mpack_tree_t* tree);
-
-/**
- * Sets the custom pointer to pass to the tree callbacks, such as teardown.
- *
- * @param tree The MPack tree.
- * @param context User data to pass to the tree callbacks.
- *
- * @see mpack_reader_context()
- */
-MPACK_INLINE void mpack_tree_set_context(mpack_tree_t* tree, void* context) {
-    tree->context = context;
-}
-
-/**
- * Returns the custom context for tree callbacks.
- *
- * @see mpack_tree_set_context
- * @see mpack_tree_init_stream
- */
-MPACK_INLINE void* mpack_tree_context(mpack_tree_t* tree) {
-    return tree->context;
-}
-
-/**
- * Sets the error function to call when an error is flagged on the tree.
- *
- * This should normally be used with mpack_tree_set_context() to register
- * a custom pointer to pass to the error function.
- *
- * See the definition of mpack_tree_error_t for more information about
- * what you can do from an error callback.
- *
- * @see mpack_tree_error_t
- * @param tree The MPack tree.
- * @param error_fn The function to call when an error is flagged on the tree.
- */
-MPACK_INLINE void mpack_tree_set_error_handler(mpack_tree_t* tree, mpack_tree_error_t error_fn) {
-    tree->error_fn = error_fn;
-}
-
-/**
- * Sets the teardown function to call when the tree is destroyed.
- *
- * This should normally be used with mpack_tree_set_context() to register
- * a custom pointer to pass to the teardown function.
- *
- * @param tree The MPack tree.
- * @param teardown The function to call when the tree is destroyed.
- */
-MPACK_INLINE void mpack_tree_set_teardown(mpack_tree_t* tree, mpack_tree_teardown_t teardown) {
-    tree->teardown = teardown;
-}
-
-/**
- * Places the tree in the given error state, calling the error callback if one
- * is set.
- *
- * This allows you to externally flag errors, for example if you are validating
- * data as you read it.
- *
- * If the tree is already in an error state, this call is ignored and no
- * error callback is called.
- */
-void mpack_tree_flag_error(mpack_tree_t* tree, mpack_error_t error);
-
-/**
- * @}
- */
-
-/**
- * @name Node Core Functions
- * @{
- */
-
-/**
- * Places the node's tree in the given error state, calling the error callback
- * if one is set.
- *
- * This allows you to externally flag errors, for example if you are validating
- * data as you read it.
- *
- * If the tree is already in an error state, this call is ignored and no
- * error callback is called.
- */
-void mpack_node_flag_error(mpack_node_t node, mpack_error_t error);
-
-/**
- * Returns the error state of the node's tree.
- */
-MPACK_INLINE mpack_error_t mpack_node_error(mpack_node_t node) {
-    return mpack_tree_error(node.tree);
-}
-
-/**
- * Returns a tag describing the given node, or a nil tag if the
- * tree is in an error state.
- */
-mpack_tag_t mpack_node_tag(mpack_node_t node);
-
-/** @cond */
-
-#if MPACK_DEBUG && MPACK_STDIO
-/*
- * Converts a node to a pseudo-JSON string for debugging purposes, placing the
- * result in the given buffer with a null-terminator.
- *
- * If the buffer does not have enough space, the result will be truncated (but
- * it is guaranteed to be null-terminated.)
- *
- * This is only available in debug mode, and only if stdio is available (since
- * it uses snprintf().) It's strictly for debugging purposes.
- */
-void mpack_node_print_to_buffer(mpack_node_t node, char* buffer, size_t buffer_size);
-
-/*
- * Converts a node to pseudo-JSON for debugging purposes, calling the given
- * callback as many times as is necessary to output the character data.
- *
- * No null-terminator or trailing newline will be written.
- *
- * This is only available in debug mode, and only if stdio is available (since
- * it uses snprintf().) It's strictly for debugging purposes.
- */
-void mpack_node_print_to_callback(mpack_node_t node, mpack_print_callback_t callback, void* context);
-
-/*
- * Converts a node to pseudo-JSON for debugging purposes
- * and pretty-prints it to the given file.
- *
- * This is only available in debug mode, and only if stdio is available (since
- * it uses snprintf().) It's strictly for debugging purposes.
- */
-void mpack_node_print_to_file(mpack_node_t node, FILE* file);
-
-/*
- * Converts a node to pseudo-JSON for debugging purposes
- * and pretty-prints it to stdout.
- *
- * This is only available in debug mode, and only if stdio is available (since
- * it uses snprintf().) It's strictly for debugging purposes.
- */
-MPACK_INLINE void mpack_node_print_to_stdout(mpack_node_t node) {
-    mpack_node_print_to_file(node, stdout);
-}
-
-/*
- * Deprecated.
- *
- * \deprecated Renamed to mpack_node_print_to_stdout().
- */
-MPACK_INLINE void mpack_node_print(mpack_node_t node) {
-    mpack_node_print_to_stdout(node);
-}
-#endif
-
-/** @endcond */
-
-/**
- * @}
- */
-
-/**
- * @name Node Primitive Value Functions
- * @{
- */
-
-/**
- * Returns the type of the node.
- */
-mpack_type_t mpack_node_type(mpack_node_t node);
-
-/**
- * Returns true if the given node is a nil node; false otherwise.
- *
- * To ensure that a node is nil and flag an error otherwise, use
- * mpack_node_nil().
- */
-bool mpack_node_is_nil(mpack_node_t node);
-
-/**
- * Returns true if the given node handle indicates a missing node; false otherwise.
- *
- * To ensure that a node is missing and flag an error otherwise, use
- * mpack_node_missing().
- */
-bool mpack_node_is_missing(mpack_node_t node);
-
-/**
- * Checks that the given node is of nil type, raising @ref mpack_error_type
- * otherwise.
- *
- * Use mpack_node_is_nil() to return whether the node is nil.
- */
-void mpack_node_nil(mpack_node_t node);
-
-/**
- * Checks that the given node indicates a missing node, raising @ref
- * mpack_error_type otherwise.
- *
- * Use mpack_node_is_missing() to return whether the node is missing.
- */
-void mpack_node_missing(mpack_node_t node);
-
-/**
- * Returns the bool value of the node. If this node is not of the correct
- * type, false is returned and mpack_error_type is raised.
- */
-bool mpack_node_bool(mpack_node_t node);
-
-/**
- * Checks if the given node is of bool type with value true, raising
- * mpack_error_type otherwise.
- */
-void mpack_node_true(mpack_node_t node);
-
-/**
- * Checks if the given node is of bool type with value false, raising
- * mpack_error_type otherwise.
- */
-void mpack_node_false(mpack_node_t node);
-
-/**
- * Returns the 8-bit unsigned value of the node. If this node is not
- * of a compatible type, @ref mpack_error_type is raised and zero is returned.
- */
-uint8_t mpack_node_u8(mpack_node_t node);
-
-/**
- * Returns the 8-bit signed value of the node. If this node is not
- * of a compatible type, @ref mpack_error_type is raised and zero is returned.
- */
-int8_t mpack_node_i8(mpack_node_t node);
-
-/**
- * Returns the 16-bit unsigned value of the node. If this node is not
- * of a compatible type, @ref mpack_error_type is raised and zero is returned.
- */
-uint16_t mpack_node_u16(mpack_node_t node);
-
-/**
- * Returns the 16-bit signed value of the node. If this node is not
- * of a compatible type, @ref mpack_error_type is raised and zero is returned.
- */
-int16_t mpack_node_i16(mpack_node_t node);
-
-/**
- * Returns the 32-bit unsigned value of the node. If this node is not
- * of a compatible type, @ref mpack_error_type is raised and zero is returned.
- */
-uint32_t mpack_node_u32(mpack_node_t node);
-
-/**
- * Returns the 32-bit signed value of the node. If this node is not
- * of a compatible type, @ref mpack_error_type is raised and zero is returned.
- */
-int32_t mpack_node_i32(mpack_node_t node);
-
-/**
- * Returns the 64-bit unsigned value of the node. If this node is not
- * of a compatible type, @ref mpack_error_type is raised, and zero is returned.
- */
-uint64_t mpack_node_u64(mpack_node_t node);
-
-/**
- * Returns the 64-bit signed value of the node. If this node is not
- * of a compatible type, @ref mpack_error_type is raised and zero is returned.
- */
-int64_t mpack_node_i64(mpack_node_t node);
-
-/**
- * Returns the unsigned int value of the node.
- *
- * Returns zero if an error occurs.
- *
- * @throws mpack_error_type If the node is not an integer type or does not fit in the range of an unsigned int
- */
-unsigned int mpack_node_uint(mpack_node_t node);
-
-/**
- * Returns the int value of the node.
- *
- * Returns zero if an error occurs.
- *
- * @throws mpack_error_type If the node is not an integer type or does not fit in the range of an int
- */
-int mpack_node_int(mpack_node_t node);
-
-/**
- * Returns the float value of the node. The underlying value can be an
- * integer, float or double; the value is converted to a float.
- *
- * @note Reading a double or a large integer with this function can incur a
- * loss of precision.
- *
- * @throws mpack_error_type if the underlying value is not a float, double or integer.
- */
-float mpack_node_float(mpack_node_t node);
-
-/**
- * Returns the double value of the node. The underlying value can be an
- * integer, float or double; the value is converted to a double.
- *
- * @note Reading a very large integer with this function can incur a
- * loss of precision.
- *
- * @throws mpack_error_type if the underlying value is not a float, double or integer.
- */
-double mpack_node_double(mpack_node_t node);
-
-/**
- * Returns the float value of the node. The underlying value must be a float,
- * not a double or an integer. This ensures no loss of precision can occur.
- *
- * @throws mpack_error_type if the underlying value is not a float.
- */
-float mpack_node_float_strict(mpack_node_t node);
-
-/**
- * Returns the double value of the node. The underlying value must be a float
- * or double, not an integer. This ensures no loss of precision can occur.
- *
- * @throws mpack_error_type if the underlying value is not a float or double.
- */
-double mpack_node_double_strict(mpack_node_t node);
-
-#if MPACK_EXTENSIONS
-/**
- * Returns a timestamp.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- *
- * @throws mpack_error_type if the underlying value is not a timestamp.
- */
-mpack_timestamp_t mpack_node_timestamp(mpack_node_t node);
-
-/**
- * Returns a timestamp's (signed) seconds since 1970-01-01T00:00:00Z.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- *
- * @throws mpack_error_type if the underlying value is not a timestamp.
- */
-int64_t mpack_node_timestamp_seconds(mpack_node_t node);
-
-/**
- * Returns a timestamp's additional nanoseconds.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- *
- * @return A nanosecond count between 0 and 999,999,999 inclusive.
- * @throws mpack_error_type if the underlying value is not a timestamp.
- */
-uint32_t mpack_node_timestamp_nanoseconds(mpack_node_t node);
-#endif
-
-/**
- * @}
- */
-
-/**
- * @name Node String and Data Functions
- * @{
- */
-
-/**
- * Checks that the given node contains a valid UTF-8 string.
- *
- * If the string is invalid, this flags an error, which would cause subsequent calls
- * to mpack_node_str() to return NULL and mpack_node_strlen() to return zero. So you
- * can check the node for error immediately after calling this, or you can call those
- * functions to use the data anyway and check for errors later.
- *
- * @throws mpack_error_type If this node is not a string or does not contain valid UTF-8.
- *
- * @param node The string node to test
- *
- * @see mpack_node_str()
- * @see mpack_node_strlen()
- */
-void mpack_node_check_utf8(mpack_node_t node);
-
-/**
- * Checks that the given node contains a valid UTF-8 string with no NUL bytes.
- *
- * This does not check that the string has a null-terminator! It only checks whether
- * the string could safely be represented as a C-string by appending a null-terminator.
- * (If the string does already contain a null-terminator, this will flag an error.)
- *
- * This is performed automatically by other UTF-8 cstr helper functions. Only
- * call this if you will do something else with the data directly, but you still
- * want to ensure it will be valid as a UTF-8 C-string.
- *
- * @throws mpack_error_type If this node is not a string, does not contain valid UTF-8,
- *     or contains a NUL byte.
- *
- * @param node The string node to test
- *
- * @see mpack_node_str()
- * @see mpack_node_strlen()
- * @see mpack_node_copy_utf8_cstr()
- * @see mpack_node_utf8_cstr_alloc()
- */
-void mpack_node_check_utf8_cstr(mpack_node_t node);
-
-#if MPACK_EXTENSIONS
-/**
- * Returns the extension type of the given ext node.
- *
- * This returns zero if the tree is in an error state.
- *
- * @note This requires @ref MPACK_EXTENSIONS.
- */
-int8_t mpack_node_exttype(mpack_node_t node);
-#endif
-
-/**
- * Returns the number of bytes in the given bin node.
- *
- * This returns zero if the tree is in an error state.
- *
- * If this node is not a bin, @ref mpack_error_type is raised and zero is returned.
- */
-size_t mpack_node_bin_size(mpack_node_t node);
-
-/**
- * Returns the length of the given str, bin or ext node.
- *
- * This returns zero if the tree is in an error state.
- *
- * If this node is not a str, bin or map, @ref mpack_error_type is raised and zero
- * is returned.
- */
-uint32_t mpack_node_data_len(mpack_node_t node);
-
-/**
- * Returns the length in bytes of the given string node. This does not
- * include any null-terminator.
- *
- * This returns zero if the tree is in an error state.
- *
- * If this node is not a str, @ref mpack_error_type is raised and zero is returned.
- */
-size_t mpack_node_strlen(mpack_node_t node);
-
-/**
- * Returns a pointer to the data contained by this node, ensuring the node is a
- * string.
- *
- * @warning Strings are not null-terminated! Use one of the cstr functions
- * to get a null-terminated string.
- *
- * The pointer is valid as long as the data backing the tree is valid.
- *
- * If this node is not a string, @ref mpack_error_type is raised and @c NULL is returned.
- *
- * @see mpack_node_copy_cstr()
- * @see mpack_node_cstr_alloc()
- * @see mpack_node_utf8_cstr_alloc()
- */
-const char* mpack_node_str(mpack_node_t node);
-
-/**
- * Returns a pointer to the data contained by this node.
- *
- * @note Strings are not null-terminated! Use one of the cstr functions
- * to get a null-terminated string.
- *
- * The pointer is valid as long as the data backing the tree is valid.
- *
- * If this node is not of a str, bin or map, @ref mpack_error_type is raised, and
- * @c NULL is returned.
- *
- * @see mpack_node_copy_cstr()
- * @see mpack_node_cstr_alloc()
- * @see mpack_node_utf8_cstr_alloc()
- */
-const char* mpack_node_data(mpack_node_t node);
-
-/**
- * Returns a pointer to the data contained by this bin node.
- *
- * The pointer is valid as long as the data backing the tree is valid.
- *
- * If this node is not a bin, @ref mpack_error_type is raised and @c NULL is
- * returned.
- */
-const char* mpack_node_bin_data(mpack_node_t node);
-
-/**
- * Copies the bytes contained by this node into the given buffer, returning the
- * number of bytes in the node.
- *
- * @throws mpack_error_type If this node is not a str, bin or ext type
- * @throws mpack_error_too_big If the string does not fit in the given buffer
- *
- * @param node The string node from which to copy data
- * @param buffer A buffer in which to copy the node's bytes
- * @param bufsize The size of the given buffer
- *
- * @return The number of bytes in the node, or zero if an error occurs.
- */
-size_t mpack_node_copy_data(mpack_node_t node, char* buffer, size_t bufsize);
-
-/**
- * Checks that the given node contains a valid UTF-8 string and copies the
- * string into the given buffer, returning the number of bytes in the string.
- *
- * @throws mpack_error_type If this node is not a string
- * @throws mpack_error_too_big If the string does not fit in the given buffer
- *
- * @param node The string node from which to copy data
- * @param buffer A buffer in which to copy the node's bytes
- * @param bufsize The size of the given buffer
- *
- * @return The number of bytes in the node, or zero if an error occurs.
- */
-size_t mpack_node_copy_utf8(mpack_node_t node, char* buffer, size_t bufsize);
-
-/**
- * Checks that the given node contains a string with no NUL bytes, copies the string
- * into the given buffer, and adds a null terminator.
- *
- * If this node is not of a string type, @ref mpack_error_type is raised. If the string
- * does not fit, @ref mpack_error_data is raised.
- *
- * If any error occurs, the buffer will contain an empty null-terminated string.
- *
- * @param node The string node from which to copy data
- * @param buffer A buffer in which to copy the node's string
- * @param size The size of the given buffer
- */
-void mpack_node_copy_cstr(mpack_node_t node, char* buffer, size_t size);
-
-/**
- * Checks that the given node contains a valid UTF-8 string with no NUL bytes,
- * copies the string into the given buffer, and adds a null terminator.
- *
- * If this node is not of a string type, @ref mpack_error_type is raised. If the string
- * does not fit, @ref mpack_error_data is raised.
- *
- * If any error occurs, the buffer will contain an empty null-terminated string.
- *
- * @param node The string node from which to copy data
- * @param buffer A buffer in which to copy the node's string
- * @param size The size of the given buffer
- */
-void mpack_node_copy_utf8_cstr(mpack_node_t node, char* buffer, size_t size);
-
-#ifdef MPACK_MALLOC
-/**
- * Allocates a new chunk of data using MPACK_MALLOC() with the bytes
- * contained by this node.
- *
- * The allocated data must be freed with MPACK_FREE() (or simply free()
- * if MPack's allocator hasn't been customized.)
- *
- * @throws mpack_error_type If this node is not a str, bin or ext type
- * @throws mpack_error_too_big If the size of the data is larger than the
- *     given maximum size
- * @throws mpack_error_memory If an allocation failure occurs
- *
- * @param node The node from which to allocate and copy data
- * @param maxsize The maximum size to allocate
- *
- * @return The allocated data, or NULL if any error occurs.
- */
-char* mpack_node_data_alloc(mpack_node_t node, size_t maxsize);
-
-/**
- * Allocates a new null-terminated string using MPACK_MALLOC() with the string
- * contained by this node.
- *
- * The allocated string must be freed with MPACK_FREE() (or simply free()
- * if MPack's allocator hasn't been customized.)
- *
- * @throws mpack_error_type If this node is not a string or contains NUL bytes
- * @throws mpack_error_too_big If the size of the string plus null-terminator
- *     is larger than the given maximum size
- * @throws mpack_error_memory If an allocation failure occurs
- *
- * @param node The node from which to allocate and copy string data
- * @param maxsize The maximum size to allocate, including the null-terminator
- *
- * @return The allocated string, or NULL if any error occurs.
- */
-char* mpack_node_cstr_alloc(mpack_node_t node, size_t maxsize);
-
-/**
- * Allocates a new null-terminated string using MPACK_MALLOC() with the UTF-8
- * string contained by this node.
- *
- * The allocated string must be freed with MPACK_FREE() (or simply free()
- * if MPack's allocator hasn't been customized.)
- *
- * @throws mpack_error_type If this node is not a string, is not valid UTF-8,
- *     or contains NUL bytes
- * @throws mpack_error_too_big If the size of the string plus null-terminator
- *     is larger than the given maximum size
- * @throws mpack_error_memory If an allocation failure occurs
- *
- * @param node The node from which to allocate and copy string data
- * @param maxsize The maximum size to allocate, including the null-terminator
- *
- * @return The allocated string, or NULL if any error occurs.
- */
-char* mpack_node_utf8_cstr_alloc(mpack_node_t node, size_t maxsize);
-#endif
-
-/**
- * Searches the given string array for a string matching the given
- * node and returns its index.
- *
- * If the node does not match any of the given strings,
- * @ref mpack_error_type is flagged. Use mpack_node_enum_optional()
- * if you want to allow values other than the given strings.
- *
- * If any error occurs or if the tree is in an error state, @a count
- * is returned.
- *
- * This can be used to quickly parse a string into an enum when the
- * enum values range from 0 to @a count-1. If the last value in the
- * enum is a special "count" value, it can be passed as the count,
- * and the return value can be cast directly to the enum type.
- *
- * @code{.c}
- * typedef enum           { APPLE ,  BANANA ,  ORANGE , COUNT} fruit_t;
- * const char* fruits[] = {"apple", "banana", "orange"};
- *
- * fruit_t fruit = (fruit_t)mpack_node_enum(node, fruits, COUNT);
- * @endcode
- *
- * @param node The node
- * @param strings An array of expected strings of length count
- * @param count The number of strings
- * @return The index of the matched string, or @a count in case of error
- */
-size_t mpack_node_enum(mpack_node_t node, const char* strings[], size_t count);
-
-/**
- * Searches the given string array for a string matching the given node,
- * returning its index or @a count if no strings match.
- *
- * If the value is not a string, or it does not match any of the
- * given strings, @a count is returned and no error is flagged.
- *
- * If any error occurs or if the tree is in an error state, @a count
- * is returned.
- *
- * This can be used to quickly parse a string into an enum when the
- * enum values range from 0 to @a count-1. If the last value in the
- * enum is a special "count" value, it can be passed as the count,
- * and the return value can be cast directly to the enum type.
- *
- * @code{.c}
- * typedef enum           { APPLE ,  BANANA ,  ORANGE , COUNT} fruit_t;
- * const char* fruits[] = {"apple", "banana", "orange"};
- *
- * fruit_t fruit = (fruit_t)mpack_node_enum_optional(node, fruits, COUNT);
- * @endcode
- *
- * @param node The node
- * @param strings An array of expected strings of length count
- * @param count The number of strings
- * @return The index of the matched string, or @a count in case of error
- */
-size_t mpack_node_enum_optional(mpack_node_t node, const char* strings[], size_t count);
-
-/**
- * @}
- */
-
-/**
- * @name Compound Node Functions
- * @{
- */
-
-/**
- * Returns the length of the given array node. Raises mpack_error_type
- * and returns 0 if the given node is not an array.
- */
-size_t mpack_node_array_length(mpack_node_t node);
-
-/**
- * Returns the node in the given array at the given index. If the node
- * is not an array, @ref mpack_error_type is raised and a nil node is returned.
- * If the given index is out of bounds, @ref mpack_error_data is raised and
- * a nil node is returned.
- */
-mpack_node_t mpack_node_array_at(mpack_node_t node, size_t index);
-
-/**
- * Returns the number of key/value pairs in the given map node. Raises
- * mpack_error_type and returns 0 if the given node is not a map.
- */
-size_t mpack_node_map_count(mpack_node_t node);
-
-/**
- * Returns the key node in the given map at the given index.
- *
- * A nil node is returned in case of error.
- *
- * @throws mpack_error_type if the node is not a map
- * @throws mpack_error_data if the given index is out of bounds
- */
-mpack_node_t mpack_node_map_key_at(mpack_node_t node, size_t index);
-
-/**
- * Returns the value node in the given map at the given index.
- *
- * A nil node is returned in case of error.
- *
- * @throws mpack_error_type if the node is not a map
- * @throws mpack_error_data if the given index is out of bounds
- */
-mpack_node_t mpack_node_map_value_at(mpack_node_t node, size_t index);
-
-/**
- * Returns the value node in the given map for the given integer key.
- *
- * The key must exist within the map. Use mpack_node_map_int_optional() to
- * check for optional keys.
- *
- * The key must be unique. An error is flagged if the node has multiple
- * entries with the given key.
- *
- * @throws mpack_error_type If the node is not a map
- * @throws mpack_error_data If the node does not contain exactly one entry with the given key
- *
- * @return The value node for the given key, or a nil node in case of error
- */
-mpack_node_t mpack_node_map_int(mpack_node_t node, int64_t num);
-
-/**
- * Returns the value node in the given map for the given integer key, or a
- * missing node if the map does not contain the given key.
- *
- * The key must be unique. An error is flagged if the node has multiple
- * entries with the given key.
- *
- * @throws mpack_error_type If the node is not a map
- * @throws mpack_error_data If the node contains more than one entry with the given key
- *
- * @return The value node for the given key, or a missing node if the key does
- *         not exist, or a nil node in case of error
- *
- * @see mpack_node_is_missing()
- */
-mpack_node_t mpack_node_map_int_optional(mpack_node_t node, int64_t num);
-
-/**
- * Returns the value node in the given map for the given unsigned integer key.
- *
- * The key must exist within the map. Use mpack_node_map_uint_optional() to
- * check for optional keys.
- *
- * The key must be unique. An error is flagged if the node has multiple
- * entries with the given key.
- *
- * @throws mpack_error_type If the node is not a map
- * @throws mpack_error_data If the node does not contain exactly one entry with the given key
- *
- * @return The value node for the given key, or a nil node in case of error
- */
-mpack_node_t mpack_node_map_uint(mpack_node_t node, uint64_t num);
-
-/**
- * Returns the value node in the given map for the given unsigned integer
- * key, or a nil node if the map does not contain the given key.
- *
- * The key must be unique. An error is flagged if the node has multiple
- * entries with the given key.
- *
- * @throws mpack_error_type If the node is not a map
- * @throws mpack_error_data If the node contains more than one entry with the given key
- *
- * @return The value node for the given key, or a missing node if the key does
- *         not exist, or a nil node in case of error
- *
- * @see mpack_node_is_missing()
- */
-mpack_node_t mpack_node_map_uint_optional(mpack_node_t node, uint64_t num);
-
-/**
- * Returns the value node in the given map for the given string key.
- *
- * The key must exist within the map. Use mpack_node_map_str_optional() to
- * check for optional keys.
- *
- * The key must be unique. An error is flagged if the node has multiple
- * entries with the given key.
- *
- * @throws mpack_error_type If the node is not a map
- * @throws mpack_error_data If the node does not contain exactly one entry with the given key
- *
- * @return The value node for the given key, or a nil node in case of error
- */
-mpack_node_t mpack_node_map_str(mpack_node_t node, const char* str, size_t length);
-
-/**
- * Returns the value node in the given map for the given string key, or a nil
- * node if the map does not contain the given key.
- *
- * The key must be unique. An error is flagged if the node has multiple
- * entries with the given key.
- *
- * @throws mpack_error_type If the node is not a map
- * @throws mpack_error_data If the node contains more than one entry with the given key
- *
- * @return The value node for the given key, or a missing node if the key does
- *         not exist, or a nil node in case of error
- *
- * @see mpack_node_is_missing()
- */
-mpack_node_t mpack_node_map_str_optional(mpack_node_t node, const char* str, size_t length);
-
-/**
- * Returns the value node in the given map for the given null-terminated
- * string key.
- *
- * The key must exist within the map. Use mpack_node_map_cstr_optional() to
- * check for optional keys.
- *
- * The key must be unique. An error is flagged if the node has multiple
- * entries with the given key.
- *
- * @throws mpack_error_type If the node is not a map
- * @throws mpack_error_data If the node does not contain exactly one entry with the given key
- *
- * @return The value node for the given key, or a nil node in case of error
- */
-mpack_node_t mpack_node_map_cstr(mpack_node_t node, const char* cstr);
-
-/**
- * Returns the value node in the given map for the given null-terminated
- * string key, or a nil node if the map does not contain the given key.
- *
- * The key must be unique. An error is flagged if the node has multiple
- * entries with the given key.
- *
- * @throws mpack_error_type If the node is not a map
- * @throws mpack_error_data If the node contains more than one entry with the given key
- *
- * @return The value node for the given key, or a missing node if the key does
- *         not exist, or a nil node in case of error
- *
- * @see mpack_node_is_missing()
- */
-mpack_node_t mpack_node_map_cstr_optional(mpack_node_t node, const char* cstr);
-
-/**
- * Returns true if the given node map contains exactly one entry with the
- * given integer key.
- *
- * The key must be unique. An error is flagged if the node has multiple
- * entries with the given key.
- *
- * @throws mpack_error_type If the node is not a map
- * @throws mpack_error_data If the node contains more than one entry with the given key
- */
-bool mpack_node_map_contains_int(mpack_node_t node, int64_t num);
-
-/**
- * Returns true if the given node map contains exactly one entry with the
- * given unsigned integer key.
- *
- * The key must be unique. An error is flagged if the node has multiple
- * entries with the given key.
- *
- * @throws mpack_error_type If the node is not a map
- * @throws mpack_error_data If the node contains more than one entry with the given key
- */
-bool mpack_node_map_contains_uint(mpack_node_t node, uint64_t num);
-
-/**
- * Returns true if the given node map contains exactly one entry with the
- * given string key.
- *
- * The key must be unique. An error is flagged if the node has multiple
- * entries with the given key.
- *
- * @throws mpack_error_type If the node is not a map
- * @throws mpack_error_data If the node contains more than one entry with the given key
- */
-bool mpack_node_map_contains_str(mpack_node_t node, const char* str, size_t length);
-
-/**
- * Returns true if the given node map contains exactly one entry with the
- * given null-terminated string key.
- *
- * The key must be unique. An error is flagged if the node has multiple
- * entries with the given key.
- *
- * @throws mpack_error_type If the node is not a map
- * @throws mpack_error_data If the node contains more than one entry with the given key
- */
-bool mpack_node_map_contains_cstr(mpack_node_t node, const char* cstr);
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-#endif
-
-MPACK_HEADER_END
-
-#endif
-
-
-#endif
-
diff --git a/php-pecl-datadog-trace.spec b/php-pecl-datadog-trace.spec
index d503754..6a3e204 100644
--- a/php-pecl-datadog-trace.spec
+++ b/php-pecl-datadog-trace.spec
@@ -35,20 +35,19 @@
 Summary:        APM and distributed tracing for PHP
 Name:           %{?sub_prefix}php-pecl-datadog-trace
 Version:        0.18.0
-Release:        1%{?dist}%{!?scl:%{!?nophptag:%(%{__php} -r 'echo ".".PHP_MAJOR_VERSION.".".PHP_MINOR_VERSION;')}}
+Release:        2%{?dist}%{!?scl:%{!?nophptag:%(%{__php} -r 'echo ".".PHP_MAJOR_VERSION.".".PHP_MINOR_VERSION;')}}
 License:        MIT
 URL:            http://pecl.php.net/package/%{proj_name}
 Source0:        http://pecl.php.net/get/%{proj_name}-%{version}.tgz
 
-Source1:        https://raw.githubusercontent.com/DataDog/dd-trace-php/0.18.0/src/ext/mpack/LICENSE
-Source2:        https://raw.githubusercontent.com/DataDog/dd-trace-php/0.18.0/src/ext/mpack/mpack.c
-Source3:        https://raw.githubusercontent.com/DataDog/dd-trace-php/0.18.0/src/ext/mpack/mpack.h
+Patch0:         https://patch-diff.githubusercontent.com/raw/DataDog/dd-trace-php/pull/396.patch
 
 BuildRequires:  %{?dtsprefix}gcc
 BuildRequires:  %{?scl_prefix}php-devel
 BuildRequires:  %{?scl_prefix}php-pear
 # For tests
 BuildRequires:  %{?scl_prefix}php-json
+BuildRequires:  %{?scl_prefix}php-posix
 
 Requires:       %{?scl_prefix}php(zend-abi) = %{php_zend_api}
 Requires:       %{?scl_prefix}php(api) = %{php_core_api}
@@ -98,14 +97,12 @@ mv %{proj_name}-%{version} NTS
 
 # Don't install tests
 sed -e 's/role="test"/role="src"/' \
-    %{?_licensedir:-e '/LICENSe/s/role="doc"/role="src"/' } \
+    %{?_licensedir:-e '/LICENSE/s/role="doc"/role="src"/' } \
     -i package.xml
 
 cd NTS
-# https://github.com/DataDog/dd-trace-php/issues/393
-mkdir src/ext/mpack
-cp %{SOURCE2} %{SOURCE3} src/ext/mpack
-cp %{SOURCE1} LICENSE.mpack
+cp src/ext/mpack/LICENSE LICENSE.mpack
+%patch0 -p1 -b .pr396
 
 : Sanity check, really often broken
 extver=$(sed -n '/#define PHP_DDTRACE_VERSION /{s/.* "//;s/".*$//;p}' src/ext/version.h)
@@ -136,7 +133,6 @@ EOF
 
 %build
 %{?dtsenable}
-export CFLAGS="%{optflags} -std=c99"
 
 cd NTS
 %{_bindir}/phpize
@@ -181,10 +177,15 @@ done
 %check
 %if %{__isa_bits} < 64
 rm ?TS/tests/ext/dd_trace_serialize_msgpack.phpt
+rm ?TS/tests/ext/dd_trace_serialize_msgpack_error.phpt
+rm ?TS/tests/ext/dd_trace_serialize_msgpack_error_strict.phpt
+rm ?TS/tests/ext/segfault_backtrace_disabled.phpt
+rm ?TS/tests/ext/segfault_backtrace_disabled_via_env_enabled_in_ini.phpt
 %endif
 
 MOD="-n"
-[ -f %{php_extdir}/json.so ] && MOD="$MOD -d extension=json.so"
+[ -f %{php_extdir}/json.so ]  && MOD="$MOD -d extension=json.so"
+[ -f %{php_extdir}/posix.so ] && MOD="$MOD -d extension=posix.so"
 
 cd NTS
 : Minimal load test for NTS extension
@@ -248,6 +249,9 @@ fi
 
 
 %changelog
+* Tue Apr  9 2019 Remi Collet <remi@remirepo.net> - 0.18.0-2
+- test build
+
 * Tue Apr  9 2019 Remi Collet <remi@remirepo.net> - 0.18.0-1
 - update to 0.18.0
 - open https://github.com/DataDog/dd-trace-php/issues/393