From dfbf72d9da895dfe32b83d52ee84a40c37c61e13 Mon Sep 17 00:00:00 2001 From: cogu Date: Wed, 6 May 2026 15:36:23 +0200 Subject: [PATCH 1/3] Refactor handling of records Fixes an issue where using a limit check inside a record definitions was not working properly --- apx/include/apx/decoder.h | 4 +- apx/include/apx/deserializer.h | 4 +- apx/include/apx/program.h | 3 +- apx/include/apx/serializer.h | 4 +- apx/include/apx/vm_defs.h | 56 ++++++----- apx/src/compiler.c | 24 ++++- apx/src/decoder.c | 25 +++-- apx/src/deserializer.c | 45 ++++----- apx/src/program.c | 20 +++- apx/src/serializer.c | 42 ++++---- apx/src/vm.c | 25 ++++- apx/test/testsuite_client.c | 139 ++++++++++++++++++++++++--- apx/test/testsuite_compiler_pack.c | 25 +++-- apx/test/testsuite_compiler_unpack.c | 25 +++-- apx/test/testsuite_vm_deserializer.c | 57 ++++++----- apx/test/testsuite_vm_serializer.c | 30 +++--- apx/test/testsuite_vm_unpack.c | 52 ++++++++++ 17 files changed, 420 insertions(+), 160 deletions(-) diff --git a/apx/include/apx/decoder.h b/apx/include/apx/decoder.h index af56935..d273341 100644 --- a/apx/include/apx/decoder.h +++ b/apx/include/apx/decoder.h @@ -51,7 +51,7 @@ typedef struct apx_vm_decoder_tag apx_rangeCheckInt32OperationInfo_t range_check_int32_info; apx_rangeCheckInt64OperationInfo_t range_check_int64_info; adt_str_t field_name; - bool is_last_field; + bool is_first_field; } apx_vm_decoder_t; ////////////////////////////////////////////////////////////////////////////// @@ -71,6 +71,6 @@ char const* apx_vm_decoder_get_field_name(apx_vm_decoder_t* self); void apx_vm_decoder_save_program_position(apx_vm_decoder_t* self); void apx_vm_decoder_recall_program_position(apx_vm_decoder_t* self); bool apx_vm_decoder_has_saved_program_position(apx_vm_decoder_t* self); -bool apx_vm_decoder_is_last_field(apx_vm_decoder_t* self); +bool apx_vm_decoder_is_first_field(apx_vm_decoder_t* self); #endif //APX_VM_DECODER_H diff --git a/apx/include/apx/deserializer.h b/apx/include/apx/deserializer.h index 6e9a18b..58e7d77 100644 --- a/apx/include/apx/deserializer.h +++ b/apx/include/apx/deserializer.h @@ -77,7 +77,6 @@ typedef struct apx_vm_readState_tag dtl_dv_type_id value_type; //describes which part of the value union is currently active scalar_storage_type_t scalar_storage_type; //describes which part of the scalar_value union is currently active apx_typeCode_t type_code; - bool is_last_field; apx_sizeType_t dynamic_size_type; apx_rangeCheckState_t range_check_state; } apx_vm_readState_t; @@ -131,7 +130,8 @@ apx_error_t apx_vm_deserializer_unpack_char8(apx_vm_deserializer_t* self, uint32 apx_error_t apx_vm_deserializer_unpack_bool(apx_vm_deserializer_t* self, uint32_t array_length, apx_sizeType_t dynamic_size_type); apx_error_t apx_vm_deserializer_unpack_byte(apx_vm_deserializer_t* self, uint32_t array_length, apx_sizeType_t dynamic_size_type); apx_error_t apx_vm_deserializer_unpack_record(apx_vm_deserializer_t* self, uint32_t array_length, apx_sizeType_t dynamic_size_type); -apx_error_t apx_vm_deserializer_record_select(apx_vm_deserializer_t* self, char const* key, bool is_last_field); +apx_error_t apx_vm_deserializer_record_select(apx_vm_deserializer_t* self, char const* key, bool const is_first_field); +apx_error_t apx_vm_deserializer_record_end(apx_vm_deserializer_t* self); apx_error_t apx_vm_deserializer_check_value_range_int32(apx_vm_deserializer_t* self, int32_t lower_limit, int32_t upper_limit); apx_error_t apx_vm_deserializer_check_value_range_uint32(apx_vm_deserializer_t* self, uint32_t lower_limit, uint32_t upper_limit); apx_error_t apx_vm_deserializer_check_value_range_int64(apx_vm_deserializer_t* self, int64_t lower_limit, int64_t upper_limit); diff --git a/apx/include/apx/program.h b/apx/include/apx/program.h index e365f54..1184c5e 100644 --- a/apx/include/apx/program.h +++ b/apx/include/apx/program.h @@ -55,7 +55,8 @@ typedef struct apx_programHeader_tag apx_error_t apx_program_encode_header(apx_program_t *program, apx_programType_t program_type, uint32_t element_size, uint32_t queue_size, bool is_dynamic); apx_error_t apx_program_decode_header(uint8_t const* begin, uint8_t const* end, uint8_t const** next, apx_programHeader_t *header); uint8_t apx_program_encode_instruction(uint8_t opcode, uint8_t variant, bool flag); -void apx_program_decode_instruction(uint8_t instruction, uint8_t* opcode, uint8_t* variant, bool* flag); +void apx_program_decode_instruction(uint8_t const instruction, uint8_t* opcode, uint8_t* variant, bool* flag); +void apx_program_dump(apx_program_t const* program); #define APX_PROGRAM_CREATE(p) adt_bytearray_create(p, APX_PROGRAM_GROW_SIZE) #define APX_PROGRAM_NEW() adt_bytearray_new(APX_PROGRAM_GROW_SIZE) diff --git a/apx/include/apx/serializer.h b/apx/include/apx/serializer.h index cb29584..f665bbb 100644 --- a/apx/include/apx/serializer.h +++ b/apx/include/apx/serializer.h @@ -66,7 +66,6 @@ typedef struct apx_vm_writeState_tag dtl_dv_type_id value_type; //describes which part of the value union is currently active scalar_storage_type_t scalar_storage_type; //describes which part of the scalar_value union is currently active apx_typeCode_t type_code; - bool is_last_field; apx_sizeType_t dynamic_size_type; apx_rangeCheckState_t range_check_state; } apx_vm_writeState_t; @@ -140,7 +139,8 @@ apx_error_t apx_vm_serializer_pack_char8(apx_vm_serializer_t* self, uint32_t arr apx_error_t apx_vm_serializer_pack_bool(apx_vm_serializer_t* self, uint32_t array_length, apx_sizeType_t dynamic_size_type); apx_error_t apx_vm_serializer_pack_byte(apx_vm_serializer_t* self, uint32_t array_length, apx_sizeType_t dynamic_size_type); apx_error_t apx_vm_serializer_pack_record(apx_vm_serializer_t* self, uint32_t array_length, apx_sizeType_t dynamic_size_type); -apx_error_t apx_vm_serializer_record_select(apx_vm_serializer_t* self, char const* key, bool is_last_field); +apx_error_t apx_vm_serializer_record_select(apx_vm_serializer_t* self, char const* key, bool const is_first_field); +apx_error_t apx_vm_serializer_record_end(apx_vm_serializer_t* self); apx_error_t apx_vm_serializer_check_value_range_int32(apx_vm_serializer_t* self, int32_t lower_limit, int32_t upper_limit); apx_error_t apx_vm_serializer_check_value_range_uint32(apx_vm_serializer_t* self, uint32_t lower_limit, uint32_t upper_limit); apx_error_t apx_vm_serializer_check_value_range_int64(apx_vm_serializer_t* self, int64_t lower_limit, int64_t upper_limit); diff --git a/apx/include/apx/vm_defs.h b/apx/include/apx/vm_defs.h index a92d5e9..9606d4e 100644 --- a/apx/include/apx/vm_defs.h +++ b/apx/include/apx/vm_defs.h @@ -108,12 +108,14 @@ 4: S8 5: S16 6: S32 - 7: S64 - 8: ARRAY - 9: RECORD - 10: BOOL - 11: BYTE (immutable bytes object) - 12: CHAR + 8: BOOL + 9: BYTE (immutable bytes object) + 10: RECORD + 11: ARRAY + 12: ASCII_CHAR + 13: CHAR8 + 14: CHAR16 + 15: CHAR32 2: DATA_SIZE : 6 variants FLAG: is_dynamic_array(true, false) @@ -130,19 +132,19 @@ 10: ELEMENT_SIZE_U32_QUEUE_SIZE_U16 11: ELEMENT_SIZE_U32_QUEUE_SIZE_U32 - 3: DATA_CTRL : 9 variants + 3: DATA_CTRL : 10 variants 0: RECORD_SELECT - 1: LIMIT_CHECK_U8 - 2: LIMIT_CHECK_U16 - 3: LIMIT_CHECK_U32 - 4: LIMIT_CHECK_U64 - 5: LIMIT_CHECK_S8 - 6: LIMIT_CHECK_S16 - 7: LIMIT_CHECK_S32 - 8: LIMIT_CHECK_S64 - FLAG(variant 0): When true: This is the last record field. - When false: More record fields to follow - FLAG (variant 1..8): When true, the limit check applies to non-scalar value (such as array of u8, u16 etc.) + 1: RECORD_END + 2: LIMIT_CHECK_U8 + 3: LIMIT_CHECK_U16 + 4: LIMIT_CHECK_U32 + 5: LIMIT_CHECK_U64 + 6: LIMIT_CHECK_S8 + 7: LIMIT_CHECK_S16 + 8: LIMIT_CHECK_S32 + 9: LIMIT_CHECK_S64 + FLAG (variant 0): When true, this is the first field of the record. + FLAG (variants 1..9): When true, the limit check applies to non-scalar value (such as array of u8, u16 etc.) 4: FLOW_CTRL : 1 variant 0: ARRAY_NEXT 5: UNPACK2 (reserved for 16 additional data types) @@ -204,12 +206,13 @@ #define APX_VM_OPCODE_DATA_CTRL ((uint8_t) 3u) #define APX_VM_VARIANT_RECORD_SELECT ((uint8_t) 0u) #define APX_VM_VARIANT_LIMIT_CHECK_NONE ((uint8_t) 0u) //Overlays with APX_VM_VARIANT_RECORD_SELECT (context-specific) -#define APX_VM_VARIANT_LIMIT_CHECK_U8 ((uint8_t) 1u) -#define APX_VM_VARIANT_LIMIT_CHECK_U16 ((uint8_t) 2u) -#define APX_VM_VARIANT_LIMIT_CHECK_U32 ((uint8_t) 3u) -#define APX_VM_VARIANT_LIMIT_CHECK_U64 ((uint8_t) 4u) -#define APX_VM_VARIANT_LIMIT_CHECK_S8 ((uint8_t) 5u) -#define APX_VM_VARIANT_LIMIT_CHECK_S16 ((uint8_t) 6u) +#define APX_VM_VARIANT_RECORD_END ((uint8_t) 1u) +#define APX_VM_VARIANT_LIMIT_CHECK_U8 ((uint8_t) 2u) +#define APX_VM_VARIANT_LIMIT_CHECK_U16 ((uint8_t) 3u) +#define APX_VM_VARIANT_LIMIT_CHECK_U32 ((uint8_t) 4u) +#define APX_VM_VARIANT_LIMIT_CHECK_U64 ((uint8_t) 5u) +#define APX_VM_VARIANT_LIMIT_CHECK_S8 ((uint8_t) 6u) +#define APX_VM_VARIANT_LIMIT_CHECK_S16 ((uint8_t) 7u) #define APX_VM_VARIANT_LIMIT_CHECK_S32 ((uint8_t) 8u) #define APX_VM_VARIANT_LIMIT_CHECK_S64 ((uint8_t) 9u) #define APX_VM_VARIANT_LIMIT_CHECK_LAST APX_VM_VARIANT_LIMIT_CHECK_S64 @@ -228,7 +231,7 @@ #define APX_VM_INST_FLAG 0x80 #define APX_VM_ARRAY_FLAG APX_VM_INST_FLAG #define APX_VM_DYN_ARRAY_FLAG APX_VM_INST_FLAG -#define APX_VM_LAST_FIELD_FLAG APX_VM_INST_FLAG +#define APX_VM_FIRST_FIELD_FLAG APX_VM_INST_FLAG #define APX_VM_UINT8_SIZE ((uint32_t) sizeof(uint8_t)) #define APX_VM_CHAR_SIZE ((uint32_t) sizeof(char)) @@ -254,7 +257,8 @@ typedef uint8_t apx_operationType_t; #define APX_OPERATION_TYPE_RANGE_CHECK_INT64 ((apx_operationType_t) 5u) #define APX_OPERATION_TYPE_RANGE_CHECK_UINT64 ((apx_operationType_t) 6u) #define APX_OPERATION_TYPE_RECORD_SELECT ((apx_operationType_t) 7u) -#define APX_OPERATION_TYPE_ARRAY_NEXT ((apx_operationType_t) 8u) +#define APX_OPERATION_TYPE_RECORD_END ((apx_operationType_t) 8u) +#define APX_OPERATION_TYPE_ARRAY_NEXT ((apx_operationType_t) 9u) typedef struct apx_packUnpackOperationInfo_tag { diff --git a/apx/src/compiler.c b/apx/src/compiler.c index 25f5dd1..27fb8a1 100644 --- a/apx/src/compiler.c +++ b/apx/src/compiler.c @@ -58,7 +58,8 @@ static apx_error_t compile_limit_values_int64(apx_compiler_t* self, uint8_t limi static apx_error_t compile_limit_values_uint64(apx_compiler_t* self, uint8_t limit_variant, uint64_t lower_limit, uint64_t upper_limit); static apx_error_t compile_array_size_instruction(apx_compiler_t* self, uint32_t array_size, bool is_dynamic_array); static apx_error_t compile_record_fields(apx_compiler_t* self, apx_dataElement_t const* data_element, apx_programType_t program_type, uint32_t* record_size); -static apx_error_t compile_record_select_instruction(apx_compiler_t* self, apx_dataElement_t const* data_element, bool is_last_field); +static apx_error_t compile_record_select_instruction(apx_compiler_t* self, apx_dataElement_t const* data_element, bool const is_first_field); +static apx_error_t compile_record_end_instruction(apx_compiler_t* self); static apx_error_t compile_array_next_instruction(apx_compiler_t* self); @@ -647,13 +648,13 @@ static apx_error_t compile_record_fields(apx_compiler_t* self, apx_dataElement_t { return APX_EMPTY_RECORD_ERROR; } + apx_error_t result = APX_NO_ERROR; for (i = 0u; i < num_children; i++) { - apx_error_t result = APX_NO_ERROR; uint32_t child_size = 0u; apx_dataElement_t const* child_element = apx_dataElement_get_child_at(data_element, i); assert(child_element != NULL); - result = compile_record_select_instruction(self, child_element, (i == (num_children - 1)) ? true : false); + result = compile_record_select_instruction(self, child_element, (i==0u) ? true : false); if (result != APX_NO_ERROR) { return result; @@ -676,10 +677,15 @@ static apx_error_t compile_record_fields(apx_compiler_t* self, apx_dataElement_t } *record_size += child_size; } + result = compile_record_end_instruction(self); + if (result != APX_NO_ERROR) + { + return result; + } return APX_NO_ERROR; } -static apx_error_t compile_record_select_instruction(apx_compiler_t* self, apx_dataElement_t const* data_element, bool is_last_field) +static apx_error_t compile_record_select_instruction(apx_compiler_t* self, apx_dataElement_t const* data_element, bool const is_first_field) { assert((self != NULL) && (data_element != NULL)); char const* name = apx_dataElement_get_name(data_element); @@ -698,7 +704,7 @@ static apx_error_t compile_record_select_instruction(apx_compiler_t* self, apx_d { return APX_NAME_TOO_LONG_ERROR; } - uint8_t const instruction = apx_program_encode_instruction(APX_VM_OPCODE_DATA_CTRL, APX_VM_VARIANT_RECORD_SELECT, is_last_field); + uint8_t const instruction = apx_program_encode_instruction(APX_VM_OPCODE_DATA_CTRL, APX_VM_VARIANT_RECORD_SELECT, is_first_field); rc = adt_bytearray_push(self->program, instruction); if (rc == ADT_NO_ERROR) { @@ -711,6 +717,14 @@ static apx_error_t compile_record_select_instruction(apx_compiler_t* self, apx_d return convert_from_adt_to_apx_error(rc); } +static apx_error_t compile_record_end_instruction(apx_compiler_t* self) +{ + assert(self != NULL); + uint8_t const instruction = apx_program_encode_instruction(APX_VM_OPCODE_DATA_CTRL, APX_VM_VARIANT_RECORD_END, false); + adt_error_t rc = adt_bytearray_push(self->program, instruction); + return convert_from_adt_to_apx_error(rc); +} + static apx_error_t compile_array_next_instruction(apx_compiler_t* self) { assert(self != NULL); diff --git a/apx/src/decoder.c b/apx/src/decoder.c index 1297c85..58dbf2d 100644 --- a/apx/src/decoder.c +++ b/apx/src/decoder.c @@ -50,7 +50,8 @@ static apx_error_t decode_range_check_uint32(apx_vm_decoder_t* self, uint8_t var static apx_error_t decode_range_check_uint64(apx_vm_decoder_t* self, uint8_t variant); static apx_error_t decode_range_check_int32(apx_vm_decoder_t* self, uint8_t variant); static apx_error_t decode_range_check_int64(apx_vm_decoder_t* self, uint8_t variant); -static apx_error_t decode_record_select(apx_vm_decoder_t* self, bool is_last_field); +static apx_error_t decode_record_select(apx_vm_decoder_t* self, bool is_first_field); +static apx_error_t decode_record_end(apx_vm_decoder_t* self); ////////////////////////////////////////////////////////////////////////////// // PUBLIC FUNCTIONS @@ -76,7 +77,7 @@ void apx_vm_decoder_create(apx_vm_decoder_t* self) self->range_check_int64_info.lower_limit = 0; self->range_check_int64_info.upper_limit = 0; adt_str_create(&self->field_name); - self->is_last_field = false; + self->is_first_field = false; } } @@ -218,11 +219,11 @@ bool apx_vm_decoder_has_saved_program_position(apx_vm_decoder_t* self) return false; } -bool apx_vm_decoder_is_last_field(apx_vm_decoder_t* self) +bool apx_vm_decoder_is_first_field(apx_vm_decoder_t* self) { if (self != NULL) { - return self->is_last_field; + return self->is_first_field; } return false; } @@ -260,6 +261,10 @@ static apx_error_t decode_next_instruction_internal(apx_vm_decoder_t* self) { return decode_record_select(self, flag); } + else if (variant == APX_VM_VARIANT_RECORD_END) + { + return decode_record_end(self); + } else if (variant <= APX_VM_VARIANT_LIMIT_CHECK_LAST) { switch (variant) @@ -490,7 +495,7 @@ static apx_error_t decode_range_check_int64(apx_vm_decoder_t* self, uint8_t vari return APX_UNEXPECTED_END_ERROR; } -static apx_error_t decode_record_select(apx_vm_decoder_t* self, bool is_last_field) +static apx_error_t decode_record_select(apx_vm_decoder_t* self, bool is_first_field) { assert(self != NULL); self->operation_type = APX_OPERATION_TYPE_RECORD_SELECT; @@ -499,8 +504,16 @@ static apx_error_t decode_record_select(apx_vm_decoder_t* self, bool is_last_fie { adt_str_set_bstr(&self->field_name, self->program_next, result); self->program_next = result + UINT8_SIZE; //Skip past null-terminator - self->is_last_field = is_last_field; + self->is_first_field = is_first_field; return APX_NO_ERROR; } return APX_INVALID_INSTRUCTION_ERROR; } + +static apx_error_t decode_record_end(apx_vm_decoder_t* self) +{ + assert(self != NULL); + self->operation_type = APX_OPERATION_TYPE_RECORD_END; + return APX_NO_ERROR; +} + diff --git a/apx/src/deserializer.c b/apx/src/deserializer.c index c5d9adb..8669255 100644 --- a/apx/src/deserializer.c +++ b/apx/src/deserializer.c @@ -67,7 +67,7 @@ static apx_error_t state_determine_array_length_from_read_buffer(apx_vm_readStat static dtl_sv_t* state_take_sv(apx_vm_readState_t* self); static apx_error_t state_push_array_value(apx_vm_readState_t* self, dtl_dv_t* dv); static apx_error_t state_read_byte_array(apx_vm_readState_t* self, apx_vm_readBuffer_t* buffer); -static apx_error_t state_set_field_name(apx_vm_readState_t* self, char const* name, bool is_last_field); +static apx_error_t state_set_field_name(apx_vm_readState_t* self, char const* name); static apx_error_t state_create_child_value_from_child_state(apx_vm_readState_t* self, apx_vm_readState_t* child_state); static apx_error_t state_push_value_from_child_state(apx_vm_readState_t* self, apx_vm_readState_t* child_state); @@ -404,13 +404,21 @@ apx_error_t apx_vm_deserializer_unpack_record(apx_vm_deserializer_t* self, uint3 return APX_INVALID_ARGUMENT_ERROR; } -apx_error_t apx_vm_deserializer_record_select(apx_vm_deserializer_t* self, char const* key, bool is_last_field) +apx_error_t apx_vm_deserializer_record_select(apx_vm_deserializer_t* self, char const* key, bool const is_first_field) { if ( (self != NULL) && (key != NULL) ) { + if (!is_first_field) + { + apx_error_t const result = deserializer_pop_state(self); + if (result != APX_NO_ERROR) + { + return result; + } + } if (self->state->value_type == DTL_DV_HASH) { - state_set_field_name(self->state, key, is_last_field); + state_set_field_name(self->state, key); deserializer_enter_new_child_state(self); return APX_NO_ERROR; } @@ -419,6 +427,15 @@ apx_error_t apx_vm_deserializer_record_select(apx_vm_deserializer_t* self, char return APX_INVALID_ARGUMENT_ERROR; } +apx_error_t apx_vm_deserializer_record_end(apx_vm_deserializer_t* self) +{ + if (self != NULL) + { + return deserializer_pop_state(self); + } + return APX_INVALID_ARGUMENT_ERROR; +} + apx_error_t apx_vm_deserializer_check_value_range_int32(apx_vm_deserializer_t* self, int32_t lower_limit, int32_t upper_limit) { if (self != NULL) @@ -664,6 +681,7 @@ apx_error_t apx_vm_deserializer_array_next(apx_vm_deserializer_t* self, bool* is if ((self != NULL) && (is_last != NULL)) { *is_last = false; + deserializer_pop_state(self); if (self->state->value_type == DTL_DV_ARRAY) { if (self->state->array_len > 0) @@ -780,7 +798,6 @@ static void state_create(apx_vm_readState_t* self) self->value_type = DTL_DV_NULL; self->scalar_storage_type = APX_VM_SCALAR_STORAGE_TYPE_NONE; self->type_code = APX_TYPE_CODE_NONE; - self->is_last_field = false; self->dynamic_size_type = APX_SIZE_TYPE_NONE; self->range_check_state = APX_RANGE_CHECK_STATE_NOT_CHECKED; self->scalar_value.i32 = 0u; @@ -829,7 +846,6 @@ static void state_reset(apx_vm_readState_t* self) self->array_len = 0u; self->max_array_len = 0u; self->element_size = 0u; - self->is_last_field = false; self->type_code = APX_TYPE_CODE_NONE; self->scalar_storage_type = APX_VM_SCALAR_STORAGE_TYPE_NONE; self->range_check_state = APX_RANGE_CHECK_STATE_NOT_CHECKED; @@ -1190,13 +1206,12 @@ static apx_error_t state_read_byte_array(apx_vm_readState_t* self, apx_vm_readBu return APX_NO_ERROR; } -static apx_error_t state_set_field_name(apx_vm_readState_t* self, char const* name, bool is_last_field) +static apx_error_t state_set_field_name(apx_vm_readState_t* self, char const* name) { if ((self != NULL) && (name != NULL)) { apx_error_t retval = APX_NO_ERROR; adt_error_t rc; - self->is_last_field = is_last_field; rc = adt_str_set_cstr(&self->field_name, name); if (rc != ADT_NO_ERROR) { @@ -1339,7 +1354,6 @@ apx_error_t deserializer_unpack_value(apx_vm_deserializer_t* self, uint32_t arra assert(self != NULL); apx_error_t retval = APX_NO_ERROR; assert(self->state != NULL); - bool do_pop_state = true; retval = deserializer_prepare_for_array(self, array_length, dynamic_size_type); if (retval == APX_NO_ERROR) { @@ -1368,7 +1382,6 @@ apx_error_t deserializer_unpack_value(apx_vm_deserializer_t* self, uint32_t arra } else if (state_is_record_type(self->state)) { - do_pop_state = false; retval = deserializer_unpack_record_value(self); } else @@ -1395,7 +1408,6 @@ apx_error_t deserializer_unpack_value(apx_vm_deserializer_t* self, uint32_t arra } else if (state_is_record_type(self->state)) { - do_pop_state = false; retval = deserializer_unpack_record_value(self); } else @@ -1404,13 +1416,6 @@ apx_error_t deserializer_unpack_value(apx_vm_deserializer_t* self, uint32_t arra } } } - if (retval == APX_NO_ERROR) - { - if (do_pop_state) - { - retval = deserializer_pop_state(self); - } - } } return retval; } @@ -1571,7 +1576,7 @@ static apx_error_t deserializer_unpack_byte_array_internal(apx_vm_deserializer_t static apx_error_t deserializer_pop_state(apx_vm_deserializer_t* self) { assert(self->state != NULL); - while (adt_stack_size(&self->stack) > 0) + if (adt_stack_size(&self->stack) > 0) { apx_vm_readState_t* child_state = self->state; assert(child_state != NULL); @@ -1605,10 +1610,6 @@ static apx_error_t deserializer_pop_state(apx_vm_deserializer_t* self) return APX_NOT_IMPLEMENTED_ERROR; } state_delete(child_state); - if (!self->state->is_last_field) - { - break; - } } return APX_NO_ERROR; } diff --git a/apx/src/program.c b/apx/src/program.c index 2da9c14..7da671f 100644 --- a/apx/src/program.c +++ b/apx/src/program.c @@ -28,6 +28,7 @@ // INCLUDES ////////////////////////////////////////////////////////////////////////////// #include +#include #include "apx/program.h" #include "apx/vm_common.h" #include "pack.h" @@ -248,7 +249,7 @@ uint8_t apx_program_encode_instruction(uint8_t opcode, uint8_t variant, bool fla return result; } -void apx_program_decode_instruction(uint8_t instruction, uint8_t* opcode, uint8_t* variant, bool* flag) +void apx_program_decode_instruction(uint8_t const instruction, uint8_t* opcode, uint8_t* variant, bool* flag) { if ((opcode != NULL) && (variant != NULL) && (flag != NULL)) { @@ -286,3 +287,20 @@ static uint8_t calc_data_size_variant(uint8_t element_variant, uint8_t queue_var return retval; } +void apx_program_dump(apx_program_t const* program) +{ + if (program != NULL) + { + uint8_t const* program_next = adt_bytearray_data(program); + uint8_t const* program_end = program_next + adt_bytearray_length(program); + while(program_next < program_end) + { + uint8_t const instruction = *program_next++; + uint8_t opcode = 0u; + uint8_t variant = 0u; + bool flag = false; + apx_program_decode_instruction(instruction, &opcode, &variant, &flag); + printf("Instruction: 0x%02X, Opcode: 0x%02X, Variant: 0x%02X, Flag: %d\n", instruction, opcode, variant, flag); + } + } +} \ No newline at end of file diff --git a/apx/src/serializer.c b/apx/src/serializer.c index 10bdabb..d5730a2 100644 --- a/apx/src/serializer.c +++ b/apx/src/serializer.c @@ -67,7 +67,7 @@ static apx_error_t state_read_scalar_array_value(apx_vm_writeState_t* self, int3 static apx_error_t state_read_scalar_value_internal(apx_vm_writeState_t* self, dtl_sv_t const* sv, apx_typeCode_t type_code); static apx_error_t state_default_range_check_scalar(apx_vm_writeState_t* self); static dtl_dv_t* state_get_child_value(apx_vm_writeState_t* self, char const* key); -static apx_error_t state_set_field_name(apx_vm_writeState_t* self, char const* name, bool is_last_field); +static apx_error_t state_set_field_name(apx_vm_writeState_t* self, char const* name); //apx_vm_queuedWriteState_t API static void queued_write_state_init(apx_vm_queuedWriteState_t* self); @@ -110,7 +110,6 @@ void apx_vm_writeState_create(apx_vm_writeState_t* self) self->value_type = DTL_DV_NULL; self->scalar_storage_type = APX_VM_SCALAR_STORAGE_TYPE_NONE; self->type_code = APX_TYPE_CODE_NONE; - self->is_last_field = false; self->dynamic_size_type = APX_SIZE_TYPE_NONE; self->range_check_state = APX_RANGE_CHECK_STATE_NOT_CHECKED; self->scalar_value.i32 = 0u; @@ -528,11 +527,14 @@ apx_error_t apx_vm_serializer_pack_record(apx_vm_serializer_t* self, uint32_t ar return APX_INVALID_ARGUMENT_ERROR; } -apx_error_t apx_vm_serializer_record_select(apx_vm_serializer_t* self, char const* key, bool is_last_field) +apx_error_t apx_vm_serializer_record_select(apx_vm_serializer_t* self, char const* key, bool const is_first_field) { - if ( (self != NULL) && (key != NULL) ) { + if (!is_first_field) + { + serializer_pop_state(self); + } if (self->state->value_type == DTL_DV_HASH) { dtl_dv_t* child_value = state_get_child_value(self->state, key); @@ -540,9 +542,9 @@ apx_error_t apx_vm_serializer_record_select(apx_vm_serializer_t* self, char cons { return APX_NOT_FOUND_ERROR; } - state_set_field_name(self->state, key, is_last_field); + state_set_field_name(self->state, key); serializer_enter_new_child_state(self); - state_set_value(self->state, child_value); //m_state on this line is the newly entered child_state + state_set_value(self->state, child_value); //state on this line is the newly entered child_state return APX_NO_ERROR; } return APX_VALUE_TYPE_ERROR; @@ -550,6 +552,15 @@ apx_error_t apx_vm_serializer_record_select(apx_vm_serializer_t* self, char cons return APX_INVALID_ARGUMENT_ERROR; } +apx_error_t apx_vm_serializer_record_end(apx_vm_serializer_t* self) +{ + if (self != NULL) + { + serializer_pop_state(self); + } + return APX_NO_ERROR; +} + apx_error_t apx_vm_serializer_check_value_range_int32(apx_vm_serializer_t* self, int32_t lower_limit, int32_t upper_limit) { if (self != NULL) @@ -843,6 +854,7 @@ apx_error_t apx_vm_serializer_array_next(apx_vm_serializer_t* self, bool* is_las if ((self != NULL) && (is_last != NULL)) { *is_last = false; + serializer_pop_state(self); if (self->state->value_type == DTL_DV_ARRAY) { if (self->state->array_len > 0) @@ -927,7 +939,6 @@ static void state_reset(apx_vm_writeState_t* self, dtl_dv_type_id type_id) self->array_len = 0u; self->max_array_len = 0u; self->element_size = 0u; - self->is_last_field = false; self->type_code = APX_TYPE_CODE_NONE; self->scalar_storage_type = APX_VM_SCALAR_STORAGE_TYPE_NONE; self->range_check_state = APX_RANGE_CHECK_STATE_NOT_CHECKED; @@ -1265,14 +1276,13 @@ static dtl_dv_t* state_get_child_value(apx_vm_writeState_t* self, char const* ke return NULL; } -static apx_error_t state_set_field_name(apx_vm_writeState_t* self, char const* name, bool is_last_field) +static apx_error_t state_set_field_name(apx_vm_writeState_t* self, char const* name) { assert( self != NULL); if (name == NULL) { return APX_NULL_PTR_ERROR; } - self->is_last_field = is_last_field; return convert_from_adt_to_apx_error(adt_str_set_cstr(&self->field_name, name)); } @@ -1362,7 +1372,7 @@ static apx_error_t serializer_pack_value(apx_vm_serializer_t* self) assert(self != NULL); apx_error_t retval = APX_NO_ERROR; assert(self->state != NULL); - bool do_pop_state = true; + if (queued_write_state_is_active(&self->queued_write_state)) { if (self->queued_write_state.current_length >= self->queued_write_state.max_length) @@ -1385,7 +1395,6 @@ static apx_error_t serializer_pack_value(apx_vm_serializer_t* self) } else if (state_is_record_type(self->state)) { - do_pop_state = false; retval = serializer_pack_record_value(self); } else @@ -1416,7 +1425,6 @@ static apx_error_t serializer_pack_value(apx_vm_serializer_t* self) } else if (state_is_record_type(self->state)) { - do_pop_state = false; retval = serializer_pack_record_value(self); } else @@ -1431,10 +1439,6 @@ static apx_error_t serializer_pack_value(apx_vm_serializer_t* self) { self->queued_write_state.current_length++; } - if (do_pop_state) - { - serializer_pop_state(self); - } } return retval; } @@ -1690,16 +1694,12 @@ static apx_error_t serializer_pack_byte_array_internal(apx_vm_serializer_t* self static void serializer_pop_state(apx_vm_serializer_t* self) { assert(self->state != NULL); - while (adt_stack_size(&self->stack) > 0) + if (adt_stack_size(&self->stack) > 0) { assert(self->state != NULL); apx_vm_writeState_delete(self->state); self->state = adt_stack_top(&self->stack); adt_stack_pop(&self->stack); - if (!self->state->is_last_field) - { - break; - } } } diff --git a/apx/src/vm.c b/apx/src/vm.c index 94c212d..caa4cb5 100644 --- a/apx/src/vm.c +++ b/apx/src/vm.c @@ -57,7 +57,9 @@ static apx_error_t run_range_check_unpack_uint32(apx_vm_t* self); static apx_error_t run_range_check_unpack_int64(apx_vm_t* self); static apx_error_t run_range_check_unpack_uint64(apx_vm_t* self); static apx_error_t run_pack_record_select(apx_vm_t* self); +static apx_error_t run_pack_record_end(apx_vm_t* self); static apx_error_t run_unpack_record_select(apx_vm_t* self); +static apx_error_t run_unpack_record_end(apx_vm_t* self); static apx_error_t run_array_next(apx_vm_t* self); ////////////////////////////////////////////////////////////////////////////// @@ -272,6 +274,9 @@ static apx_error_t run_pack_program(apx_vm_t* self) case APX_OPERATION_TYPE_RECORD_SELECT: result = run_pack_record_select(self); break; + case APX_OPERATION_TYPE_RECORD_END: + result = run_pack_record_end(self); + break; case APX_OPERATION_TYPE_ARRAY_NEXT: result = run_array_next(self); break; @@ -320,6 +325,9 @@ static apx_error_t run_unpack_program(apx_vm_t* self) case APX_OPERATION_TYPE_RECORD_SELECT: result = run_unpack_record_select(self); break; + case APX_OPERATION_TYPE_RECORD_END: + result = run_unpack_record_end(self); + break; case APX_OPERATION_TYPE_ARRAY_NEXT: result = run_array_next(self); break; @@ -511,18 +519,27 @@ static apx_error_t run_range_check_unpack_uint64(apx_vm_t* self) static apx_error_t run_pack_record_select(apx_vm_t* self) { char const* field_name = apx_vm_decoder_get_field_name(&self->decoder); - bool is_last_field = apx_vm_decoder_is_last_field(&self->decoder); + bool const is_first_field = apx_vm_decoder_is_first_field(&self->decoder); assert(field_name != NULL); - return apx_vm_serializer_record_select(&self->serializer, field_name, is_last_field); + return apx_vm_serializer_record_select(&self->serializer, field_name, is_first_field); +} + +static apx_error_t run_pack_record_end(apx_vm_t* self) +{ + return apx_vm_serializer_record_end(&self->serializer); } static apx_error_t run_unpack_record_select(apx_vm_t* self) { char const* field_name = apx_vm_decoder_get_field_name(&self->decoder); - bool is_last_field = apx_vm_decoder_is_last_field(&self->decoder); + bool const is_first_field = apx_vm_decoder_is_first_field(&self->decoder); assert(field_name != NULL); - return apx_vm_deserializer_record_select(&self->deserializer, field_name, is_last_field); + return apx_vm_deserializer_record_select(&self->deserializer, field_name, is_first_field); +} +static apx_error_t run_unpack_record_end(apx_vm_t* self) +{ + return apx_vm_deserializer_record_end(&self->deserializer); } static apx_error_t run_array_next(apx_vm_t* self) diff --git a/apx/test/testsuite_client.c b/apx/test/testsuite_client.c index 56eeda5..a80d6f6 100644 --- a/apx/test/testsuite_client.c +++ b/apx/test/testsuite_client.c @@ -28,21 +28,19 @@ static const char *m_apx_definition2 = "APX/1.2\n" "R\"U16Value\"S:=0xffff\n" "R\"U32Value\"L:=0xffffffff\n" "\n"; -/* + static const char *m_apx_definition3 = "APX/1.2\n" "N\"TestNode3\"\n" - "P\"U8Array\"C[3]:={0xFF, 0xFF, 0xFF}\n" - "P\"U16Array\"S[3]:={0xFFFF, 0xFFFF, 0xFFFF}\n" - "P\"U32Array\"L[3]:={0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}\n" + "T\"RecordType\"{\"First\"C(0,7)\"Second\"C[4]}\n" + "R\"RecordPort\"T[0]:={7,{0,0,0,0}}\n" "\n"; -static const char *m_apx_definition4 = "APX/1.2\n" +static const char *m_apx_definition4 = "APX/1.3\n" "N\"TestNode4\"\n" - "R\"U8Array\"C[3]:={0xFF, 0xFF, 0xFF}\n" - "R\"U16Array\"S[3]:={0xFFFF, 0xFFFF, 0xFFFF}\n" - "R\"U32Array\"L[3]:={0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}\n" + "T\"ArrayType\"{\"First\"C(0,15)\"Second\"C(0,15)}[3]\n" + "R\"ArrayPort\"T[0]:={{0xf,0xf},{0xf,0xf},{0xf,0xf}}\n" "\n"; - +/* static const char *m_apx_definition5 = "APX/1.2\n" "N\"TestNode5\"\n" "P\"S8Value\"c:=-1\n" @@ -113,10 +111,8 @@ static void test_apx_client_write_port_dtl_u16(CuTest* tc); static void test_apx_client_read_port_dtl_u16(CuTest* tc); static void test_apx_client_write_port_dtl_u32(CuTest* tc); static void test_apx_client_read_port_dtl_u32(CuTest* tc); - - - - +static void test_apx_client_read_struct_with_array(CuTest* tc); +static void test_apx_client_read_array_of_structs(CuTest* tc); ////////////////////////////////////////////////////////////////////////////// @@ -141,6 +137,8 @@ CuSuite* testSuite_apx_client(void) SUITE_ADD_TEST(suite, test_apx_client_read_port_dtl_u16); SUITE_ADD_TEST(suite, test_apx_client_write_port_dtl_u32); SUITE_ADD_TEST(suite, test_apx_client_read_port_dtl_u32); + SUITE_ADD_TEST(suite, test_apx_client_read_struct_with_array); + SUITE_ADD_TEST(suite, test_apx_client_read_array_of_structs); return suite; @@ -491,3 +489,118 @@ static void test_apx_client_read_port_dtl_u32(CuTest* tc) apx_client_delete(client); } + +static void test_apx_client_read_struct_with_array(CuTest* tc) +{ + const uint32_t offset = 0; + void* port_instance = NULL; + uint8_t raw_data[UINT8_SIZE*5] = { 0x01, 0x02, 0x03, 0x04, 0x05 }; + apx_nodeInstance_t* node_instance; + apx_nodeData_t* node_data; + dtl_hv_t* hv = NULL; + dtl_sv_t* child_sv = NULL; + dtl_av_t* child_av = NULL; + bool ok = false; + apx_client_t* client; + + client = apx_client_new(); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_client_build_node(client, m_apx_definition3)); + port_instance = apx_client_get_port_instance_by_name(client, NULL, "RecordPort"); + CuAssertPtrNotNull(tc, port_instance); + node_instance = apx_client_get_last_attached_node(client); + CuAssertPtrNotNull(tc, node_instance); + node_data = apx_nodeInstance_get_node_data(node_instance); + CuAssertPtrNotNull(tc, node_data); + apx_nodeData_write_require_port_data(node_data, offset, raw_data, (apx_size_t)sizeof(raw_data)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_client_read_port_data(client, port_instance, (dtl_dv_t**)&hv)); + CuAssertPtrNotNull(tc, hv); + child_sv = (dtl_sv_t*)dtl_hv_get_cstr(hv, "First"); + CuAssertPtrNotNull(tc, child_sv); + CuAssertUIntEquals(tc, 0x01, dtl_sv_to_u32(child_sv, &ok)); + CuAssertTrue(tc, ok); + child_av = (dtl_av_t*)dtl_hv_get_cstr(hv, "Second"); + CuAssertIntEquals(tc, DTL_DV_ARRAY, dtl_dv_type((dtl_dv_t*)child_av)); + CuAssertPtrNotNull(tc, child_av); + CuAssertIntEquals(tc, 4, dtl_av_length(child_av)); + child_sv = (dtl_sv_t*)dtl_av_value(child_av, 0); + CuAssertPtrNotNull(tc, child_sv); + CuAssertIntEquals(tc, DTL_DV_SCALAR, dtl_dv_type((dtl_dv_t*)child_sv)); + CuAssertUIntEquals(tc, 0x02, dtl_sv_to_u32(child_sv, &ok)); + CuAssertTrue(tc, ok); + child_sv = (dtl_sv_t*)dtl_av_value(child_av, 1); + CuAssertPtrNotNull(tc, child_sv); + CuAssertUIntEquals(tc, 0x03, dtl_sv_to_u32(child_sv, &ok)); + CuAssertTrue(tc, ok); + child_sv = (dtl_sv_t*)dtl_av_value(child_av, 2); + CuAssertPtrNotNull(tc, child_sv); + CuAssertUIntEquals(tc, 0x04, dtl_sv_to_u32(child_sv, &ok)); + CuAssertTrue(tc, ok); + child_sv = (dtl_sv_t*)dtl_av_value(child_av, 3); + CuAssertPtrNotNull(tc, child_sv); + CuAssertUIntEquals(tc, 0x05, dtl_sv_to_u32(child_sv, &ok)); + CuAssertTrue(tc, ok); + dtl_dv_dec_ref((dtl_dv_t*)hv); +} + +static void test_apx_client_read_array_of_structs(CuTest* tc) +{ + const uint32_t offset = 0; + void* port_instance = NULL; + uint8_t raw_data[UINT8_SIZE*6] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 }; + apx_nodeInstance_t* node_instance; + apx_nodeData_t* node_data; + dtl_av_t* av = NULL; + dtl_hv_t* child_hv = NULL; + dtl_sv_t* child_sv = NULL; + bool ok = false; + apx_client_t* client; + + client = apx_client_new(); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_client_build_node(client, m_apx_definition4)); + port_instance = apx_client_get_port_instance_by_name(client, NULL, "ArrayPort"); + CuAssertPtrNotNull(tc, port_instance); + node_instance = apx_client_get_last_attached_node(client); + CuAssertPtrNotNull(tc, node_instance); + node_data = apx_nodeInstance_get_node_data(node_instance); + CuAssertPtrNotNull(tc, node_data); + apx_nodeData_write_require_port_data(node_data, offset, raw_data, (apx_size_t)sizeof(raw_data)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_client_read_port_data(client, port_instance, (dtl_dv_t**)&av)); + CuAssertPtrNotNull(tc, av); + CuAssertIntEquals(tc, DTL_DV_ARRAY, dtl_dv_type((dtl_dv_t*)av)); + CuAssertIntEquals(tc, 3, dtl_av_length(av)); + child_hv = (dtl_hv_t*)dtl_av_value(av, 0); + CuAssertPtrNotNull(tc, child_hv); + CuAssertIntEquals(tc, DTL_DV_HASH, dtl_dv_type((dtl_dv_t*)child_hv)); + child_sv = (dtl_sv_t*)dtl_hv_get_cstr(child_hv, "First"); + CuAssertPtrNotNull(tc, child_sv); + CuAssertUIntEquals(tc, 0x01, dtl_sv_to_u32(child_sv, &ok)); + CuAssertTrue(tc, ok); + child_sv = (dtl_sv_t*)dtl_hv_get_cstr(child_hv, "Second"); + CuAssertPtrNotNull(tc, child_sv); + CuAssertUIntEquals(tc, 0x02, dtl_sv_to_u32(child_sv, &ok)); + CuAssertTrue(tc, ok); + child_hv = (dtl_hv_t*)dtl_av_value(av, 1); + CuAssertPtrNotNull(tc, child_hv); + CuAssertIntEquals(tc, DTL_DV_HASH, dtl_dv_type((dtl_dv_t*)child_hv)); + child_sv = (dtl_sv_t*)dtl_hv_get_cstr(child_hv, "First"); + CuAssertPtrNotNull(tc, child_sv); + CuAssertUIntEquals(tc, 0x03, dtl_sv_to_u32(child_sv, &ok)); + CuAssertTrue(tc, ok); + child_sv = (dtl_sv_t*)dtl_hv_get_cstr(child_hv, "Second"); + CuAssertPtrNotNull(tc, child_sv); + CuAssertUIntEquals(tc, 0x04, dtl_sv_to_u32(child_sv, &ok)); + CuAssertTrue(tc, ok); + child_hv = (dtl_hv_t*)dtl_av_value(av, 2); + CuAssertPtrNotNull(tc, child_hv); + CuAssertIntEquals(tc, DTL_DV_HASH, dtl_dv_type((dtl_dv_t*)child_hv)); + child_sv = (dtl_sv_t*)dtl_hv_get_cstr(child_hv, "First"); + CuAssertPtrNotNull(tc, child_sv); + CuAssertUIntEquals(tc, 0x05, dtl_sv_to_u32(child_sv, &ok)); + CuAssertTrue(tc, ok); + child_sv = (dtl_sv_t*)dtl_hv_get_cstr(child_hv, "Second"); + CuAssertPtrNotNull(tc, child_sv); + CuAssertUIntEquals(tc, 0x06, dtl_sv_to_u32(child_sv, &ok)); + CuAssertTrue(tc, ok); + + dtl_dv_dec_ref((dtl_dv_t*)av); +} \ No newline at end of file diff --git a/apx/test/testsuite_compiler_pack.c b/apx/test/testsuite_compiler_pack.c index 5657d43..49803f3 100644 --- a/apx/test/testsuite_compiler_pack.c +++ b/apx/test/testsuite_compiler_pack.c @@ -1132,12 +1132,13 @@ static void test_apx_compiler_pack_record_u8_u16(CuTest* tc) uint8_t const expected[] = { APX_VM_HEADER_PROG_TYPE_PACK | APX_VM_VARIANT_UINT8, UINT8_SIZE + UINT16_SIZE, APX_VM_OPCODE_PACK | (APX_VM_VARIANT_RECORD << APX_VM_INST_VARIANT_SHIFT), - APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_FIRST_FIELD_FLAG| APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'F', 'i', 'r', 's', 't', '\0', APX_VM_OPCODE_PACK | (APX_VM_VARIANT_UINT8 << APX_VM_INST_VARIANT_SHIFT), - APX_VM_LAST_FIELD_FLAG | APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'S', 'e', 'c', 'o', 'n', 'd', '\0', APX_VM_OPCODE_PACK | (APX_VM_VARIANT_UINT16 << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_END << APX_VM_INST_VARIANT_SHIFT), }; apx_istream_create(&stream); @@ -1220,18 +1221,19 @@ static void test_apx_compiler_pack_record_reference_with_child_references(CuTest uint8_t const expected[] = { APX_VM_HEADER_PROG_TYPE_PACK | APX_VM_VARIANT_UINT8, UINT8_SIZE + UINT8_SIZE, APX_VM_OPCODE_PACK | (APX_VM_VARIANT_RECORD << APX_VM_INST_VARIANT_SHIFT), - APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_FIRST_FIELD_FLAG | APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'F', 'i', 'r', 's', 't', '\0', APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_LIMIT_CHECK_U8 << APX_VM_INST_VARIANT_SHIFT), 0u, 3u, APX_VM_OPCODE_PACK | (APX_VM_VARIANT_UINT8 << APX_VM_INST_VARIANT_SHIFT), - APX_VM_LAST_FIELD_FLAG | APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'S', 'e', 'c', 'o', 'n', 'd', '\0', APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_LIMIT_CHECK_U8 << APX_VM_INST_VARIANT_SHIFT), 0u, 7u, APX_VM_OPCODE_PACK | (APX_VM_VARIANT_UINT8 << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_END << APX_VM_INST_VARIANT_SHIFT), }; apx_istream_create(&stream); @@ -1273,12 +1275,13 @@ static void test_apx_compiler_pack_array_of_records(CuTest* tc) APX_VM_ARRAY_FLAG | APX_VM_OPCODE_PACK | (APX_VM_VARIANT_RECORD << APX_VM_INST_VARIANT_SHIFT), APX_VM_OPCODE_DATA_SIZE | (APX_VM_VARIANT_ARRAY_SIZE_U8), array_length, - APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_FIRST_FIELD_FLAG | APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'I', 'd','\0', APX_VM_OPCODE_PACK | (APX_VM_VARIANT_UINT16 << APX_VM_INST_VARIANT_SHIFT), - APX_VM_LAST_FIELD_FLAG | APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'V', 'a', 'l', 'u', 'e', '\0', APX_VM_OPCODE_PACK | (APX_VM_VARIANT_UINT8 << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_END << APX_VM_INST_VARIANT_SHIFT), APX_VM_OPCODE_FLOW_CTRL | (APX_VM_VARIANT_ARRAY_NEXT << APX_VM_INST_VARIANT_SHIFT), }; @@ -1321,12 +1324,13 @@ static void test_apx_compiler_pack_dynamic_array_of_records(CuTest* tc) APX_VM_ARRAY_FLAG | APX_VM_OPCODE_PACK | (APX_VM_VARIANT_RECORD << APX_VM_INST_VARIANT_SHIFT), APX_VM_DYN_ARRAY_FLAG | APX_VM_OPCODE_DATA_SIZE | (APX_VM_VARIANT_ARRAY_SIZE_U8), array_length, - APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_FIRST_FIELD_FLAG |APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'I', 'd','\0', APX_VM_OPCODE_PACK | (APX_VM_VARIANT_UINT16 << APX_VM_INST_VARIANT_SHIFT), - APX_VM_LAST_FIELD_FLAG | APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'V', 'a', 'l', 'u', 'e', '\0', APX_VM_OPCODE_PACK | (APX_VM_VARIANT_UINT8 << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_END << APX_VM_INST_VARIANT_SHIFT), APX_VM_OPCODE_FLOW_CTRL | (APX_VM_VARIANT_ARRAY_NEXT << APX_VM_INST_VARIANT_SHIFT), }; @@ -1367,14 +1371,15 @@ static void test_apx_compiler_pack_record_DYNU8_U16(CuTest* tc) uint8_t const expected[] = { APX_VM_HEADER_FLAG_DYNAMIC_DATA | APX_VM_HEADER_PROG_TYPE_PACK | APX_VM_VARIANT_UINT8, UINT8_SIZE + UINT8_SIZE * array_length + UINT16_SIZE, APX_VM_OPCODE_PACK | (APX_VM_VARIANT_RECORD << APX_VM_INST_VARIANT_SHIFT), - APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_FIRST_FIELD_FLAG | APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'F', 'i', 'r', 's', 't', '\0', APX_VM_ARRAY_FLAG | APX_VM_OPCODE_PACK | (APX_VM_VARIANT_UINT8 << APX_VM_INST_VARIANT_SHIFT), APX_VM_DYN_ARRAY_FLAG | APX_VM_OPCODE_DATA_SIZE | (APX_VM_VARIANT_ARRAY_SIZE_U8), array_length, - APX_VM_LAST_FIELD_FLAG | APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'S', 'e', 'c', 'o', 'n', 'd', '\0', APX_VM_OPCODE_PACK | (APX_VM_VARIANT_UINT16 << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_END << APX_VM_INST_VARIANT_SHIFT), }; apx_istream_create(&stream); diff --git a/apx/test/testsuite_compiler_unpack.c b/apx/test/testsuite_compiler_unpack.c index b715e56..439ade8 100644 --- a/apx/test/testsuite_compiler_unpack.c +++ b/apx/test/testsuite_compiler_unpack.c @@ -1424,12 +1424,13 @@ static void test_apx_compiler_unpack_record_u8_u16(CuTest* tc) uint8_t const expected[] = { APX_VM_HEADER_PROG_TYPE_UNPACK | APX_VM_VARIANT_UINT8, UINT8_SIZE + UINT16_SIZE, APX_VM_OPCODE_UNPACK | (APX_VM_VARIANT_RECORD << APX_VM_INST_VARIANT_SHIFT), - APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_FIRST_FIELD_FLAG | APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'F', 'i', 'r', 's', 't', '\0', APX_VM_OPCODE_UNPACK | (APX_VM_VARIANT_UINT8 << APX_VM_INST_VARIANT_SHIFT), - APX_VM_LAST_FIELD_FLAG | APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'S', 'e', 'c', 'o', 'n', 'd', '\0', APX_VM_OPCODE_UNPACK | (APX_VM_VARIANT_UINT16 << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_END << APX_VM_INST_VARIANT_SHIFT), }; apx_istream_create(&stream); @@ -1512,18 +1513,19 @@ static void test_apx_compiler_unpack_record_reference_with_child_references(CuTe uint8_t const expected[] = { APX_VM_HEADER_PROG_TYPE_UNPACK | APX_VM_VARIANT_UINT8, UINT8_SIZE + UINT8_SIZE, APX_VM_OPCODE_UNPACK | (APX_VM_VARIANT_RECORD << APX_VM_INST_VARIANT_SHIFT), - APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_FIRST_FIELD_FLAG | APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'F', 'i', 'r', 's', 't', '\0', APX_VM_OPCODE_UNPACK | (APX_VM_VARIANT_UINT8 << APX_VM_INST_VARIANT_SHIFT), APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_LIMIT_CHECK_U8 << APX_VM_INST_VARIANT_SHIFT), 0u, 3u, - APX_VM_LAST_FIELD_FLAG | APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'S', 'e', 'c', 'o', 'n', 'd', '\0', APX_VM_OPCODE_UNPACK | (APX_VM_VARIANT_UINT8 << APX_VM_INST_VARIANT_SHIFT), APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_LIMIT_CHECK_U8 << APX_VM_INST_VARIANT_SHIFT), 0u, 7u, + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_END << APX_VM_INST_VARIANT_SHIFT), }; apx_istream_create(&stream); @@ -1565,12 +1567,13 @@ static void test_apx_compiler_unpack_array_of_records(CuTest* tc) APX_VM_ARRAY_FLAG | APX_VM_OPCODE_UNPACK | (APX_VM_VARIANT_RECORD << APX_VM_INST_VARIANT_SHIFT), APX_VM_OPCODE_DATA_SIZE | (APX_VM_VARIANT_ARRAY_SIZE_U8), array_length, - APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_FIRST_FIELD_FLAG | APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'I', 'd','\0', APX_VM_OPCODE_UNPACK | (APX_VM_VARIANT_UINT16 << APX_VM_INST_VARIANT_SHIFT), - APX_VM_LAST_FIELD_FLAG | APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'V', 'a', 'l', 'u', 'e', '\0', APX_VM_OPCODE_UNPACK | (APX_VM_VARIANT_UINT8 << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_END << APX_VM_INST_VARIANT_SHIFT), APX_VM_OPCODE_FLOW_CTRL | (APX_VM_VARIANT_ARRAY_NEXT << APX_VM_INST_VARIANT_SHIFT), }; @@ -1613,12 +1616,13 @@ static void test_apx_compiler_unpack_dynamic_array_of_records(CuTest* tc) APX_VM_ARRAY_FLAG | APX_VM_OPCODE_UNPACK | (APX_VM_VARIANT_RECORD << APX_VM_INST_VARIANT_SHIFT), APX_VM_DYN_ARRAY_FLAG | APX_VM_OPCODE_DATA_SIZE | (APX_VM_VARIANT_ARRAY_SIZE_U8), array_length, - APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_FIRST_FIELD_FLAG | APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'I', 'd','\0', APX_VM_OPCODE_UNPACK | (APX_VM_VARIANT_UINT16 << APX_VM_INST_VARIANT_SHIFT), - APX_VM_LAST_FIELD_FLAG | APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'V', 'a', 'l', 'u', 'e', '\0', APX_VM_OPCODE_UNPACK | (APX_VM_VARIANT_UINT8 << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_END << APX_VM_INST_VARIANT_SHIFT), APX_VM_OPCODE_FLOW_CTRL | (APX_VM_VARIANT_ARRAY_NEXT << APX_VM_INST_VARIANT_SHIFT), }; @@ -1659,14 +1663,15 @@ static void test_apx_compiler_unpack_record_DYNU8_U16(CuTest* tc) uint8_t const expected[] = { APX_VM_HEADER_FLAG_DYNAMIC_DATA | APX_VM_HEADER_PROG_TYPE_UNPACK | APX_VM_VARIANT_UINT8, UINT8_SIZE + UINT8_SIZE * array_length + UINT16_SIZE, APX_VM_OPCODE_UNPACK | (APX_VM_VARIANT_RECORD << APX_VM_INST_VARIANT_SHIFT), - APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_FIRST_FIELD_FLAG |APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'F', 'i', 'r', 's', 't', '\0', APX_VM_ARRAY_FLAG | APX_VM_OPCODE_UNPACK | (APX_VM_VARIANT_UINT8 << APX_VM_INST_VARIANT_SHIFT), APX_VM_DYN_ARRAY_FLAG | APX_VM_OPCODE_DATA_SIZE | (APX_VM_VARIANT_ARRAY_SIZE_U8), array_length, - APX_VM_LAST_FIELD_FLAG | APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_SELECT << APX_VM_INST_VARIANT_SHIFT), 'S', 'e', 'c', 'o', 'n', 'd', '\0', APX_VM_OPCODE_UNPACK | (APX_VM_VARIANT_UINT16 << APX_VM_INST_VARIANT_SHIFT), + APX_VM_OPCODE_DATA_CTRL | (APX_VM_VARIANT_RECORD_END << APX_VM_INST_VARIANT_SHIFT), }; apx_istream_create(&stream); diff --git a/apx/test/testsuite_vm_deserializer.c b/apx/test/testsuite_vm_deserializer.c index b565dd4..e33a97f 100644 --- a/apx/test/testsuite_vm_deserializer.c +++ b/apx/test/testsuite_vm_deserializer.c @@ -119,7 +119,7 @@ CuSuite* testSuite_apx_vm_deserializer(void) SUITE_ADD_TEST(suite, test_unpack_record_inside_record_u8_u16__u16_u32); SUITE_ADD_TEST(suite, test_unpack_array_of_record_u16_u8); SUITE_ADD_TEST(suite, test_unpack_uint8_queued_element); - SUITE_ADD_TEST(suite, test_unpack_uint8_multiple_queued_elements); + SUITE_ADD_TEST(suite, test_unpack_uint8_multiple_queued_elements); SUITE_ADD_TEST(suite, test_range_check_uint8_scalar); SUITE_ADD_TEST(suite, test_range_check_uint8_with_out_of_range_value); SUITE_ADD_TEST(suite, test_range_check_uint8_array); @@ -1052,10 +1052,11 @@ static void test_unpack_record_u8_u8(CuTest* tc) apx_vm_deserializer_create(&dsr); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_set_read_buffer(&dsr, &buf[0], sizeof(buf))); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_record(&dsr, array_length, dynamic_size_type)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "First", false)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "First", true)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_uint8(&dsr, array_length, dynamic_size_type)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Second", true)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Second", false)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_uint8(&dsr, array_length, dynamic_size_type)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_end(&dsr)); CuAssertUIntEquals(tc, (unsigned int)sizeof(buf), (unsigned int)apx_vm_deserializer_bytes_read(&dsr)); CuAssertUIntEquals(tc, DTL_DV_HASH, apx_vm_deserializer_value_type(&dsr)); hv = apx_vm_deserializer_take_hv(&dsr); @@ -1088,10 +1089,11 @@ static void test_unpack_record_u8array_u16(CuTest* tc) apx_vm_deserializer_create(&dsr); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_set_read_buffer(&dsr, &buf[0], sizeof(buf))); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_record(&dsr, outer_array_length, dynamic_size_type)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "First", false)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "First", true)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_uint8(&dsr, inner_array_length1, dynamic_size_type)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Second", true)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Second", false)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_uint16(&dsr, inner_array_length2, dynamic_size_type)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_end(&dsr)); CuAssertUIntEquals(tc, (unsigned int)sizeof(buf), (unsigned int)apx_vm_deserializer_bytes_read(&dsr)); CuAssertUIntEquals(tc, DTL_DV_HASH, apx_vm_deserializer_value_type(&dsr)); hv = apx_vm_deserializer_take_hv(&dsr); @@ -1136,12 +1138,13 @@ static void test_unpack_record_string_string_bool(CuTest* tc) apx_vm_deserializer_create(&dsr); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_set_read_buffer(&dsr, &buf[0], sizeof(buf))); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_record(&dsr, array_length, dynamic_size_type)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "First", false)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "First", true)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_char(&dsr, str_max_length1, dynamic_size_type)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Second", false)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_char(&dsr, str_max_length2, dynamic_size_type)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Third", true)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Third", false)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_bool(&dsr, array_length, dynamic_size_type)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_end(&dsr)); CuAssertUIntEquals(tc, (unsigned int)sizeof(buf), (unsigned int)apx_vm_deserializer_bytes_read(&dsr)); CuAssertUIntEquals(tc, DTL_DV_HASH, apx_vm_deserializer_value_type(&dsr)); hv = apx_vm_deserializer_take_hv(&dsr); @@ -1184,10 +1187,11 @@ static void test_unpack_record_dynstring_u32array(CuTest* tc) apx_vm_deserializer_create(&dsr); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_set_read_buffer(&dsr, &buf[0], sizeof(buf))); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_record(&dsr, 0u, record_dynamic_size_type)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "First", false)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "First", true)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_char(&dsr, max_string_length, str_dynamic_size_type)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Second", false)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_uint32(&dsr, u32_array_size, u32_array_size_type)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_end(&dsr)); CuAssertUIntEquals(tc, (unsigned int)sizeof(buf), (unsigned int)apx_vm_deserializer_bytes_read(&dsr)); CuAssertUIntEquals(tc, DTL_DV_HASH, apx_vm_deserializer_value_type(&dsr)); hv = apx_vm_deserializer_take_hv(&dsr); @@ -1227,10 +1231,11 @@ static void test_unpack_record_bool_dynstring(CuTest* tc) apx_vm_deserializer_create(&dsr); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_set_read_buffer(&dsr, &buf[0], sizeof(buf))); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_record(&dsr, 0u, record_size_type)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "First", false)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "First", true)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_bool(&dsr, 0u, first_field_size_type)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Second", false)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_char(&dsr, max_string_length, second_field_size_type)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_end(&dsr)); CuAssertUIntEquals(tc, (unsigned int)sizeof(buf), (unsigned int)apx_vm_deserializer_bytes_read(&dsr)); CuAssertUIntEquals(tc, DTL_DV_HASH, apx_vm_deserializer_value_type(&dsr)); hv = apx_vm_deserializer_take_hv(&dsr); @@ -1260,18 +1265,21 @@ static void test_unpack_record_inside_record_u8_u16__u16_u32(CuTest* tc) apx_vm_deserializer_create(&dsr); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_set_read_buffer(&dsr, &buf[0], sizeof(buf))); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_record(&dsr, 0u, APX_SIZE_TYPE_NONE)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "First", false)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "First", true)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_record(&dsr, 0u, APX_SIZE_TYPE_NONE)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Inner1", false)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Inner1", true)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_uint8(&dsr, 0u, APX_SIZE_TYPE_NONE)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Inner2", true)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Inner2", false)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_uint16(&dsr, 0u, APX_SIZE_TYPE_NONE)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_end(&dsr)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Second", false)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_record(&dsr, 0u, APX_SIZE_TYPE_NONE)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Inner3", false)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Inner3", true)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_uint16(&dsr, 0u, APX_SIZE_TYPE_NONE)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Inner4", true)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Inner4", false)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_uint32(&dsr, 0u, APX_SIZE_TYPE_NONE)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_end(&dsr)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_end(&dsr)); CuAssertUIntEquals(tc, (unsigned int)sizeof(buf), (unsigned int)apx_vm_deserializer_bytes_read(&dsr)); CuAssertUIntEquals(tc, DTL_DV_HASH, apx_vm_deserializer_value_type(&dsr)); hv = apx_vm_deserializer_take_hv(&dsr); @@ -1320,22 +1328,25 @@ static void test_unpack_array_of_record_u16_u8(CuTest* tc) apx_vm_deserializer_create(&dsr); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_set_read_buffer(&dsr, &buf[0], sizeof(buf))); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_record(&dsr, array_length, APX_SIZE_TYPE_NONE)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Id", false)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Id", true)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_uint16(&dsr, 0u, APX_SIZE_TYPE_NONE)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Value", true)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Value", false)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_uint8(&dsr, 0u, APX_SIZE_TYPE_NONE)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_end(&dsr)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_array_next(&dsr, &is_last)); CuAssertFalse(tc, is_last); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Id", false)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Id", true)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_uint16(&dsr, 0u, APX_SIZE_TYPE_NONE)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Value", true)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Value", false)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_uint8(&dsr, 0u, APX_SIZE_TYPE_NONE)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_end(&dsr)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_array_next(&dsr, &is_last)); CuAssertFalse(tc, is_last); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Id", false)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Id", true)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_uint16(&dsr, 0u, APX_SIZE_TYPE_NONE)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Value", true)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_select(&dsr, "Value", false)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_uint8(&dsr, 0u, APX_SIZE_TYPE_NONE)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_record_end(&dsr)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_array_next(&dsr, &is_last)); CuAssertTrue(tc, is_last); CuAssertUIntEquals(tc, (unsigned int)sizeof(buf), (unsigned int)apx_vm_deserializer_bytes_read(&dsr)); @@ -1549,9 +1560,9 @@ static void test_range_check_int8_array(CuTest* tc) apx_sizeType_t const dynamic_size_type = APX_SIZE_TYPE_NONE; apx_vm_deserializer_create(&dsr); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_set_read_buffer(&dsr, &buf[0], sizeof(buf))); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_int8(&dsr, array_length, dynamic_size_type)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_unpack_int8(&dsr, array_length, dynamic_size_type)); CuAssertUIntEquals(tc, (unsigned int)sizeof(buf), (unsigned int)apx_vm_deserializer_bytes_read(&dsr)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_check_value_range_int32(&dsr, -10, 10)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_deserializer_check_value_range_int32(&dsr, -10, 10)); apx_vm_deserializer_destroy(&dsr); } @@ -1591,7 +1602,7 @@ static void test_range_check_uint64_scalar(CuTest* tc) } static void test_range_check_int64_scalar(CuTest* tc) -{ +{ apx_vm_deserializer_t dsr; uint8_t buf[UINT64_SIZE] = { 0x18, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; //-1000 encoded as little endian uint32_t const array_length = 0u; diff --git a/apx/test/testsuite_vm_serializer.c b/apx/test/testsuite_vm_serializer.c index 1e465da..99524a0 100644 --- a/apx/test/testsuite_vm_serializer.c +++ b/apx/test/testsuite_vm_serializer.c @@ -1833,18 +1833,21 @@ static void test_pack_record_inside_record__uint8_uint16__uint16_uint32(CuTest* CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_set_write_buffer(&sr, &buf[0], sizeof(buf))); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_set_value_hv(&sr, hv)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_pack_record(&sr, array_length, dynamic_size_type)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "First", false)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "First", true)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_pack_record(&sr, array_length, dynamic_size_type)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Inner1", false)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Inner1", true)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_pack_uint8(&sr, array_length, dynamic_size_type)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Inner2", true)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Inner2", false)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_pack_uint16(&sr, array_length, dynamic_size_type)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Second", true)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_end(&sr)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Second", false)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_pack_record(&sr, array_length, dynamic_size_type)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Inner3", false)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Inner3", true)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_pack_uint16(&sr, array_length, dynamic_size_type)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Inner4", true)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Inner4", false)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_pack_uint32(&sr, array_length, dynamic_size_type)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_end(&sr)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_end(&sr)); CuAssertUIntEquals(tc, (unsigned int)sizeof(buf), (unsigned int)apx_vm_serializer_bytes_written(&sr)); CuAssertUIntEquals(tc, 0x12u, buf[0]); CuAssertUIntEquals(tc, 0x34u, buf[1]); @@ -1888,22 +1891,25 @@ static void test_pack_array_of_record_uint16_uint8(CuTest* tc) CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_set_write_buffer(&sr, &buf[0], sizeof(buf))); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_set_value_av(&sr, av)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_pack_record(&sr, array_length, dynamic_size_type)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Id", false)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Id", true)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_pack_uint16(&sr, child_array_length, dynamic_size_type)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Value", true)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Value", false)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_pack_uint8(&sr, child_array_length, dynamic_size_type)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_end(&sr)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_array_next(&sr, &is_last)); CuAssertFalse(tc, is_last); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Id", false)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Id", true)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_pack_uint16(&sr, child_array_length, dynamic_size_type)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Value", true)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Value", false)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_pack_uint8(&sr, child_array_length, dynamic_size_type)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_end(&sr)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_array_next(&sr, &is_last)); CuAssertFalse(tc, is_last); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Id", false)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Id", true)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_pack_uint16(&sr, child_array_length, dynamic_size_type)); - CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Value", true)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_select(&sr, "Value", false)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_pack_uint8(&sr, child_array_length, dynamic_size_type)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_record_end(&sr)); CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_serializer_array_next(&sr, &is_last)); CuAssertTrue(tc, is_last); CuAssertUIntEquals(tc, (unsigned int)sizeof(buf), (unsigned int)apx_vm_serializer_bytes_written(&sr)); diff --git a/apx/test/testsuite_vm_unpack.c b/apx/test/testsuite_vm_unpack.c index a895c14..6d5e4a4 100644 --- a/apx/test/testsuite_vm_unpack.c +++ b/apx/test/testsuite_vm_unpack.c @@ -39,6 +39,7 @@ static void test_apx_vm_unpack_char_string(CuTest* tc); static void test_apx_vm_unpack_char8_string(CuTest* tc); static void test_apx_vm_unpack_record_u16_u8(CuTest* tc); static void test_apx_vm_unpack_array_of_record_u16_u8(CuTest* tc); +static void test_apx_vm_unpack_record_element_with_range_check(CuTest* tc); ////////////////////////////////////////////////////////////////////////////// // PRIVATE VARIABLES @@ -70,6 +71,7 @@ CuSuite* testSuite_apx_vm_unpack(void) SUITE_ADD_TEST(suite, test_apx_vm_unpack_char8_string); SUITE_ADD_TEST(suite, test_apx_vm_unpack_record_u16_u8); SUITE_ADD_TEST(suite, test_apx_vm_unpack_array_of_record_u16_u8); + SUITE_ADD_TEST(suite, test_apx_vm_unpack_record_element_with_range_check); return suite; } @@ -1198,3 +1200,53 @@ static void test_apx_vm_unpack_array_of_record_u16_u8(CuTest* tc) apx_parser_destroy(&parser); apx_istream_destroy(&stream); } + +static void test_apx_vm_unpack_record_element_with_range_check(CuTest* tc) +{ + const char* apx_text = + "APX/1.3\n" + "N\"TestNode\"\n" + "R\"TestPort\"{\"First\"C(0,7)}"; + apx_parser_t parser; + apx_istream_t stream; + apx_node_t* node = NULL; + apx_port_t* port = NULL; + apx_compiler_t compiler; + apx_error_t error_code = APX_NO_ERROR; + apx_program_t* program; + apx_vm_t* vm = apx_vm_new(); + dtl_hv_t* hv = NULL; + dtl_sv_t* child_sv = NULL; + bool ok = false; + uint8_t buf[UINT8_SIZE] = {7u}; + apx_istream_create(&stream); + apx_parser_create(&parser, &stream); + CuAssertUIntEquals(tc, APX_NO_ERROR, apx_parser_parse_cstr(&parser, apx_text)); + node = apx_parser_take_last_node(&parser); + CuAssertPtrNotNull(tc, node); + port = apx_node_get_last_require_port(node); + CuAssertPtrNotNull(tc, port); + apx_compiler_create(&compiler); + program = apx_compiler_compile_port(&compiler, port, APX_UNPACK_PROGRAM, &error_code); + CuAssertPtrNotNull(tc, program); + CuAssertIntEquals(tc, APX_NO_ERROR, error_code); + + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_select_program(vm, program)); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_set_read_buffer(vm, buf, sizeof(buf))); + CuAssertIntEquals(tc, APX_NO_ERROR, apx_vm_unpack_value(vm, (dtl_dv_t**)&hv)); + CuAssertUIntEquals(tc, (unsigned int)sizeof(buf), (unsigned int)apx_vm_get_bytes_read(vm)); + CuAssertPtrNotNull(tc, hv); + CuAssertIntEquals(tc, DTL_DV_HASH, dtl_dv_type((dtl_dv_t*)hv)); + child_sv = (dtl_sv_t*)dtl_hv_get_cstr(hv, "First"); + CuAssertPtrNotNull(tc, child_sv); + CuAssertIntEquals(tc, DTL_SV_U32, dtl_sv_type(child_sv)); + CuAssertUIntEquals(tc, 7u, dtl_sv_to_u32(child_sv, &ok)); + dtl_dec_ref(hv); + + apx_vm_delete(vm); + APX_PROGRAM_DELETE(program); + apx_compiler_destroy(&compiler); + apx_node_delete(node); + apx_parser_destroy(&parser); + apx_istream_destroy(&stream); +} \ No newline at end of file From 1f03fff4b3b3321df441ec2e26ca52fe4c4b7d81 Mon Sep 17 00:00:00 2001 From: cogu Date: Wed, 6 May 2026 15:37:29 +0200 Subject: [PATCH 2/3] Fix GCC compiler warning --- app/apx_server/src/server_main.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/app/apx_server/src/server_main.c b/app/apx_server/src/server_main.c index 2245d03..4d0ade4 100644 --- a/app/apx_server/src/server_main.c +++ b/app/apx_server/src/server_main.c @@ -74,17 +74,18 @@ int main(int argc, char **argv) apx_error_t result; dtl_hv_t *server_config = (dtl_hv_t*) 0; - m_shutdownTimer = SHUTDOWN_TIMER_INIT; + m_shutdownTimer = SHUTDOWN_TIMER_INIT; m_runFlag = 1; - if (argc < 2u) + if ((argc < 2u) || (argv[1] == NULL)) { printUsage(argv[0]); return 0; } + const char* config_path = argv[1]; printf("APX Server %s\n\n", SW_VERSION_STR); - result = load_config_file(argv[1], &server_config); - printf("Loading %s: ", argv[1]); + result = load_config_file(config_path, &server_config); + printf("Loading %s: ", config_path); if (result != APX_NO_ERROR) { printf("Error %d\n", (int) result); From 1bcfd547d014f1ab65e627452694faba33056f05 Mon Sep 17 00:00:00 2001 From: cogu Date: Wed, 6 May 2026 15:42:34 +0200 Subject: [PATCH 3/3] Change version to 0.3.2 Add capability to set alpha/beta version number --- CMakeLists.txt | 12 ++++-------- cmake/apx_build_cfg.h.in | 2 +- 2 files changed, 5 insertions(+), 9 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 82f50f7..460963e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,7 +1,10 @@ cmake_minimum_required(VERSION 3.10) -project(apx LANGUAGES C VERSION 0.3.1) +project(apx LANGUAGES C VERSION 0.3.2) + +set(apx_ALPHA_BETA_VERSION "") + set(ADT_RBFH_ENABLE ON CACHE BOOL "This must always be enabled in c-apx" FORCE) @@ -10,7 +13,6 @@ include(adt/cmake/LeakCheck.cmake) include(adt/cmake/UnitTest.cmake) include(cmake/SetEnv.cmake) -option(apx_ALPHA_BUILD "Is this an alpha build?" OFF) option(BUILD_DEFAULT_SERVER "Build default APX server?" ON) option(APX_DEBUG "Enable debug-level printouts?" OFF) @@ -24,12 +26,6 @@ else() set(BUILD_SHARED_LIB_DEFAULT ON) endif() -if (apx_ALPHA_BUILD) - set (apx_ALPHA_BUILD_STR "a") -else() - set (apx_ALPHA_BUILD_STR "") -endif() - option(BUILD_SHARED_LIBS "Build ${PROJECT_NAME} as a shared library." ${BUILD_SHARED_LIB_DEFAULT}) if(BUILD_SHARED_LIBS) diff --git a/cmake/apx_build_cfg.h.in b/cmake/apx_build_cfg.h.in index 5176a5b..9eaf741 100644 --- a/cmake/apx_build_cfg.h.in +++ b/cmake/apx_build_cfg.h.in @@ -1,4 +1,4 @@ #ifndef APX_VERSION_H #define APX_VERSION_H - #define SW_VERSION_LITERAL "@apx_VERSION_MAJOR@.@apx_VERSION_MINOR@.@apx_VERSION_PATCH@" "@apx_ALPHA_BUILD_STR@" + #define SW_VERSION_LITERAL "@apx_VERSION_MAJOR@.@apx_VERSION_MINOR@.@apx_VERSION_PATCH@" "@apx_ALPHA_BETA_VERSION@" #endif \ No newline at end of file