first simple roundabout test for sized-enums work (known bugs left)

include/dl/dl_reflect.h

@@ -72,7 +72,17 @@ typedef struct dl_enum_info
 typedef struct dl_enum_value_info
 {
 	const char*  name;
-	unsigned int value;
+	union
+	{
+		int8_t   i8;
+		int16_t  i16;
+		int32_t  i32;
+		int64_t  i64;
+		uint8_t  u8;
+		uint16_t u16;
+		uint32_t u32;
+		uint64_t u64;
+	} value;
 } dl_enum_value_info_t;
 
 #ifdef __cplusplus

src/dl_reflect.cpp

@@ -152,7 +152,7 @@ dl_error_t DL_DLL_EXPORT dl_reflect_get_enum_values( dl_ctx_t dl_ctx, dl_typeid_
 	{
 		const dl_enum_value_desc* v = dl_get_enum_value( dl_ctx, e, value );
 		out_values[value].name  = dl_internal_enum_alias_name( dl_ctx, &dl_ctx->enum_alias_descs[v->main_alias]);
-		out_values[value].value = v->value;
+		out_values[value].value.u64 = v->value;
 	}
 
 	return DL_ERROR_OK;

src/dl_txt_pack.cpp

@@ -217,11 +217,23 @@ static void dl_txt_pack_eat_and_write_enum( dl_ctx_t dl_ctx, dl_txt_pack_ctx* pa
 	if( ename.str == 0x0 )
 		dl_txt_read_failed( dl_ctx, &packctx->read_ctx, DL_ERROR_MALFORMED_DATA, "expected string" );
 
-	uint32_t enum_value;
+	uint64_t enum_value;
 	if( !dl_internal_find_enum_value( dl_ctx, edesc, ename.str, (size_t)ename.len, &enum_value ) )
 		dl_txt_read_failed( dl_ctx, &packctx->read_ctx, DL_ERROR_TXT_INVALID_ENUM_VALUE, "the enum \"%s\" has no member named \"%.*s\"", dl_internal_enum_name( dl_ctx, edesc ), ename.len, ename.str );
 
-	dl_binary_writer_write_uint32( packctx->writer, enum_value );
+	switch(edesc->storage)
+	{
+		case DL_TYPE_STORAGE_ENUM_INT8:   dl_binary_writer_write_int8  ( packctx->writer, (int8_t)  enum_value ); break;
+		case DL_TYPE_STORAGE_ENUM_INT16:  dl_binary_writer_write_int16 ( packctx->writer, (int16_t) enum_value ); break;
+		case DL_TYPE_STORAGE_ENUM_INT32:  dl_binary_writer_write_int32 ( packctx->writer, (int32_t) enum_value ); break;
+		case DL_TYPE_STORAGE_ENUM_INT64:  dl_binary_writer_write_int64 ( packctx->writer, (int64_t) enum_value ); break;
+		case DL_TYPE_STORAGE_ENUM_UINT8:  dl_binary_writer_write_uint8 ( packctx->writer, (uint8_t) enum_value ); break;
+		case DL_TYPE_STORAGE_ENUM_UINT16: dl_binary_writer_write_uint16( packctx->writer, (uint16_t)enum_value ); break;
+		case DL_TYPE_STORAGE_ENUM_UINT32: dl_binary_writer_write_uint32( packctx->writer, (uint32_t)enum_value ); break;
+		case DL_TYPE_STORAGE_ENUM_UINT64: dl_binary_writer_write_uint64( packctx->writer, (uint64_t)enum_value ); break;
+		default:
+			DL_ASSERT(false);
+	}
 	packctx->read_ctx.iter = ename.str + ename.len + 1;
 }
 
@@ -602,7 +614,14 @@ static void dl_txt_pack_member( dl_ctx_t dl_ctx, dl_txt_pack_ctx* packctx, size_
 				case DL_TYPE_STORAGE_STR:    dl_txt_pack_eat_and_write_string( dl_ctx, packctx ); break;
 				case DL_TYPE_STORAGE_PTR:    dl_txt_pack_eat_and_write_ptr( dl_ctx, packctx, dl_internal_find_type( dl_ctx, member->type_id ), member_pos ); break;
 				case DL_TYPE_STORAGE_STRUCT: dl_txt_pack_eat_and_write_struct( dl_ctx, packctx, dl_internal_find_type( dl_ctx, member->type_id ) ); break;
+				case DL_TYPE_STORAGE_ENUM_INT8:
+				case DL_TYPE_STORAGE_ENUM_INT16:
+				case DL_TYPE_STORAGE_ENUM_INT32:
+				case DL_TYPE_STORAGE_ENUM_INT64:
+				case DL_TYPE_STORAGE_ENUM_UINT8:
+				case DL_TYPE_STORAGE_ENUM_UINT16:
 				case DL_TYPE_STORAGE_ENUM_UINT32:
+				case DL_TYPE_STORAGE_ENUM_UINT64:
 				{
 					dl_txt_eat_white( &packctx->read_ctx );
 					const dl_enum_desc* edesc = dl_internal_find_enum( dl_ctx, member->type_id );

src/dl_txt_unpack.cpp

@@ -126,7 +126,7 @@ static void dl_txt_unpack_fp64( dl_binary_writer* writer, double data )
 	dl_binary_writer_write( writer, buffer, (size_t)len );
 }
 
-static void dl_txt_unpack_enum( dl_ctx_t dl_ctx, dl_binary_writer* writer, const dl_enum_desc* e, uint32_t value )
+static void dl_txt_unpack_enum( dl_ctx_t dl_ctx, dl_binary_writer* writer, const dl_enum_desc* e, uint64_t value )
 {
 	for( unsigned int j = 0; j < e->value_count; ++j )
 	{
@@ -310,18 +310,64 @@ static void dl_txt_unpack_array( dl_ctx_t dl_ctx, dl_txt_unpack_ctx* unpack_ctx,
 			dl_txt_unpack_struct( dl_ctx, unpack_ctx, writer, type, array_data + (array_count - 1) * type->size[DL_PTR_SIZE_HOST] );
 			break;
 		}
-		case DL_TYPE_STORAGE_ENUM_UINT32:
+		case DL_TYPE_STORAGE_ENUM_INT8:
+		case DL_TYPE_STORAGE_ENUM_UINT8:
+		{
+			const dl_enum_desc* e = dl_internal_find_enum( dl_ctx, tid );
+			DL_ASSERT( e != 0x0, "handle this error!");
+
+			uint8_t* mem = (uint8_t*)array_data;
+			for( uint32_t i = 0; i < array_count - 1; ++i )
+			{
+				dl_txt_unpack_enum( dl_ctx, writer, e, (uint64_t)mem[i] );
+				dl_binary_writer_write( writer, ", ", 2 );
+
+			}
+			dl_txt_unpack_enum( dl_ctx, writer, e, mem[array_count - 1] );
+		}
+		break;
+		case DL_TYPE_STORAGE_ENUM_INT16:
+		case DL_TYPE_STORAGE_ENUM_UINT16:
 		{
 			const dl_enum_desc* e = dl_internal_find_enum( dl_ctx, tid );
+			DL_ASSERT( e != 0x0, "handle this error!");
 
-			if( e == 0x0 )
-				return; // TODO: handle this error!
+			uint16_t* mem = (uint16_t*)array_data;
+			for( uint32_t i = 0; i < array_count - 1; ++i )
+			{
+				dl_txt_unpack_enum( dl_ctx, writer, e, (uint64_t)mem[i] );
+				dl_binary_writer_write( writer, ", ", 2 );
 
+			}
+			dl_txt_unpack_enum( dl_ctx, writer, e, mem[array_count - 1] );
+		}
+		break;
+		case DL_TYPE_STORAGE_ENUM_INT32:
+		case DL_TYPE_STORAGE_ENUM_UINT32:
+		{
+			const dl_enum_desc* e = dl_internal_find_enum( dl_ctx, tid );
+			DL_ASSERT( e != 0x0, "handle this error!");
 
 			uint32_t* mem = (uint32_t*)array_data;
 			for( uint32_t i = 0; i < array_count - 1; ++i )
 			{
-				dl_txt_unpack_enum( dl_ctx, writer, e, mem[i] );
+				dl_txt_unpack_enum( dl_ctx, writer, e, (uint64_t)mem[i] );
+				dl_binary_writer_write( writer, ", ", 2 );
+
+			}
+			dl_txt_unpack_enum( dl_ctx, writer, e, mem[array_count - 1] );
+		}
+		break;
+		case DL_TYPE_STORAGE_ENUM_INT64:
+		case DL_TYPE_STORAGE_ENUM_UINT64:
+		{
+			const dl_enum_desc* e = dl_internal_find_enum( dl_ctx, tid );
+			DL_ASSERT( e != 0x0, "handle this error!");
+
+			uint64_t* mem = (uint64_t*)array_data;
+			for( uint32_t i = 0; i < array_count - 1; ++i )
+			{
+				dl_txt_unpack_enum( dl_ctx, writer, e, (uint64_t)mem[i] );
 				dl_binary_writer_write( writer, ", ", 2 );
 
 			}
@@ -356,15 +402,14 @@ static void dl_txt_unpack_member( dl_ctx_t dl_ctx, dl_txt_unpack_ctx* unpack_ctx
 				case DL_TYPE_STORAGE_UINT64:      dl_txt_unpack_uint64( writer, *(uint64_t*)member_data ); break;
 				case DL_TYPE_STORAGE_FP32:        dl_txt_unpack_fp32  ( writer, *(float*)member_data ); break;
 				case DL_TYPE_STORAGE_FP64:        dl_txt_unpack_fp64  ( writer, *(double*)member_data ); break;
-				case DL_TYPE_STORAGE_ENUM_UINT32: 
-				{
-					const dl_enum_desc* e = dl_internal_find_enum( dl_ctx, member->type_id );
-
-					if( e == 0x0 )
-						return; // TODO: handle this error!
-
-					dl_txt_unpack_enum  ( dl_ctx, writer, e, *(uint32_t*)member_data ); break;
-				}
+				case DL_TYPE_STORAGE_ENUM_INT8:
+				case DL_TYPE_STORAGE_ENUM_UINT8:  dl_txt_unpack_enum  ( dl_ctx, writer, dl_internal_find_enum( dl_ctx, member->type_id ), (uint64_t)*(uint8_t*)  member_data ); break;
+				case DL_TYPE_STORAGE_ENUM_INT16:
+				case DL_TYPE_STORAGE_ENUM_UINT16: dl_txt_unpack_enum  ( dl_ctx, writer, dl_internal_find_enum( dl_ctx, member->type_id ), (uint64_t)*(uint16_t*) member_data ); break;
+				case DL_TYPE_STORAGE_ENUM_INT32:
+				case DL_TYPE_STORAGE_ENUM_UINT32: dl_txt_unpack_enum  ( dl_ctx, writer, dl_internal_find_enum( dl_ctx, member->type_id ), (uint64_t)*(uint32_t*) member_data ); break;
+				case DL_TYPE_STORAGE_ENUM_INT64:
+				case DL_TYPE_STORAGE_ENUM_UINT64: dl_txt_unpack_enum  ( dl_ctx, writer, dl_internal_find_enum( dl_ctx, member->type_id ), (uint64_t)*(uint64_t*) member_data ); break;
 				case DL_TYPE_STORAGE_STR:         dl_txt_unpack_write_string_or_null( writer, unpack_ctx, *(uintptr_t*)member_data ); break;
 				case DL_TYPE_STORAGE_PTR:
 				{

src/dl_typelib_read_txt.cpp

@@ -284,7 +284,7 @@ static void dl_load_txt_fixup_bitfield_members( dl_ctx_t ctx, dl_type_desc* type
 	}
 }
 
-static inline bool dl_internal_find_enum_value_from_name( dl_ctx_t ctx, const char* name, size_t name_len, uint32_t* value )
+static inline bool dl_internal_find_enum_value_from_name( dl_ctx_t ctx, const char* name, size_t name_len, uint64_t* value )
 {
 	for( unsigned int i = 0; i < ctx->enum_alias_count; ++i )
 	{
@@ -350,15 +350,15 @@ static void dl_load_txt_calc_type_size_and_align( dl_ctx_t ctx, dl_txt_read_ctx*
 							enum_value_name_len = member->alignment[0];
 						}
 
-						uint32_t val;
+						uint64_t val;
 						if( !dl_internal_find_enum_value_from_name( ctx, enum_value_name, (size_t)enum_value_name_len, &val ) )
 							dl_txt_read_failed( ctx, read_state, DL_ERROR_TXT_INVALID_ENUM_VALUE, "%s.%s is an inline array with size %.*s, but that enum value does not exist.",
 												dl_internal_type_name( ctx, type ),
 												dl_internal_member_name( ctx, member ),
 												(int)enum_value_name_len,
 												enum_value_name );
 
-						member->set_inline_array_cnt( val );
+						member->set_inline_array_cnt( (uint32_t)val );
 					}
 				}
 

src/dl_typelib_write_c_header.cpp

@@ -133,9 +133,9 @@ static void dl_context_write_c_header_enums( dl_binary_writer* writer, dl_ctx_t
 		dl_enum_value_info_t* values = (dl_enum_value_info_t*)malloc( enum_info.value_count * sizeof( dl_enum_value_info_t ) );
 		dl_reflect_get_enum_values( ctx, tids[enum_index], values, enum_info.value_count );
 
-		dl_binary_writer_write_string_fmt( writer, "    %s = %u", values[0].name, values[0].value);
+		dl_binary_writer_write_string_fmt( writer, "    %s = %u", values[0].name, values[0].value.u32); // TODO: fix me!
 		for( unsigned int j = 1; j < enum_info.value_count; ++j )
-			dl_binary_writer_write_string_fmt( writer, ",\n    %s = %u", values[j].name, values[j].value);
+			dl_binary_writer_write_string_fmt( writer, ",\n    %s = %u", values[j].name, values[j].value.u32); // TODO: fix me!
 
 		free( values );
 		dl_binary_writer_write_string_fmt( writer, "\n};\n\n" );

src/dl_types.h

@@ -215,7 +215,7 @@ struct dl_type_desc
 struct dl_enum_value_desc
 {
 	uint32_t main_alias;
-	uint32_t value;
+	uint64_t value;
 };
 
 struct dl_enum_desc
@@ -432,7 +432,7 @@ static inline unsigned int dl_internal_find_member( dl_ctx_t ctx, const dl_type_
 	return type->member_count + 1;
 }
 
-static inline bool dl_internal_find_enum_value( dl_ctx_t ctx, const dl_enum_desc* e, const char* name, size_t name_len, uint32_t* value )
+static inline bool dl_internal_find_enum_value( dl_ctx_t ctx, const dl_enum_desc* e, const char* name, size_t name_len, uint64_t* value )
 {
 	for( unsigned int j = 0; j < e->alias_count; ++j )
 	{

tests/dl_tests_base.cpp

@@ -18,7 +18,7 @@ void pack_text_test::do_it( dl_ctx_t       dl_ctx,       dl_typeid_t type,
 	EXPECT_DL_ERR_OK( dl_txt_unpack( dl_ctx, type, store_buffer, store_size, text_buffer, text_size, 0x0 ) );
 	EXPECT_EQ( (unsigned char)0xFE, (unsigned char)text_buffer[text_size] ); // no overwrite on the generated text plox!
 
-//	printf("%s\n", text_buffer);
+	// printf("%s\n", text_buffer);
 
 	// pack txt to binary
 	EXPECT_DL_ERR_OK( dl_txt_pack_calc_size( dl_ctx, text_buffer, out_size ) );

tests/dl_tests_enum.cpp

@@ -22,27 +22,27 @@ static_assert(DL_ALIGNOF(enum_uint16) == DL_ALIGNOF(uint16_t), "alignment of enu
 static_assert(DL_ALIGNOF(enum_uint32) == DL_ALIGNOF(uint32_t), "alignment of enum is incorrect");
 static_assert(DL_ALIGNOF(enum_uint64) == DL_ALIGNOF(uint64_t), "alignment of enum is incorrect");
 
-//TYPED_TEST(DLBase, sized_enums_simple)
-//{
-//    sized_enums original;
-//    original.e_int8   = int8_1;
-//	original.e_int16  = int16_1;
-//	original.e_int32  = int32_1;
-//	original.e_int64  = int64_1;
-//	original.e_uint8  = uint8_1;
-//	original.e_uint16 = uint16_1;
-//	original.e_uint32 = uint32_1;
-//	original.e_uint64 = uint64_1;
-//
-//    sized_enums loaded;
-//    this->do_the_round_about( sized_enums::TYPE_ID, &original, &loaded, sizeof(loaded) );
-//
-//    EXPECT_EQ(int8_1,   original.e_int8);
-//    EXPECT_EQ(int16_1,  original.e_int16);
-//    EXPECT_EQ(int32_1,  original.e_int32);
-//    EXPECT_EQ(int64_1,  original.e_int64);
-//    EXPECT_EQ(uint8_1,  original.e_uint8);
-//    EXPECT_EQ(uint16_1, original.e_uint16);
-//    EXPECT_EQ(uint32_1, original.e_uint32);
-//    EXPECT_EQ(uint64_1, original.e_uint64);
-//};
+TYPED_TEST(DLBase, sized_enums_simple)
+{
+    sized_enums original;
+    original.e_int8   = int8_1;
+	original.e_int16  = int16_1;
+	original.e_int32  = int32_1;
+	original.e_int64  = int64_1;
+	original.e_uint8  = uint8_1;
+	original.e_uint16 = uint16_1;
+	original.e_uint32 = uint32_1;
+	original.e_uint64 = uint64_1;
+
+    sized_enums loaded;
+    this->do_the_round_about( sized_enums::TYPE_ID, &original, &loaded, sizeof(loaded) );
+
+    EXPECT_EQ(int8_1,   original.e_int8);
+    EXPECT_EQ(int16_1,  original.e_int16);
+    EXPECT_EQ(int32_1,  original.e_int32);
+    EXPECT_EQ(int64_1,  original.e_int64);
+    EXPECT_EQ(uint8_1,  original.e_uint8);
+    EXPECT_EQ(uint16_1, original.e_uint16);
+    EXPECT_EQ(uint32_1, original.e_uint32);
+    EXPECT_EQ(uint64_1, original.e_uint64);
+};

tool/dl_tlc/dltlc.cpp

@@ -297,7 +297,7 @@ static void show_tl_info( dl_ctx_t ctx )
 		dl_reflect_get_enum_values( ctx, enum_->tid, values, enum_->value_count );
 
 		for( unsigned int j = 0; j < enum_->value_count; ++j )
-			printf("    %s = %u\n", values[j].name, values[j].value);
+			printf("    %s = %u\n", values[j].name, values[j].value.u32); // TODO: fix me.
 
 		free( values );
 	}