edhoc 1.0.4 → 1.1.0

package/external/libedhoc/externals/zcbor/src/zcbor_decode.c

@@ -8,15 +8,19 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <string.h>
+#include <inttypes.h>
 #include "zcbor_decode.h"
 #include "zcbor_common.h"
+#include "zcbor_print.h"
 
 
 /** Return value length from additional value.
  */
 static size_t additional_len(uint8_t additional)
 {
-	if (ZCBOR_VALUE_IS_1_BYTE <= additional && additional <= ZCBOR_VALUE_IS_8_BYTES) {
+	if (additional <= ZCBOR_VALUE_IN_HEADER) {
+		return 0;
+	} else if (ZCBOR_VALUE_IS_1_BYTE <= additional && additional <= ZCBOR_VALUE_IS_8_BYTES) {
 		/* 24 => 1
 		 * 25 => 2
 		 * 26 => 4
@@ -24,24 +28,9 @@ static size_t additional_len(uint8_t additional)
 		 */
 		return 1U << (additional - ZCBOR_VALUE_IS_1_BYTE);
 	}
-	return 0;
+	return 0xF;
 }
 
-/** Extract the major type, i.e. the first 3 bits of the header byte. */
-#define MAJOR_TYPE(header_byte) ((zcbor_major_type_t)(((header_byte) >> 5) & 0x7))
-
-/** Extract the additional info, i.e. the last 5 bits of the header byte. */
-#define ADDITIONAL(header_byte) ((header_byte) & 0x1F)
-
-
-#define FAIL_AND_DECR_IF(expr, err) \
-do {\
-	if (expr) { \
-		(state->payload)--; \
-		ZCBOR_ERR(err); \
-	} \
-} while(0)
-
 
 static bool initial_checks(zcbor_state_t *state)
 {
@@ -56,7 +45,7 @@ static bool type_check(zcbor_state_t *state, zcbor_major_type_t exp_major_type)
 	if (!initial_checks(state)) {
 		ZCBOR_FAIL();
 	}
-	zcbor_major_type_t major_type = MAJOR_TYPE(*state->payload);
+	zcbor_major_type_t major_type = ZCBOR_MAJOR_TYPE(*state->payload);
 
 	if (major_type != exp_major_type) {
 		ZCBOR_ERR(ZCBOR_ERR_WRONG_TYPE);
@@ -99,6 +88,20 @@ do { \
 	ZCBOR_FAIL(); \
 } while(0)
 
+#define PRINT_FUNC() zcbor_log("%s ", __func__);
+
+
+static void endian_copy(uint8_t *dst, const uint8_t *src, size_t src_len)
+{
+#ifdef ZCBOR_BIG_ENDIAN
+	memcpy(dst, src, src_len);
+#else
+	for (size_t i = 0; i < src_len; i++) {
+		dst[i] = src[src_len - 1 - i];
+	}
+#endif /* ZCBOR_BIG_ENDIAN */
+}
+
 
 /** Get a single value.
  *
@@ -116,61 +119,55 @@ do { \
  *          succeeds. If not, they are left unchanged.
  *
  *          CBOR values are always big-endian, so this function converts from
- *          big to little-endian if necessary (@ref CONFIG_BIG_ENDIAN).
+ *          big to little-endian if necessary (@ref ZCBOR_BIG_ENDIAN).
  */
 static bool value_extract(zcbor_state_t *state,
 		void *const result, size_t result_len)
 {
-	zcbor_trace();
+	zcbor_trace(state, "value_extract");
 	zcbor_assert_state(result_len != 0, "0-length result not supported.\r\n");
-	zcbor_assert_state(result != NULL, NULL);
+	zcbor_assert_state(result_len <= 8, "result sizes above 8 bytes not supported.\r\n");
+	zcbor_assert_state(result != NULL, "result cannot be NULL.\r\n");
 
 	INITIAL_CHECKS();
 	ZCBOR_ERR_IF((state->elem_count == 0), ZCBOR_ERR_LOW_ELEM_COUNT);
 
-	uint8_t *u8_result  = (uint8_t *)result;
-	uint8_t additional = ADDITIONAL(*state->payload);
+	uint8_t additional = ZCBOR_ADDITIONAL(*state->payload);
+	size_t len = additional_len(additional);
+	uint8_t *result_offs = (uint8_t *)result + ZCBOR_ECPY_OFFS(result_len, MAX(1, len));
 
-	state->payload_bak = state->payload;
-	(state->payload)++;
+	ZCBOR_ERR_IF(additional > ZCBOR_VALUE_IS_8_BYTES, ZCBOR_ERR_ADDITIONAL_INVAL);
+	ZCBOR_ERR_IF(len > result_len, ZCBOR_ERR_INT_SIZE);
+	ZCBOR_ERR_IF((state->payload + len + 1) > state->payload_end,
+		ZCBOR_ERR_NO_PAYLOAD);
 
 	memset(result, 0, result_len);
-	if (additional <= ZCBOR_VALUE_IN_HEADER) {
-#ifdef CONFIG_BIG_ENDIAN
-		u8_result[result_len - 1] = additional;
-#else
-		u8_result[0] = additional;
-#endif /* CONFIG_BIG_ENDIAN */
-	} else {
-		size_t len = additional_len(additional);
 
-		FAIL_AND_DECR_IF(len > result_len, ZCBOR_ERR_INT_SIZE);
-		FAIL_AND_DECR_IF(len == 0, ZCBOR_ERR_ADDITIONAL_INVAL); // additional_len() did not recognize the additional value.
-		FAIL_AND_DECR_IF((state->payload + len) > state->payload_end,
-			ZCBOR_ERR_NO_PAYLOAD);
-
-#ifdef CONFIG_BIG_ENDIAN
-		memcpy(&u8_result[result_len - len], state->payload, len);
-#else
-		for (size_t i = 0; i < len; i++) {
-			u8_result[i] = (state->payload)[len - i - 1];
-		}
-#endif /* CONFIG_BIG_ENDIAN */
+	if (len == 0) {
+		*result_offs = additional;
+	} else {
+		endian_copy(result_offs, state->payload + 1, len);
 
-		(state->payload) += len;
+#ifdef ZCBOR_CANONICAL
+		ZCBOR_ERR_IF((zcbor_header_len_ptr(result, result_len) != (len + 1)),
+			ZCBOR_ERR_INVALID_VALUE_ENCODING);
+#endif
 	}
 
+	state->payload_bak = state->payload;
+	(state->payload) += len + 1;
 	(state->elem_count)--;
 	return true;
 }
 
 
-bool zcbor_int_decode(zcbor_state_t *state, void *result_int, size_t int_size)
+bool zcbor_int_decode(zcbor_state_t *state, void *result, size_t result_size)
 {
+	PRINT_FUNC();
 	INITIAL_CHECKS();
-	zcbor_major_type_t major_type = MAJOR_TYPE(*state->payload);
-	uint8_t *result_uint8 = (uint8_t *)result_int;
-	int8_t *result_int8 = (int8_t *)result_int;
+	zcbor_major_type_t major_type = ZCBOR_MAJOR_TYPE(*state->payload);
+	uint8_t *result_uint8 = (uint8_t *)result;
+	int8_t *result_int8 = (int8_t *)result;
 
 	if (major_type != ZCBOR_MAJOR_TYPE_PINT
 		&& major_type != ZCBOR_MAJOR_TYPE_NINT) {
@@ -178,14 +175,14 @@ bool zcbor_int_decode(zcbor_state_t *state, void *result_int, size_t int_size)
 		ZCBOR_ERR(ZCBOR_ERR_WRONG_TYPE);
 	}
 
-	if (!value_extract(state, result_int, int_size)) {
+	if (!value_extract(state, result, result_size)) {
 		ZCBOR_FAIL();
 	}
 
-#ifdef CONFIG_BIG_ENDIAN
+#ifdef ZCBOR_BIG_ENDIAN
 	if (result_int8[0] < 0) {
 #else
-	if (result_int8[int_size - 1] < 0) {
+	if (result_int8[result_size - 1] < 0) {
 #endif
 		/* Value is too large to fit in a signed integer. */
 		ERR_RESTORE(ZCBOR_ERR_INT_SIZE);
@@ -193,7 +190,7 @@ bool zcbor_int_decode(zcbor_state_t *state, void *result_int, size_t int_size)
 
 	if (major_type == ZCBOR_MAJOR_TYPE_NINT) {
 		/* Convert from CBOR's representation by flipping all bits. */
-		for (unsigned int i = 0; i < int_size; i++) {
+		for (unsigned int i = 0; i < result_size; i++) {
 			result_uint8[i] = (uint8_t)~result_uint8[i];
 		}
 	}
@@ -204,22 +201,25 @@ bool zcbor_int_decode(zcbor_state_t *state, void *result_int, size_t int_size)
 
 bool zcbor_int32_decode(zcbor_state_t *state, int32_t *result)
 {
+	PRINT_FUNC();
 	return zcbor_int_decode(state, result, sizeof(*result));
 }
 
 
 bool zcbor_int64_decode(zcbor_state_t *state, int64_t *result)
 {
+	PRINT_FUNC();
 	return zcbor_int_decode(state, result, sizeof(*result));
 }
 
 
-bool zcbor_uint_decode(zcbor_state_t *state, void *result_uint, size_t uint_size)
+bool zcbor_uint_decode(zcbor_state_t *state, void *result, size_t result_size)
 {
+	PRINT_FUNC();
 	INITIAL_CHECKS_WITH_TYPE(ZCBOR_MAJOR_TYPE_PINT);
 
-	if (!value_extract(state, result_uint, uint_size)) {
-		zcbor_print("uint with size %d failed.\r\n", uint_size);
+	if (!value_extract(state, result, result_size)) {
+		zcbor_log("uint with size %zu failed.\r\n", result_size);
 		ZCBOR_FAIL();
 	}
 	return true;
@@ -228,12 +228,14 @@ bool zcbor_uint_decode(zcbor_state_t *state, void *result_uint, size_t uint_size
 
 bool zcbor_uint32_decode(zcbor_state_t *state, uint32_t *result)
 {
+	PRINT_FUNC();
 	return zcbor_uint_decode(state, result, sizeof(*result));
 }
 
 
 bool zcbor_int32_expect_union(zcbor_state_t *state, int32_t result)
 {
+	PRINT_FUNC();
 	if (!zcbor_union_elem_code(state)) {
 		ZCBOR_FAIL();
 	}
@@ -243,6 +245,7 @@ bool zcbor_int32_expect_union(zcbor_state_t *state, int32_t result)
 
 bool zcbor_int64_expect_union(zcbor_state_t *state, int64_t result)
 {
+	PRINT_FUNC();
 	if (!zcbor_union_elem_code(state)) {
 		ZCBOR_FAIL();
 	}
@@ -252,6 +255,7 @@ bool zcbor_int64_expect_union(zcbor_state_t *state, int64_t result)
 
 bool zcbor_uint32_expect_union(zcbor_state_t *state, uint32_t result)
 {
+	PRINT_FUNC();
 	if (!zcbor_union_elem_code(state)) {
 		ZCBOR_FAIL();
 	}
@@ -261,6 +265,7 @@ bool zcbor_uint32_expect_union(zcbor_state_t *state, uint32_t result)
 
 bool zcbor_uint64_expect_union(zcbor_state_t *state, uint64_t result)
 {
+	PRINT_FUNC();
 	if (!zcbor_union_elem_code(state)) {
 		ZCBOR_FAIL();
 	}
@@ -268,30 +273,47 @@ bool zcbor_uint64_expect_union(zcbor_state_t *state, uint64_t result)
 }
 
 
-bool zcbor_int32_expect(zcbor_state_t *state, int32_t result)
+bool zcbor_int32_expect(zcbor_state_t *state, int32_t expected)
 {
-	return zcbor_int64_expect(state, result);
+	PRINT_FUNC();
+	return zcbor_int64_expect(state, expected);
+}
+
+
+bool zcbor_int32_pexpect(zcbor_state_t *state, int32_t *expected)
+{
+	PRINT_FUNC();
+	return zcbor_int32_expect(state, *expected);
 }
 
 
-bool zcbor_int64_expect(zcbor_state_t *state, int64_t result)
+bool zcbor_int64_expect(zcbor_state_t *state, int64_t expected)
 {
-	int64_t value;
+	PRINT_FUNC();
+	int64_t actual;
 
-	if (!zcbor_int64_decode(state, &value)) {
+	if (!zcbor_int64_decode(state, &actual)) {
 		ZCBOR_FAIL();
 	}
 
-	if (value != result) {
-		zcbor_print("%" PRIi64 " != %" PRIi64 "\r\n", value, result);
+	if (actual != expected) {
+		zcbor_log("%" PRIi64 " != %" PRIi64 "\r\n", actual, expected);
 		ERR_RESTORE(ZCBOR_ERR_WRONG_VALUE);
 	}
 	return true;
 }
 
 
+bool zcbor_int64_pexpect(zcbor_state_t *state, int64_t *expected)
+{
+	PRINT_FUNC();
+	return zcbor_int64_expect(state, *expected);
+}
+
+
 bool zcbor_uint64_decode(zcbor_state_t *state, uint64_t *result)
 {
+	PRINT_FUNC();
 	return zcbor_uint_decode(state, result, sizeof(*result));
 }
 
@@ -299,36 +321,61 @@ bool zcbor_uint64_decode(zcbor_state_t *state, uint64_t *result)
 #ifdef ZCBOR_SUPPORTS_SIZE_T
 bool zcbor_size_decode(zcbor_state_t *state, size_t *result)
 {
+	PRINT_FUNC();
 	return zcbor_uint_decode(state, result, sizeof(*result));
 }
 #endif
 
 
-bool zcbor_uint32_expect(zcbor_state_t *state, uint32_t result)
+bool zcbor_uint32_expect(zcbor_state_t *state, uint32_t expected)
 {
-	return zcbor_uint64_expect(state, result);
+	PRINT_FUNC();
+	return zcbor_uint64_expect(state, expected);
+}
+
+
+bool zcbor_uint32_pexpect(zcbor_state_t *state, uint32_t *expected)
+{
+	PRINT_FUNC();
+	return zcbor_uint32_expect(state, *expected);
 }
 
 
-bool zcbor_uint64_expect(zcbor_state_t *state, uint64_t result)
+bool zcbor_uint64_expect(zcbor_state_t *state, uint64_t expected)
 {
-	uint64_t value;
+	PRINT_FUNC();
+	uint64_t actual;
 
-	if (!zcbor_uint64_decode(state, &value)) {
+	if (!zcbor_uint64_decode(state, &actual)) {
 		ZCBOR_FAIL();
 	}
-	if (value != result) {
-		zcbor_print("%" PRIu64 " != %" PRIu64 "\r\n", value, result);
+	if (actual != expected) {
+		zcbor_log("%" PRIu64 " != %" PRIu64 "\r\n", actual, expected);
 		ERR_RESTORE(ZCBOR_ERR_WRONG_VALUE);
 	}
 	return true;
 }
 
 
+bool zcbor_uint64_pexpect(zcbor_state_t *state, uint64_t *expected)
+{
+	PRINT_FUNC();
+	return zcbor_uint64_expect(state, *expected);
+}
+
+
 #ifdef ZCBOR_SUPPORTS_SIZE_T
-bool zcbor_size_expect(zcbor_state_t *state, size_t result)
+bool zcbor_size_expect(zcbor_state_t *state, size_t expected)
 {
-	return zcbor_uint64_expect(state, result);
+	PRINT_FUNC();
+	return zcbor_uint64_expect(state, expected);
+}
+
+
+bool zcbor_size_pexpect(zcbor_state_t *state, size_t *expected)
+{
+	PRINT_FUNC();
+	return zcbor_size_expect(state, *expected);
 }
 #endif
 
@@ -358,7 +405,7 @@ static bool str_start_decode_with_overflow_check(zcbor_state_t *state,
 	/* Casting to size_t is safe since str_start_decode() checks that
 	 * payload_end is bigger that payload. */
 	if (result->len > (size_t)(state->payload_end - state->payload)) {
-		zcbor_print("error: 0x%zu > 0x%zu\r\n",
+		zcbor_log("error: 0x%zu > 0x%zu\r\n",
 			result->len,
 			(state->payload_end - state->payload));
 		ERR_RESTORE(ZCBOR_ERR_NO_PAYLOAD);
@@ -370,6 +417,7 @@ static bool str_start_decode_with_overflow_check(zcbor_state_t *state,
 
 bool zcbor_bstr_start_decode(zcbor_state_t *state, struct zcbor_string *result)
 {
+	PRINT_FUNC();
 	struct zcbor_string dummy;
 	if (result == NULL) {
 		result = &dummy;
@@ -393,7 +441,7 @@ bool zcbor_bstr_end_decode(zcbor_state_t *state)
 	ZCBOR_ERR_IF(state->payload != state->payload_end, ZCBOR_ERR_PAYLOAD_NOT_CONSUMED);
 
 	if (!zcbor_process_backup(state,
-			ZCBOR_FLAG_RESTORE | ZCBOR_FLAG_CONSUME | ZCBOR_FLAG_TRANSFER_PAYLOAD,
+			ZCBOR_FLAG_RESTORE | ZCBOR_FLAG_CONSUME | ZCBOR_FLAG_KEEP_PAYLOAD,
 			ZCBOR_MAX_ELEM_COUNT)) {
 		ZCBOR_FAIL();
 	}
@@ -414,6 +462,7 @@ static bool start_decode_fragment(zcbor_state_t *state,
 	struct zcbor_string_fragment *result,
 	zcbor_major_type_t exp_major_type)
 {
+	PRINT_FUNC();
 	if(!str_start_decode(state, &result->fragment, exp_major_type)) {
 		ZCBOR_FAIL();
 	}
@@ -429,6 +478,7 @@ static bool start_decode_fragment(zcbor_state_t *state,
 bool zcbor_bstr_start_decode_fragment(zcbor_state_t *state,
 	struct zcbor_string_fragment *result)
 {
+	PRINT_FUNC();
 	if (!start_decode_fragment(state, result, ZCBOR_MAJOR_TYPE_BSTR)) {
 		ZCBOR_FAIL();
 	}
@@ -449,7 +499,7 @@ void zcbor_next_fragment(zcbor_state_t *state,
 	result->fragment.len = result->total_len - result->offset;
 
 	partition_fragment(state, result);
-	zcbor_print("New fragment length %zu\r\n", result->fragment.len);
+	zcbor_log("New fragment length %zu\r\n", result->fragment.len);
 
 	state->payload += result->fragment.len;
 }
@@ -465,7 +515,7 @@ void zcbor_bstr_next_fragment(zcbor_state_t *state,
 	result->fragment.len = result->total_len - result->offset;
 
 	partition_fragment(state, result);
-	zcbor_print("fragment length %zu\r\n", result->fragment.len);
+	zcbor_log("fragment length %zu\r\n", result->fragment.len);
 	state->payload_end = state->payload + result->fragment.len;
 }
 
@@ -517,37 +567,75 @@ static bool str_expect(zcbor_state_t *state, struct zcbor_string *result,
 
 bool zcbor_bstr_decode(zcbor_state_t *state, struct zcbor_string *result)
 {
+	PRINT_FUNC();
 	return str_decode(state, result, ZCBOR_MAJOR_TYPE_BSTR);
 }
 
 
 bool zcbor_bstr_decode_fragment(zcbor_state_t *state, struct zcbor_string_fragment *result)
 {
+	PRINT_FUNC();
 	return str_decode_fragment(state, result, ZCBOR_MAJOR_TYPE_BSTR);
 }
 
 
-bool zcbor_bstr_expect(zcbor_state_t *state, struct zcbor_string *result)
+bool zcbor_bstr_expect(zcbor_state_t *state, struct zcbor_string *expected)
 {
-	return str_expect(state, result, ZCBOR_MAJOR_TYPE_BSTR);
+	PRINT_FUNC();
+	return str_expect(state, expected, ZCBOR_MAJOR_TYPE_BSTR);
 }
 
 
 bool zcbor_tstr_decode(zcbor_state_t *state, struct zcbor_string *result)
 {
+	PRINT_FUNC();
 	return str_decode(state, result, ZCBOR_MAJOR_TYPE_TSTR);
 }
 
 
 bool zcbor_tstr_decode_fragment(zcbor_state_t *state, struct zcbor_string_fragment *result)
 {
+	PRINT_FUNC();
 	return str_decode_fragment(state, result, ZCBOR_MAJOR_TYPE_TSTR);
 }
 
 
-bool zcbor_tstr_expect(zcbor_state_t *state, struct zcbor_string *result)
+bool zcbor_tstr_expect(zcbor_state_t *state, struct zcbor_string *expected)
+{
+	PRINT_FUNC();
+	return str_expect(state, expected, ZCBOR_MAJOR_TYPE_TSTR);
+}
+
+
+bool zcbor_bstr_expect_ptr(zcbor_state_t *state, char const *ptr, size_t len)
+{
+	PRINT_FUNC();
+	struct zcbor_string zs = { .value = (const uint8_t *)ptr, .len = len };
+
+	return zcbor_bstr_expect(state, &zs);
+}
+
+
+bool zcbor_tstr_expect_ptr(zcbor_state_t *state, char const *ptr, size_t len)
 {
-	return str_expect(state, result, ZCBOR_MAJOR_TYPE_TSTR);
+	PRINT_FUNC();
+	struct zcbor_string zs = { .value = (const uint8_t *)ptr, .len = len };
+
+	return zcbor_tstr_expect(state, &zs);
+}
+
+
+bool zcbor_bstr_expect_term(zcbor_state_t *state, char const *string, size_t maxlen)
+{
+	PRINT_FUNC();
+	return zcbor_bstr_expect_ptr(state, string, strnlen(string, maxlen));
+}
+
+
+bool zcbor_tstr_expect_term(zcbor_state_t *state, char const *string, size_t maxlen)
+{
+	PRINT_FUNC();
+	return zcbor_tstr_expect_ptr(state, string, strnlen(string, maxlen));
 }
 
 
@@ -559,14 +647,17 @@ static bool list_map_start_decode(zcbor_state_t *state,
 
 	INITIAL_CHECKS_WITH_TYPE(exp_major_type);
 
-	if (ADDITIONAL(*state->payload) == ZCBOR_VALUE_IS_INDEFINITE_LENGTH) {
+#ifndef ZCBOR_CANONICAL
+	if (ZCBOR_ADDITIONAL(*state->payload) == ZCBOR_VALUE_IS_INDEFINITE_LENGTH) {
 		/* Indefinite length array. */
 		new_elem_count = ZCBOR_LARGE_ELEM_COUNT;
 		ZCBOR_ERR_IF(state->elem_count == 0, ZCBOR_ERR_LOW_ELEM_COUNT);
 		indefinite_length_array = true;
-		state->payload++;
+		state->payload_bak = state->payload++;
 		state->elem_count--;
-	} else {
+	} else
+#endif
+	{
 		if (!value_extract(state, &new_elem_count, sizeof(new_elem_count))) {
 			ZCBOR_FAIL();
 		}
@@ -576,7 +667,7 @@ static bool list_map_start_decode(zcbor_state_t *state,
 		FAIL_RESTORE();
 	}
 
-	state->indefinite_length_array = indefinite_length_array;
+	state->decode_state.indefinite_length_array = indefinite_length_array;
 
 	return true;
 }
@@ -584,15 +675,17 @@ static bool list_map_start_decode(zcbor_state_t *state,
 
 bool zcbor_list_start_decode(zcbor_state_t *state)
 {
+	PRINT_FUNC();
 	return list_map_start_decode(state, ZCBOR_MAJOR_TYPE_LIST);
 }
 
 
 bool zcbor_map_start_decode(zcbor_state_t *state)
 {
+	PRINT_FUNC();
 	bool ret = list_map_start_decode(state, ZCBOR_MAJOR_TYPE_MAP);
 
-	if (ret && !state->indefinite_length_array) {
+	if (ret && !state->decode_state.indefinite_length_array) {
 		if (state->elem_count >= (ZCBOR_MAX_ELEM_COUNT / 2)) {
 			/* The new elem_count is too large. */
 			ERR_RESTORE(ZCBOR_ERR_INT_SIZE);
@@ -603,6 +696,272 @@ bool zcbor_map_start_decode(zcbor_state_t *state)
 }
 
 
+bool zcbor_array_at_end(zcbor_state_t *state)
+{
+#ifdef ZCBOR_CANONICAL
+	const bool indefinite_length_array = false;
+#else
+	const bool indefinite_length_array = state->decode_state.indefinite_length_array;
+#endif
+	return ((!indefinite_length_array && (state->elem_count == 0))
+		|| (indefinite_length_array
+			&& (state->payload < state->payload_end)
+			&& (*state->payload == 0xFF)));
+}
+
+
+static size_t update_map_elem_count(zcbor_state_t *state, size_t elem_count);
+#ifdef ZCBOR_MAP_SMART_SEARCH
+static bool allocate_map_flags(zcbor_state_t *state, size_t elem_count);
+#endif
+
+
+bool zcbor_unordered_map_start_decode(zcbor_state_t *state)
+{
+	PRINT_FUNC();
+	ZCBOR_FAIL_IF(!zcbor_map_start_decode(state));
+
+#ifdef ZCBOR_MAP_SMART_SEARCH
+	state->decode_state.map_search_elem_state
+		+= zcbor_flags_to_bytes(state->decode_state.map_elem_count);
+#else
+	state->decode_state.map_elems_processed = 0;
+#endif
+	state->decode_state.map_elem_count = 0;
+	state->decode_state.counting_map_elems = state->decode_state.indefinite_length_array;
+
+	if (!state->decode_state.counting_map_elems) {
+		size_t old_flags = update_map_elem_count(state, state->elem_count);
+#ifdef ZCBOR_MAP_SMART_SEARCH
+		ZCBOR_FAIL_IF(!allocate_map_flags(state, old_flags));
+#endif
+		(void)old_flags;
+	}
+
+	return true;
+}
+
+
+/** Return the max (starting) elem_count of the current container.
+ *
+ *  Should only be used for unordered maps (started with @ref zcbor_unordered_map_start_decode)
+ */
+static size_t zcbor_current_max_elem_count(zcbor_state_t *state)
+{
+	return (state->decode_state.indefinite_length_array ? \
+		ZCBOR_LARGE_ELEM_COUNT : state->decode_state.map_elem_count * 2);
+}
+
+
+static bool map_restart(zcbor_state_t *state)
+{
+	if (!zcbor_process_backup(state, ZCBOR_FLAG_RESTORE | ZCBOR_FLAG_KEEP_DECODE_STATE,
+				ZCBOR_MAX_ELEM_COUNT)) {
+		ZCBOR_FAIL();
+	}
+
+	state->elem_count = zcbor_current_max_elem_count(state);
+	return true;
+}
+
+
+__attribute__((used))
+static size_t get_current_index(zcbor_state_t *state, uint32_t index_offset)
+{
+	/* Subtract mode because for GET, you want the index you are pointing to, while for SET,
+	 * you want the one you just processed. This only comes into play when elem_count is even. */
+	return ((zcbor_current_max_elem_count(state) - state->elem_count - index_offset) / 2);
+}
+
+
+#ifdef ZCBOR_MAP_SMART_SEARCH
+#define FLAG_MODE_GET_CURRENT 0
+#define FLAG_MODE_CLEAR_CURRENT 1
+#define FLAG_MODE_CLEAR_UNUSED 2
+
+static bool manipulate_flags(zcbor_state_t *state, uint32_t mode)
+{
+	const size_t last_index = (state->decode_state.map_elem_count - 1);
+	size_t index = (mode == FLAG_MODE_CLEAR_UNUSED) ? last_index : get_current_index(state, mode);
+
+	ZCBOR_ERR_IF((index >= state->decode_state.map_elem_count),
+		ZCBOR_ERR_MAP_FLAGS_NOT_AVAILABLE);
+	uint8_t *flag_byte = &state->decode_state.map_search_elem_state[index >> 3];
+	uint8_t flag_mask = (uint8_t)(1 << (index & 7));
+
+	switch(mode) {
+	case FLAG_MODE_GET_CURRENT:
+		return (!!(*flag_byte & flag_mask));
+	case FLAG_MODE_CLEAR_CURRENT:
+		*flag_byte &= ~flag_mask;
+		return true;
+	case FLAG_MODE_CLEAR_UNUSED:
+		*flag_byte &= (uint8_t)((flag_mask << 1) - 1);
+		return true;
+	}
+	return false;
+}
+
+
+static bool should_try_key(zcbor_state_t *state)
+{
+	return manipulate_flags(state, FLAG_MODE_GET_CURRENT);
+}
+
+
+bool zcbor_elem_processed(zcbor_state_t *state)
+{
+	return manipulate_flags(state, FLAG_MODE_CLEAR_CURRENT);
+}
+
+
+static bool allocate_map_flags(zcbor_state_t *state, size_t old_flags)
+{
+	size_t new_bytes = zcbor_flags_to_bytes(state->decode_state.map_elem_count);
+	size_t old_bytes = zcbor_flags_to_bytes(old_flags);
+	size_t extra_bytes = new_bytes - old_bytes;
+	const uint8_t *flags_end = state->constant_state->map_search_elem_state_end;
+
+	if (extra_bytes) {
+		if ((state->decode_state.map_search_elem_state + new_bytes) > flags_end) {
+			state->decode_state.map_elem_count
+				= 8 * (size_t)(flags_end - state->decode_state.map_search_elem_state);
+			ZCBOR_ERR(ZCBOR_ERR_MAP_FLAGS_NOT_AVAILABLE);
+		}
+
+		memset(&state->decode_state.map_search_elem_state[new_bytes - extra_bytes], 0xFF, extra_bytes);
+	}
+	return true;
+}
+#else
+
+static bool should_try_key(zcbor_state_t *state)
+{
+	return (state->decode_state.map_elems_processed < state->decode_state.map_elem_count);
+}
+
+
+bool zcbor_elem_processed(zcbor_state_t *state)
+{
+	if (should_try_key(state)) {
+		state->decode_state.map_elems_processed++;
+	}
+	return true;
+}
+#endif
+
+
+static size_t update_map_elem_count(zcbor_state_t *state, size_t elem_count)
+{
+	size_t old_map_elem_count = state->decode_state.map_elem_count;
+
+	state->decode_state.map_elem_count = MAX(old_map_elem_count, elem_count / 2);
+	return old_map_elem_count;
+}
+
+
+static bool handle_map_end(zcbor_state_t *state)
+{
+	state->decode_state.counting_map_elems = false;
+	return map_restart(state);
+}
+
+
+static bool try_key(zcbor_state_t *state, void *key_result, zcbor_decoder_t key_decoder)
+{
+	uint8_t const *payload_bak2 = state->payload;
+	size_t elem_count_bak = state->elem_count;
+
+	if (!key_decoder(state, (uint8_t *)key_result)) {
+		state->payload = payload_bak2;
+		state->elem_count = elem_count_bak;
+		return false;
+	}
+
+	zcbor_log("Found element at index %zu.\n", get_current_index(state, 1));
+	return true;
+}
+
+
+bool zcbor_unordered_map_search(zcbor_decoder_t key_decoder, zcbor_state_t *state, void *key_result)
+{
+	PRINT_FUNC();
+	/* elem_count cannot be odd since the map consists of key-value-pairs.
+	 * This might mean that this function was called while pointing at a value (instead
+	 * of a key). */
+	ZCBOR_ERR_IF(state->elem_count & 1, ZCBOR_ERR_MAP_MISALIGNED);
+
+	uint8_t const *payload_bak = state->payload;
+	size_t elem_count = state->elem_count;
+
+	/* Loop once through all the elements of the map. */
+	do {
+		if (zcbor_array_at_end(state)) {
+			if (!handle_map_end(state)) {
+				goto error;
+			}
+			continue; /* This continue is needed so the loop stops both if elem_count is
+			           * at the very start or the very end of the map. */
+		}
+
+		if (state->decode_state.counting_map_elems) {
+			size_t m_elem_count = ZCBOR_LARGE_ELEM_COUNT - state->elem_count + 2;
+			size_t old_flags = update_map_elem_count(state, m_elem_count);
+#ifdef ZCBOR_MAP_SMART_SEARCH
+			ZCBOR_FAIL_IF(!allocate_map_flags(state, old_flags));
+#endif
+			(void)old_flags;
+		}
+
+		if (should_try_key(state) && try_key(state, key_result, key_decoder)) {
+			if (!state->constant_state->manually_process_elem) {
+				ZCBOR_FAIL_IF(!zcbor_elem_processed(state));
+			}
+			return true;
+		}
+
+		/* Skip over both the key and the value. */
+		if (!zcbor_any_skip(state, NULL) || !zcbor_any_skip(state, NULL)) {
+			goto error;
+		}
+	} while (state->elem_count != elem_count);
+
+	zcbor_error(state, ZCBOR_ERR_ELEM_NOT_FOUND);
+error:
+	state->payload = payload_bak;
+	state->elem_count = elem_count;
+	ZCBOR_FAIL();
+}
+
+
+bool zcbor_search_key_bstr_ptr(zcbor_state_t *state, char const *ptr, size_t len)
+{
+	struct zcbor_string zs = { .value = (const uint8_t *)ptr, .len = len };
+
+	return zcbor_unordered_map_search((zcbor_decoder_t *)zcbor_bstr_expect, state, &zs);
+}
+
+
+bool zcbor_search_key_tstr_ptr(zcbor_state_t *state, char const *ptr, size_t len)
+{
+	struct zcbor_string zs = { .value = (const uint8_t *)ptr, .len = len };
+
+	return zcbor_unordered_map_search((zcbor_decoder_t *)zcbor_tstr_expect, state, &zs);
+}
+
+
+bool zcbor_search_key_bstr_term(zcbor_state_t *state, char const *str, size_t maxlen)
+{
+	return zcbor_search_key_bstr_ptr(state, str, strnlen(str, maxlen));
+}
+
+
+bool zcbor_search_key_tstr_term(zcbor_state_t *state, char const *str, size_t maxlen)
+{
+	return zcbor_search_key_tstr_ptr(state, str, strnlen(str, maxlen));
+}
+
+
 static bool array_end_expect(zcbor_state_t *state)
 {
 	INITIAL_CHECKS();
@@ -617,15 +976,17 @@ static bool list_map_end_decode(zcbor_state_t *state)
 {
 	size_t max_elem_count = 0;
 
-	if (state->indefinite_length_array) {
+#ifndef ZCBOR_CANONICAL
+	if (state->decode_state.indefinite_length_array) {
 		if (!array_end_expect(state)) {
 			ZCBOR_FAIL();
 		}
 		max_elem_count = ZCBOR_MAX_ELEM_COUNT;
-		state->indefinite_length_array = false;
+		state->decode_state.indefinite_length_array = false;
 	}
+#endif
 	if (!zcbor_process_backup(state,
-			ZCBOR_FLAG_RESTORE | ZCBOR_FLAG_CONSUME | ZCBOR_FLAG_TRANSFER_PAYLOAD,
+			ZCBOR_FLAG_RESTORE | ZCBOR_FLAG_CONSUME | ZCBOR_FLAG_KEEP_PAYLOAD,
 			max_elem_count)) {
 		ZCBOR_FAIL();
 	}
@@ -636,20 +997,51 @@ static bool list_map_end_decode(zcbor_state_t *state)
 
 bool zcbor_list_end_decode(zcbor_state_t *state)
 {
+	PRINT_FUNC();
 	return list_map_end_decode(state);
 }
 
 
 bool zcbor_map_end_decode(zcbor_state_t *state)
 {
+	PRINT_FUNC();
 	return list_map_end_decode(state);
 }
 
 
+bool zcbor_unordered_map_end_decode(zcbor_state_t *state)
+{
+	/* Checking zcbor_array_at_end() ensures that check is valid.
+	 * In case the map is at the end, but state->decode_state.counting_map_elems isn't updated.*/
+	ZCBOR_ERR_IF(!zcbor_array_at_end(state) && state->decode_state.counting_map_elems,
+			ZCBOR_ERR_ELEMS_NOT_PROCESSED);
+
+	if (state->decode_state.map_elem_count > 0) {
+#ifdef ZCBOR_MAP_SMART_SEARCH
+		manipulate_flags(state, FLAG_MODE_CLEAR_UNUSED);
+
+		for (size_t i = 0; i < zcbor_flags_to_bytes(state->decode_state.map_elem_count); i++) {
+			if (state->decode_state.map_search_elem_state[i] != 0) {
+				zcbor_log("unprocessed element(s) in map: [%zu] = 0x%02x\n",
+						i, state->decode_state.map_search_elem_state[i]);
+				ZCBOR_ERR(ZCBOR_ERR_ELEMS_NOT_PROCESSED);
+			}
+		}
+#else
+		ZCBOR_ERR_IF(should_try_key(state), ZCBOR_ERR_ELEMS_NOT_PROCESSED);
+#endif
+	}
+	while (!zcbor_array_at_end(state)) {
+		zcbor_any_skip(state, NULL);
+	}
+	return zcbor_map_end_decode(state);
+}
+
+
 bool zcbor_list_map_end_force_decode(zcbor_state_t *state)
 {
 	if (!zcbor_process_backup(state,
-			ZCBOR_FLAG_RESTORE | ZCBOR_FLAG_CONSUME | ZCBOR_FLAG_TRANSFER_PAYLOAD,
+			ZCBOR_FLAG_RESTORE | ZCBOR_FLAG_CONSUME | ZCBOR_FLAG_KEEP_PAYLOAD,
 			ZCBOR_MAX_ELEM_COUNT)) {
 		ZCBOR_FAIL();
 	}
@@ -660,11 +1052,13 @@ bool zcbor_list_map_end_force_decode(zcbor_state_t *state)
 
 bool zcbor_simple_decode(zcbor_state_t *state, uint8_t *result)
 {
+	PRINT_FUNC();
+	PRINT_FUNC();
 	INITIAL_CHECKS_WITH_TYPE(ZCBOR_MAJOR_TYPE_SIMPLE);
 
 	/* Simple values must be 0-23 (additional is 0-23) or 24-255 (additional is 24).
 	 * Other additional values are not considered simple values. */
-	ZCBOR_ERR_IF(ADDITIONAL(*state->payload) > 24, ZCBOR_ERR_WRONG_TYPE);
+	ZCBOR_ERR_IF(ZCBOR_ADDITIONAL(*state->payload) > 24, ZCBOR_ERR_WRONG_TYPE);
 
 	if (!value_extract(state, result, sizeof(*result))) {
 		ZCBOR_FAIL();
@@ -673,16 +1067,17 @@ bool zcbor_simple_decode(zcbor_state_t *state, uint8_t *result)
 }
 
 
-bool zcbor_simple_expect(zcbor_state_t *state, uint8_t result)
+bool zcbor_simple_expect(zcbor_state_t *state, uint8_t expected)
 {
-	uint8_t value;
+	PRINT_FUNC();
+	uint8_t actual;
 
-	if (!zcbor_simple_decode(state, &value)) {
+	if (!zcbor_simple_decode(state, &actual)) {
 		ZCBOR_FAIL();
 	}
 
-	if (value != result) {
-		zcbor_print("simple value %u != %u\r\n", value, result);
+	if (actual != expected) {
+		zcbor_log("simple value %u != %u\r\n", actual, expected);
 		ERR_RESTORE(ZCBOR_ERR_WRONG_VALUE);
 	}
 
@@ -690,8 +1085,16 @@ bool zcbor_simple_expect(zcbor_state_t *state, uint8_t result)
 }
 
 
+bool zcbor_simple_pexpect(zcbor_state_t *state, uint8_t *expected)
+{
+	PRINT_FUNC();
+	return zcbor_simple_expect(state, *expected);
+}
+
+
 bool zcbor_nil_expect(zcbor_state_t *state, void *unused)
 {
+	PRINT_FUNC();
 	(void)unused;
 	return zcbor_simple_expect(state, 22);
 }
@@ -699,6 +1102,7 @@ bool zcbor_nil_expect(zcbor_state_t *state, void *unused)
 
 bool zcbor_undefined_expect(zcbor_state_t *state, void *unused)
 {
+	PRINT_FUNC();
 	(void)unused;
 	return zcbor_simple_expect(state, 23);
 }
@@ -706,6 +1110,7 @@ bool zcbor_undefined_expect(zcbor_state_t *state, void *unused)
 
 bool zcbor_bool_decode(zcbor_state_t *state, bool *result)
 {
+	PRINT_FUNC();
 	uint8_t value;
 
 	if (!zcbor_simple_decode(state, &value)) {
@@ -717,28 +1122,36 @@ bool zcbor_bool_decode(zcbor_state_t *state, bool *result)
 	}
 	*result = value;
 
-	zcbor_print("boolval: %u\r\n", *result);
+	zcbor_log("boolval: %u\r\n", *result);
 	return true;
 }
 
 
-bool zcbor_bool_expect(zcbor_state_t *state, bool result)
+bool zcbor_bool_expect(zcbor_state_t *state, bool expected)
+{
+	PRINT_FUNC();
+	return zcbor_simple_expect(state, (uint8_t)(!!expected) + ZCBOR_BOOL_TO_SIMPLE);
+}
+
+
+bool zcbor_bool_pexpect(zcbor_state_t *state, bool *expected)
 {
-	return zcbor_simple_expect(state, (uint8_t)(!!result) + ZCBOR_BOOL_TO_SIMPLE);
+	PRINT_FUNC();
+	return zcbor_bool_expect(state, *expected);
 }
 
 
 static bool float_check(zcbor_state_t *state, uint8_t additional_val)
 {
 	INITIAL_CHECKS_WITH_TYPE(ZCBOR_MAJOR_TYPE_SIMPLE);
-	ZCBOR_ERR_IF(ADDITIONAL(*state->payload) != additional_val, ZCBOR_ERR_FLOAT_SIZE);
+	ZCBOR_ERR_IF(ZCBOR_ADDITIONAL(*state->payload) != additional_val, ZCBOR_ERR_FLOAT_SIZE);
 	return true;
 }
 
 
 bool zcbor_float16_bytes_decode(zcbor_state_t *state, uint16_t *result)
 {
-
+	PRINT_FUNC();
 	ZCBOR_FAIL_IF(!float_check(state, ZCBOR_VALUE_IS_2_BYTES));
 
 	if (!value_extract(state, result, sizeof(*result))) {
@@ -749,81 +1162,67 @@ bool zcbor_float16_bytes_decode(zcbor_state_t *state, uint16_t *result)
 }
 
 
-bool zcbor_float16_bytes_expect(zcbor_state_t *state, uint16_t result)
+bool zcbor_float16_bytes_expect(zcbor_state_t *state, uint16_t expected)
 {
-	uint16_t value;
+	PRINT_FUNC();
+	uint16_t actual;
 
-	if (!zcbor_float16_bytes_decode(state, &value)) {
+	if (!zcbor_float16_bytes_decode(state, &actual)) {
 		ZCBOR_FAIL();
 	}
-	if (value != result) {
+	if (actual != expected) {
 		ERR_RESTORE(ZCBOR_ERR_WRONG_VALUE);
 	}
 	return true;
 }
 
 
-/* Float16: */
-#define F16_SIGN_OFFS 15 /* Bit offset of the sign bit. */
-#define F16_EXPO_OFFS 10 /* Bit offset of the exponent. */
-#define F16_EXPO_MSK 0x1F /* Bitmask for the exponent (right shifted by F16_EXPO_OFFS). */
-#define F16_MANTISSA_MSK 0x3FF /* Bitmask for the mantissa. */
-#define F16_MIN_EXPO 24 /* Negative exponent of the non-zero float16 value closest to 0 (2^-24) */
-#define F16_MIN (1.0 / (1 << F16_MIN_EXPO)) /* The non-zero float16 value closest to 0 (2^-24) */
-#define F16_BIAS 15 /* The exponent bias of normalized float16 values. */
-
-/* Float32: */
-#define F32_SIGN_OFFS 31 /* Bit offset of the sign bit. */
-#define F32_EXPO_OFFS 23 /* Bit offset of the exponent. */
-#define F32_EXPO_MSK 0xFF /* Bitmask for the exponent (right shifted by F32_EXPO_OFFS). */
-#define F32_BIAS 127 /* The exponent bias of normalized float32 values. */
+bool zcbor_float16_bytes_pexpect(zcbor_state_t *state, uint16_t *expected)
+{
+	PRINT_FUNC();
+	return zcbor_float16_bytes_expect(state, *expected);
+}
 
 
 bool zcbor_float16_decode(zcbor_state_t *state, float *result)
 {
+	PRINT_FUNC();
 	uint16_t value16;
 
 	if (!zcbor_float16_bytes_decode(state, &value16)) {
 		ZCBOR_FAIL();
 	}
 
-	uint32_t sign = value16 >> F16_SIGN_OFFS;
-	uint32_t expo = (value16 >> F16_EXPO_OFFS) & F16_EXPO_MSK;
-	uint32_t mantissa = value16 & F16_MANTISSA_MSK;
-
-	if ((expo == 0) && (mantissa != 0)) {
-		/* Subnormal float16 - convert to normalized float32 */
-		*result = ((float)mantissa * (float)F16_MIN) * (sign ? -1 : 1);
-	} else {
-		/* Normalized / zero / Infinity / NaN */
-		uint32_t new_expo = (expo == 0 /* zero */) ? 0
-			: (expo == F16_EXPO_MSK /* inf/NaN */) ? F32_EXPO_MSK
-				: (expo + (F32_BIAS - F16_BIAS));
-		uint32_t value32 = (sign << F32_SIGN_OFFS) | (new_expo << F32_EXPO_OFFS)
-			| (mantissa << (F32_EXPO_OFFS - F16_EXPO_OFFS));
-		memcpy(result, &value32, sizeof(*result));
-	}
-
+	*result = zcbor_float16_to_32(value16);
 	return true;
 }
 
 
-bool zcbor_float16_expect(zcbor_state_t *state, float result)
+bool zcbor_float16_expect(zcbor_state_t *state, float expected)
 {
-	float value;
+	PRINT_FUNC();
+	float actual;
 
-	if (!zcbor_float16_decode(state, &value)) {
+	if (!zcbor_float16_decode(state, &actual)) {
 		ZCBOR_FAIL();
 	}
-	if (value != result) {
+	if (actual != expected) {
 		ERR_RESTORE(ZCBOR_ERR_WRONG_VALUE);
 	}
 	return true;
 }
 
 
+bool zcbor_float16_pexpect(zcbor_state_t *state, float *expected)
+{
+	PRINT_FUNC();
+	return zcbor_float16_expect(state, *expected);
+}
+
+
 bool zcbor_float32_decode(zcbor_state_t *state, float *result)
 {
+	PRINT_FUNC();
 	ZCBOR_FAIL_IF(!float_check(state, ZCBOR_VALUE_IS_4_BYTES));
 
 	if (!value_extract(state, result, sizeof(*result))) {
@@ -834,22 +1233,31 @@ bool zcbor_float32_decode(zcbor_state_t *state, float *result)
 }
 
 
-bool zcbor_float32_expect(zcbor_state_t *state, float result)
+bool zcbor_float32_expect(zcbor_state_t *state, float expected)
 {
-	float value;
+	PRINT_FUNC();
+	float actual;
 
-	if (!zcbor_float32_decode(state, &value)) {
+	if (!zcbor_float32_decode(state, &actual)) {
 		ZCBOR_FAIL();
 	}
-	if (value != result) {
+	if (actual != expected) {
 		ERR_RESTORE(ZCBOR_ERR_WRONG_VALUE);
 	}
 	return true;
 }
 
 
+bool zcbor_float32_pexpect(zcbor_state_t *state, float *expected)
+{
+	PRINT_FUNC();
+	return zcbor_float32_expect(state, *expected);
+}
+
+
 bool zcbor_float16_32_decode(zcbor_state_t *state, float *result)
 {
+	PRINT_FUNC();
 	if (zcbor_float16_decode(state, result)) {
 		/* Do nothing */
 	} else if (!zcbor_float32_decode(state, result)) {
@@ -860,11 +1268,12 @@ bool zcbor_float16_32_decode(zcbor_state_t *state, float *result)
 }
 
 
-bool zcbor_float16_32_expect(zcbor_state_t *state, float result)
+bool zcbor_float16_32_expect(zcbor_state_t *state, float expected)
 {
-	if (zcbor_float16_expect(state, (float)result)) {
+	PRINT_FUNC();
+	if (zcbor_float16_expect(state, expected)) {
 		/* Do nothing */
-	} else if (!zcbor_float32_expect(state, result)) {
+	} else if (!zcbor_float32_expect(state, expected)) {
 		ZCBOR_FAIL();
 	}
 
@@ -872,8 +1281,16 @@ bool zcbor_float16_32_expect(zcbor_state_t *state, float result)
 }
 
 
+bool zcbor_float16_32_pexpect(zcbor_state_t *state, float *expected)
+{
+	PRINT_FUNC();
+	return zcbor_float16_32_expect(state, *expected);
+}
+
+
 bool zcbor_float64_decode(zcbor_state_t *state, double *result)
 {
+	PRINT_FUNC();
 	ZCBOR_FAIL_IF(!float_check(state, ZCBOR_VALUE_IS_8_BYTES));
 
 	if (!value_extract(state, result, sizeof(*result))) {
@@ -884,22 +1301,31 @@ bool zcbor_float64_decode(zcbor_state_t *state, double *result)
 }
 
 
-bool zcbor_float64_expect(zcbor_state_t *state, double result)
+bool zcbor_float64_expect(zcbor_state_t *state, double expected)
 {
-	double value;
+	PRINT_FUNC();
+	double actual;
 
-	if (!zcbor_float64_decode(state, &value)) {
+	if (!zcbor_float64_decode(state, &actual)) {
 		ZCBOR_FAIL();
 	}
-	if (value != result) {
+	if (actual != expected) {
 		ERR_RESTORE(ZCBOR_ERR_WRONG_VALUE);
 	}
 	return true;
 }
 
 
+bool zcbor_float64_pexpect(zcbor_state_t *state, double *expected)
+{
+	PRINT_FUNC();
+	return zcbor_float64_expect(state, *expected);
+}
+
+
 bool zcbor_float32_64_decode(zcbor_state_t *state, double *result)
 {
+	PRINT_FUNC();
 	float float_result;
 
 	if (zcbor_float32_decode(state, &float_result)) {
@@ -912,11 +1338,12 @@ bool zcbor_float32_64_decode(zcbor_state_t *state, double *result)
 }
 
 
-bool zcbor_float32_64_expect(zcbor_state_t *state, double result)
+bool zcbor_float32_64_expect(zcbor_state_t *state, double expected)
 {
-	if (zcbor_float64_expect(state, result)) {
+	PRINT_FUNC();
+	if (zcbor_float64_expect(state, expected)) {
 		/* Do nothing */
-	} else if (!zcbor_float32_expect(state, (float)result)) {
+	} else if (!zcbor_float32_expect(state, (float)expected)) {
 		ZCBOR_FAIL();
 	}
 
@@ -924,8 +1351,16 @@ bool zcbor_float32_64_expect(zcbor_state_t *state, double result)
 }
 
 
+bool zcbor_float32_64_pexpect(zcbor_state_t *state, double *expected)
+{
+	PRINT_FUNC();
+	return zcbor_float32_64_expect(state, *expected);
+}
+
+
 bool zcbor_float_decode(zcbor_state_t *state, double *result)
 {
+	PRINT_FUNC();
 	float float_result;
 
 	if (zcbor_float16_decode(state, &float_result)) {
@@ -940,13 +1375,14 @@ bool zcbor_float_decode(zcbor_state_t *state, double *result)
 }
 
 
-bool zcbor_float_expect(zcbor_state_t *state, double result)
+bool zcbor_float_expect(zcbor_state_t *state, double expected)
 {
-	if (zcbor_float16_expect(state, (float)result)) {
+	PRINT_FUNC();
+	if (zcbor_float16_expect(state, (float)expected)) {
 		/* Do nothing */
-	} else if (zcbor_float32_expect(state, (float)result)) {
+	} else if (zcbor_float32_expect(state, (float)expected)) {
 		/* Do nothing */
-	} else if (!zcbor_float64_expect(state, result)) {
+	} else if (!zcbor_float64_expect(state, expected)) {
 		ZCBOR_FAIL();
 	}
 
@@ -954,15 +1390,23 @@ bool zcbor_float_expect(zcbor_state_t *state, double result)
 }
 
 
+bool zcbor_float_pexpect(zcbor_state_t *state, double *expected)
+{
+	PRINT_FUNC();
+	return zcbor_float_expect(state, *expected);
+}
+
+
 bool zcbor_any_skip(zcbor_state_t *state, void *result)
 {
+	PRINT_FUNC();
 	zcbor_assert_state(result == NULL,
 			"'any' type cannot be returned, only skipped.\r\n");
 	(void)result;
 
 	INITIAL_CHECKS();
-	zcbor_major_type_t major_type = MAJOR_TYPE(*state->payload);
-	uint8_t additional = ADDITIONAL(*state->payload);
+	zcbor_major_type_t major_type = ZCBOR_MAJOR_TYPE(*state->payload);
+	uint8_t additional = ZCBOR_ADDITIONAL(*state->payload);
 	uint64_t value = 0; /* In case of indefinite_length_array. */
 	zcbor_state_t state_copy;
 
@@ -975,12 +1419,16 @@ bool zcbor_any_skip(zcbor_state_t *state, void *result)
 			ZCBOR_FAIL();
 		}
 		ZCBOR_ERR_IF(state_copy.payload >= state_copy.payload_end, ZCBOR_ERR_NO_PAYLOAD);
-		major_type = MAJOR_TYPE(*state_copy.payload);
-		additional = ADDITIONAL(*state_copy.payload);
+		major_type = ZCBOR_MAJOR_TYPE(*state_copy.payload);
+		additional = ZCBOR_ADDITIONAL(*state_copy.payload);
 	}
 
+#ifdef ZCBOR_CANONICAL
+	const bool indefinite_length_array = false;
+#else
 	const bool indefinite_length_array = ((additional == ZCBOR_VALUE_IS_INDEFINITE_LENGTH)
 		&& ((major_type == ZCBOR_MAJOR_TYPE_LIST) || (major_type == ZCBOR_MAJOR_TYPE_MAP)));
+#endif
 
 	if (!indefinite_length_array && !value_extract(&state_copy, &value, sizeof(value))) {
 		/* Can happen because of elem_count (or payload_end) */
@@ -991,7 +1439,7 @@ bool zcbor_any_skip(zcbor_state_t *state, void *result)
 		case ZCBOR_MAJOR_TYPE_BSTR:
 		case ZCBOR_MAJOR_TYPE_TSTR:
 			/* 'value' is the length of the BSTR or TSTR.
-			 * The cast to size_t is safe because value_extract() above
+			 * The subtraction is safe because value_extract() above
 			 * checks that payload_end is greater than payload. */
 			ZCBOR_ERR_IF(
 				value > (uint64_t)(state_copy.payload_end - state_copy.payload),
@@ -1008,7 +1456,7 @@ bool zcbor_any_skip(zcbor_state_t *state, void *result)
 				value = ZCBOR_LARGE_ELEM_COUNT;
 			}
 			state_copy.elem_count = (size_t)value;
-			state_copy.indefinite_length_array = indefinite_length_array;
+			state_copy.decode_state.indefinite_length_array = indefinite_length_array;
 			while (!zcbor_array_at_end(&state_copy)) {
 				if (!zcbor_any_skip(&state_copy, NULL)) {
 					ZCBOR_FAIL();
@@ -1032,6 +1480,7 @@ bool zcbor_any_skip(zcbor_state_t *state, void *result)
 
 bool zcbor_tag_decode(zcbor_state_t *state, uint32_t *result)
 {
+	PRINT_FUNC();
 	INITIAL_CHECKS_WITH_TYPE(ZCBOR_MAJOR_TYPE_TAG);
 
 	if (!value_extract(state, result, sizeof(*result))) {
@@ -1042,20 +1491,28 @@ bool zcbor_tag_decode(zcbor_state_t *state, uint32_t *result)
 }
 
 
-bool zcbor_tag_expect(zcbor_state_t *state, uint32_t result)
+bool zcbor_tag_expect(zcbor_state_t *state, uint32_t expected)
 {
-	uint32_t tag_val;
+	PRINT_FUNC();
+	uint32_t actual;
 
-	if (!zcbor_tag_decode(state, &tag_val)) {
+	if (!zcbor_tag_decode(state, &actual)) {
 		ZCBOR_FAIL();
 	}
-	if (tag_val != result) {
+	if (actual != expected) {
 		ERR_RESTORE(ZCBOR_ERR_WRONG_VALUE);
 	}
 	return true;
 }
 
 
+bool zcbor_tag_pexpect(zcbor_state_t *state, uint32_t *expected)
+{
+	PRINT_FUNC();
+	return zcbor_tag_expect(state, *expected);
+}
+
+
 bool zcbor_multi_decode(size_t min_decode,
 		size_t max_decode,
 		size_t *num_decode,
@@ -1064,6 +1521,7 @@ bool zcbor_multi_decode(size_t min_decode,
 		void *result,
 		size_t result_len)
 {
+	PRINT_FUNC();
 	ZCBOR_CHECK_ERROR();
 	for (size_t i = 0; i < max_decode; i++) {
 		uint8_t const *payload_bak = state->payload;
@@ -1075,11 +1533,11 @@ bool zcbor_multi_decode(size_t min_decode,
 			state->payload = payload_bak;
 			state->elem_count = elem_count_bak;
 			ZCBOR_ERR_IF(i < min_decode, ZCBOR_ERR_ITERATIONS);
-			zcbor_print("Found %" PRIuFAST32 " elements.\r\n", i);
+			zcbor_log("Found %zu elements.\r\n", i);
 			return true;
 		}
 	}
-	zcbor_print("Found %" PRIuFAST32 " elements.\r\n", max_decode);
+	zcbor_log("Found %zu elements.\r\n", max_decode);
 	*num_decode = max_decode;
 	return true;
 }
@@ -1090,7 +1548,8 @@ bool zcbor_present_decode(bool *present,
 		zcbor_state_t *state,
 		void *result)
 {
-	size_t num_decode;
+	PRINT_FUNC();
+	size_t num_decode = 0;
 	bool retval = zcbor_multi_decode(0, 1, &num_decode, decoder, state, result, 0);
 
 	zcbor_assert_state(retval, "zcbor_multi_decode should not fail with these parameters.\r\n");
@@ -1101,7 +1560,8 @@ bool zcbor_present_decode(bool *present,
 
 
 void zcbor_new_decode_state(zcbor_state_t *state_array, size_t n_states,
-		const uint8_t *payload, size_t payload_len, size_t elem_count)
+		const uint8_t *payload, size_t payload_len, size_t elem_count,
+		uint8_t *flags, size_t flags_bytes)
 {
-	zcbor_new_state(state_array, n_states, payload, payload_len, elem_count);
+	zcbor_new_state(state_array, n_states, payload, payload_len, elem_count, flags, flags_bytes);
 }