diff options
| -rw-r--r-- | 396.patch | 22 | ||||
| -rw-r--r-- | LICENSE | 22 | ||||
| -rw-r--r-- | mpack.c | 6442 | ||||
| -rw-r--r-- | mpack.h | 7151 | ||||
| -rw-r--r-- | php-pecl-datadog-trace.spec | 26 |
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 |