| /* |
| * Copyright (c) 2023 Nordic Semiconductor ASA |
| * |
| * SPDX-License-Identifier: Apache-2.0 |
| * |
| * Generated using zcbor version 0.8.1 |
| * https://github.com/zephyrproject-rtos/zcbor |
| * Generated with a --default-max-qty of 99 |
| */ |
| |
| #include <stdint.h> |
| #include <stdbool.h> |
| #include <stddef.h> |
| #include <string.h> |
| #include "zcbor_decode.h" |
| #include "lwm2m_senml_cbor_decode.h" |
| #include "zcbor_print.h" |
| |
| static bool decode_repeated_record_bn(zcbor_state_t *state, struct record_bn *result); |
| static bool decode_repeated_record_bt(zcbor_state_t *state, struct record_bt *result); |
| static bool decode_repeated_record_n(zcbor_state_t *state, struct record_n *result); |
| static bool decode_repeated_record_t(zcbor_state_t *state, struct record_t *result); |
| static bool decode_repeated_record_union(zcbor_state_t *state, struct record_union_r *result); |
| static bool decode_value(zcbor_state_t *state, struct value_r *result); |
| static bool decode_key_value_pair(zcbor_state_t *state, struct key_value_pair *result); |
| static bool decode_repeated_record_key_value_pair_m(zcbor_state_t *state, |
| struct record_key_value_pair_m *result); |
| static bool decode_record(zcbor_state_t *state, struct record *result); |
| static bool decode_lwm2m_senml(zcbor_state_t *state, struct lwm2m_senml *result); |
| |
| static bool decode_repeated_record_bn(zcbor_state_t *state, struct record_bn *result) |
| { |
| zcbor_log("%s\r\n", __func__); |
| |
| bool tmp_result = ((((zcbor_int32_expect(state, (-2)))) && |
| (zcbor_tstr_decode(state, (&(*result).record_bn))))); |
| |
| if (!tmp_result) { |
| zcbor_trace_file(state); |
| zcbor_log("%s error: %s\r\n", __func__, zcbor_error_str(zcbor_peek_error(state))); |
| } else { |
| zcbor_log("%s success\r\n", __func__); |
| } |
| |
| return tmp_result; |
| } |
| |
| static bool decode_repeated_record_bt(zcbor_state_t *state, struct record_bt *result) |
| { |
| zcbor_log("%s\r\n", __func__); |
| |
| bool tmp_result = |
| ((((zcbor_int32_expect(state, (-3)))) && |
| (zcbor_int64_decode(state, (&(*result).record_bt))) && |
| ((((*result).record_bt >= INT64_MIN) && ((*result).record_bt <= INT64_MAX)) || |
| (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false)))); |
| |
| if (!tmp_result) { |
| zcbor_trace_file(state); |
| zcbor_log("%s error: %s\r\n", __func__, zcbor_error_str(zcbor_peek_error(state))); |
| } else { |
| zcbor_log("%s success\r\n", __func__); |
| } |
| |
| return tmp_result; |
| } |
| |
| static bool decode_repeated_record_n(zcbor_state_t *state, struct record_n *result) |
| { |
| zcbor_log("%s\r\n", __func__); |
| |
| bool tmp_result = ((((zcbor_uint32_expect(state, (0)))) && |
| (zcbor_tstr_decode(state, (&(*result).record_n))))); |
| |
| if (!tmp_result) { |
| zcbor_trace_file(state); |
| zcbor_log("%s error: %s\r\n", __func__, zcbor_error_str(zcbor_peek_error(state))); |
| } else { |
| zcbor_log("%s success\r\n", __func__); |
| } |
| |
| return tmp_result; |
| } |
| |
| static bool decode_repeated_record_t(zcbor_state_t *state, struct record_t *result) |
| { |
| zcbor_log("%s\r\n", __func__); |
| |
| bool tmp_result = |
| ((((zcbor_uint32_expect(state, (6)))) && |
| (zcbor_int64_decode(state, (&(*result).record_t))) && |
| ((((*result).record_t >= INT64_MIN) && ((*result).record_t <= INT64_MAX)) || |
| (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false)))); |
| |
| if (!tmp_result) { |
| zcbor_trace_file(state); |
| zcbor_log("%s error: %s\r\n", __func__, zcbor_error_str(zcbor_peek_error(state))); |
| } else { |
| zcbor_log("%s success\r\n", __func__); |
| } |
| |
| return tmp_result; |
| } |
| |
| static bool decode_repeated_record_union(zcbor_state_t *state, struct record_union_r *result) |
| { |
| zcbor_log("%s\r\n", __func__); |
| struct zcbor_string tmp_str; |
| bool int_res; |
| |
| bool tmp_result = |
| (((zcbor_union_start_code(state) && |
| (int_res = (((((zcbor_uint32_expect_union(state, (2)))) && |
| (zcbor_int64_decode(state, (&(*result).union_vi))) && |
| ((((*result).union_vi >= INT64_MIN) && |
| ((*result).union_vi <= INT64_MAX)) || |
| (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))) && |
| (((*result).record_union_choice = union_vi_c), true)) || |
| ((((zcbor_uint32_expect_union(state, (2)))) && |
| (zcbor_float_decode(state, (&(*result).union_vf)))) && |
| (((*result).record_union_choice = union_vf_c), true)) || |
| ((((zcbor_uint32_expect_union(state, (3)))) && |
| (zcbor_tstr_decode(state, (&(*result).union_vs)))) && |
| (((*result).record_union_choice = union_vs_c), true)) || |
| ((((zcbor_uint32_expect_union(state, (4)))) && |
| (zcbor_bool_decode(state, (&(*result).union_vb)))) && |
| (((*result).record_union_choice = union_vb_c), true)) || |
| ((((zcbor_uint32_expect_union(state, (8)))) && |
| (zcbor_bstr_decode(state, (&(*result).union_vd)))) && |
| (((*result).record_union_choice = union_vd_c), true)) || |
| (zcbor_union_elem_code(state) && |
| ((((zcbor_tstr_expect( |
| state, ((tmp_str.value = (uint8_t *)"vlo", |
| tmp_str.len = sizeof("vlo") - 1, &tmp_str))))) && |
| (zcbor_tstr_decode(state, (&(*result).union_vlo)))) && |
| (((*result).record_union_choice = union_vlo_c), true)))), |
| zcbor_union_end_code(state), int_res)))); |
| |
| if (!tmp_result) { |
| zcbor_trace_file(state); |
| zcbor_log("%s error: %s\r\n", __func__, zcbor_error_str(zcbor_peek_error(state))); |
| } else { |
| zcbor_log("%s success\r\n", __func__); |
| } |
| |
| return tmp_result; |
| } |
| |
| static bool decode_value(zcbor_state_t *state, struct value_r *result) |
| { |
| zcbor_log("%s\r\n", __func__); |
| bool int_res; |
| |
| bool tmp_result = (((zcbor_union_start_code(state) && |
| (int_res = ((((zcbor_tstr_decode(state, (&(*result).value_tstr)))) && |
| (((*result).value_choice = value_tstr_c), true)) || |
| (((zcbor_bstr_decode(state, (&(*result).value_bstr)))) && |
| (((*result).value_choice = value_bstr_c), true)) || |
| (((zcbor_int64_decode(state, (&(*result).value_int))) && |
| ((((*result).value_int >= INT64_MIN) && |
| ((*result).value_int <= INT64_MAX)) || |
| (zcbor_error(state, ZCBOR_ERR_WRONG_RANGE), false))) && |
| (((*result).value_choice = value_int_c), true)) || |
| (((zcbor_float_decode(state, (&(*result).value_float)))) && |
| (((*result).value_choice = value_float_c), true)) || |
| (((zcbor_bool_decode(state, (&(*result).value_bool)))) && |
| (((*result).value_choice = value_bool_c), true))), |
| zcbor_union_end_code(state), int_res)))); |
| |
| if (!tmp_result) { |
| zcbor_trace_file(state); |
| zcbor_log("%s error: %s\r\n", __func__, zcbor_error_str(zcbor_peek_error(state))); |
| } else { |
| zcbor_log("%s success\r\n", __func__); |
| } |
| |
| return tmp_result; |
| } |
| |
| static bool decode_key_value_pair(zcbor_state_t *state, struct key_value_pair *result) |
| { |
| zcbor_log("%s\r\n", __func__); |
| |
| bool tmp_result = ((((zcbor_int32_decode(state, (&(*result).key_value_pair_key)))) && |
| (decode_value(state, (&(*result).key_value_pair))))); |
| |
| if (!tmp_result) { |
| zcbor_trace_file(state); |
| zcbor_log("%s error: %s\r\n", __func__, zcbor_error_str(zcbor_peek_error(state))); |
| } else { |
| zcbor_log("%s success\r\n", __func__); |
| } |
| |
| return tmp_result; |
| } |
| |
| static bool decode_repeated_record_key_value_pair_m(zcbor_state_t *state, |
| struct record_key_value_pair_m *result) |
| { |
| zcbor_log("%s\r\n", __func__); |
| |
| bool tmp_result = (((decode_key_value_pair(state, (&(*result).record_key_value_pair_m))))); |
| |
| if (!tmp_result) { |
| zcbor_trace_file(state); |
| zcbor_log("%s error: %s\r\n", __func__, zcbor_error_str(zcbor_peek_error(state))); |
| } else { |
| zcbor_log("%s success\r\n", __func__); |
| } |
| |
| return tmp_result; |
| } |
| |
| static bool decode_record(zcbor_state_t *state, struct record *result) |
| { |
| zcbor_log("%s\r\n", __func__); |
| |
| bool tmp_result = |
| (((zcbor_map_start_decode(state) && |
| ((zcbor_present_decode(&((*result).record_bn_present), |
| (zcbor_decoder_t *)decode_repeated_record_bn, state, |
| (&(*result).record_bn)) && |
| zcbor_present_decode(&((*result).record_bt_present), |
| (zcbor_decoder_t *)decode_repeated_record_bt, state, |
| (&(*result).record_bt)) && |
| zcbor_present_decode(&((*result).record_n_present), |
| (zcbor_decoder_t *)decode_repeated_record_n, state, |
| (&(*result).record_n)) && |
| zcbor_present_decode(&((*result).record_t_present), |
| (zcbor_decoder_t *)decode_repeated_record_t, state, |
| (&(*result).record_t)) && |
| zcbor_present_decode(&((*result).record_union_present), |
| (zcbor_decoder_t *)decode_repeated_record_union, state, |
| (&(*result).record_union)) && |
| zcbor_multi_decode(0, ZCBOR_ARRAY_SIZE(result->record_key_value_pair_m), |
| &(*result).record_key_value_pair_m_count, |
| (zcbor_decoder_t *)decode_repeated_record_key_value_pair_m, |
| state, (&(*result).record_key_value_pair_m), |
| sizeof(struct record_key_value_pair_m))) || |
| (zcbor_list_map_end_force_decode(state), false)) && |
| zcbor_map_end_decode(state)))); |
| |
| if (!tmp_result) { |
| zcbor_trace_file(state); |
| zcbor_log("%s error: %s\r\n", __func__, zcbor_error_str(zcbor_peek_error(state))); |
| } else { |
| zcbor_log("%s success\r\n", __func__); |
| } |
| |
| return tmp_result; |
| } |
| |
| static bool decode_lwm2m_senml(zcbor_state_t *state, struct lwm2m_senml *result) |
| { |
| zcbor_log("%s\r\n", __func__); |
| |
| bool tmp_result = |
| (((zcbor_list_start_decode(state) && |
| ((zcbor_multi_decode( |
| 1, ZCBOR_ARRAY_SIZE(result->lwm2m_senml_record_m), |
| &(*result).lwm2m_senml_record_m_count, (zcbor_decoder_t *)decode_record, |
| state, (&(*result).lwm2m_senml_record_m), sizeof(struct record))) || |
| (zcbor_list_map_end_force_decode(state), false)) && |
| zcbor_list_end_decode(state)))); |
| |
| if (!tmp_result) { |
| zcbor_trace_file(state); |
| zcbor_log("%s error: %s\r\n", __func__, zcbor_error_str(zcbor_peek_error(state))); |
| } else { |
| zcbor_log("%s success\r\n", __func__); |
| } |
| |
| return tmp_result; |
| } |
| |
| int cbor_decode_lwm2m_senml(const uint8_t *payload, size_t payload_len, struct lwm2m_senml *result, |
| size_t *payload_len_out) |
| { |
| zcbor_state_t states[5]; |
| |
| return zcbor_entry_function(payload, payload_len, (void *)result, payload_len_out, states, |
| (zcbor_decoder_t *)decode_lwm2m_senml, |
| sizeof(states) / sizeof(zcbor_state_t), 1); |
| } |