dl_error_t dl_instance_store( dl_ctx_t dl_ctx, dl_typeid_t type_id, void* instance, unsigned char* out_buffer, size_t out_buffer_size, size_t* produced_bytes ) { if( out_buffer_size > 0 && out_buffer_size <= sizeof(SDLDataHeader) ) return DL_ERROR_BUFFER_TO_SMALL; const SDLType* type = dl_internal_find_type( dl_ctx, type_id ); if( type == 0x0 ) return DL_ERROR_TYPE_NOT_FOUND; // write header SDLDataHeader header; header.id = DL_INSTANCE_ID; header.version = DL_INSTANCE_VERSION; header.root_instance_type = type_id; header.instance_size = 0; header.is_64_bit_ptr = sizeof(void*) == 8 ? 1 : 0; header.pad[0] = header.pad[1] = header.pad[2] = 0; unsigned char* store_ctx_buffer = 0x0; size_t store_ctx_buffer_size = 0; bool store_ctx_is_dummy = out_buffer_size == 0; if( out_buffer_size > 0 ) { memcpy(out_buffer, &header, sizeof(SDLDataHeader)); store_ctx_buffer = out_buffer + sizeof(SDLDataHeader); store_ctx_buffer_size = out_buffer_size - sizeof(SDLDataHeader); } CDLBinStoreContext store_context( store_ctx_buffer, store_ctx_buffer_size, store_ctx_is_dummy ); dl_binary_writer_reserve( &store_context.writer, type->size[DL_PTR_SIZE_HOST] ); store_context.AddWrittenPtr(instance, 0); // if pointer refere to root-node, it can be found at offset 0 dl_error_t err = dl_internal_instance_store( dl_ctx, type, (uint8*)instance, &store_context ); // write instance size! SDLDataHeader* out_header = (SDLDataHeader*)out_buffer; dl_binary_writer_seek_end( &store_context.writer ); if( out_buffer ) out_header->instance_size = (uint32)dl_binary_writer_tell( &store_context.writer ); if( produced_bytes ) *produced_bytes = (uint32)dl_binary_writer_tell( &store_context.writer ) + sizeof(SDLDataHeader); if( out_buffer_size > 0 && out_header->instance_size > out_buffer_size ) return DL_ERROR_BUFFER_TO_SMALL; return err; }
static dl_error_t dl_internal_convert_write_struct( dl_ctx_t dl_ctx, const uint8* data, const SDLType* type, SConvertContext& conv_ctx, dl_binary_writer* writer ) { dl_binary_writer_align( writer, type->alignment[conv_ctx.m_TargetPtrSize] ); pint Pos = dl_binary_writer_tell( writer ); dl_binary_writer_reserve( writer, type->size[conv_ctx.m_TargetPtrSize] ); for(uint32 iMember = 0; iMember < type->member_count; ++iMember) { const SDLMember& Member = type->members[iMember]; const uint8* pMemberData = data + Member.offset[conv_ctx.m_SourcePtrSize]; dl_binary_writer_align( writer, Member.alignment[conv_ctx.m_TargetPtrSize] ); dl_type_t AtomType = Member.AtomType(); dl_type_t StorageType = Member.StorageType(); switch(AtomType) { case DL_TYPE_ATOM_POD: { switch (StorageType) { case DL_TYPE_STORAGE_STRUCT: { const SDLType* pSubType = dl_internal_find_type(dl_ctx, Member.type_id); if(pSubType == 0x0) return DL_ERROR_TYPE_NOT_FOUND; dl_internal_convert_write_struct( dl_ctx, pMemberData, pSubType, conv_ctx, writer ); } break; case DL_TYPE_STORAGE_STR: { pint Offset = DLInternalReadPtrData(pMemberData, conv_ctx.m_SourceEndian, conv_ctx.m_SourcePtrSize); conv_ctx.m_lPatchOffset.Add( SConvertContext::PatchPos( dl_binary_writer_tell( writer ), Offset ) ); dl_binary_writer_write_ptr( writer, 0x0 ); } break; case DL_TYPE_STORAGE_PTR: { pint Offset = DLInternalReadPtrData(pMemberData, conv_ctx.m_SourceEndian, conv_ctx.m_SourcePtrSize); if (Offset != DL_NULL_PTR_OFFSET[conv_ctx.m_SourcePtrSize]) conv_ctx.m_lPatchOffset.Add(SConvertContext::PatchPos( dl_binary_writer_tell( writer ), Offset ) ); dl_binary_writer_write_ptr( writer, pint(-1) ); } break; default: DL_ASSERT(Member.IsSimplePod() || StorageType == DL_TYPE_STORAGE_ENUM); dl_binary_writer_write_swap( writer, pMemberData, Member.size[conv_ctx.m_SourcePtrSize] ); break; } } break; case DL_TYPE_ATOM_INLINE_ARRAY: { switch(StorageType) { case DL_TYPE_STORAGE_STRUCT: { const SDLType* pSubType = dl_internal_find_type(dl_ctx, Member.type_id); if(pSubType == 0x0) return DL_ERROR_TYPE_NOT_FOUND; pint MemberSize = Member.size[conv_ctx.m_SourcePtrSize]; pint SubtypeSize = pSubType->size[conv_ctx.m_SourcePtrSize]; for (pint ElemOffset = 0; ElemOffset < MemberSize; ElemOffset += SubtypeSize) dl_internal_convert_write_struct( dl_ctx, pMemberData + ElemOffset, pSubType, conv_ctx, writer ); } break; case DL_TYPE_STORAGE_STR: { pint PtrSizeSource = dl_internal_ptr_size(conv_ctx.m_SourcePtrSize); pint PtrSizeTarget = dl_internal_ptr_size(conv_ctx.m_TargetPtrSize); uint32 Count = Member.size[conv_ctx.m_SourcePtrSize] / (uint32)PtrSizeSource; pint Pos = dl_binary_writer_tell( writer ); for (pint iElem = 0; iElem < Count; ++iElem) { pint OldOffset = DLInternalReadPtrData(pMemberData + (iElem * PtrSizeSource), conv_ctx.m_SourceEndian, conv_ctx.m_SourcePtrSize); conv_ctx.m_lPatchOffset.Add(SConvertContext::PatchPos(Pos + (iElem * PtrSizeTarget), OldOffset)); } dl_binary_writer_write_zero( writer, Member.size[conv_ctx.m_TargetPtrSize] ); } break; default: { DL_ASSERT(Member.IsSimplePod() || StorageType == DL_TYPE_STORAGE_ENUM); pint PodSize = DLPodSize(Member.type); uint32 ArraySize = Member.size[conv_ctx.m_SourcePtrSize]; switch(PodSize) { case 1: dl_binary_writer_write_array( writer, pMemberData, ArraySize / sizeof( uint8), sizeof( uint8) ); break; case 2: dl_binary_writer_write_array( writer, pMemberData, ArraySize / sizeof(uint16), sizeof(uint16) ); break; case 4: dl_binary_writer_write_array( writer, pMemberData, ArraySize / sizeof(uint32), sizeof(uint32) ); break; case 8: dl_binary_writer_write_array( writer, pMemberData, ArraySize / sizeof(uint64), sizeof(uint64) ); break; default: DL_ASSERT(false && "Not supported pod-size!"); } } break; } } break; case DL_TYPE_ATOM_ARRAY: { pint Offset = 0; uint32 Count = 0; dl_internal_read_array_data( pMemberData, &Offset, &Count, conv_ctx.m_SourceEndian, conv_ctx.m_SourcePtrSize ); if(Offset != DL_NULL_PTR_OFFSET[conv_ctx.m_SourcePtrSize]) conv_ctx.m_lPatchOffset.Add(SConvertContext::PatchPos( dl_binary_writer_tell( writer ), Offset) ); else Offset = DL_NULL_PTR_OFFSET[conv_ctx.m_TargetPtrSize]; dl_binary_writer_write_ptr( writer, Offset ); dl_binary_writer_write_4byte( writer, pMemberData + dl_internal_ptr_size( conv_ctx.m_SourcePtrSize ) ); if( conv_ctx.m_TargetPtrSize == DL_PTR_SIZE_64BIT ) dl_binary_writer_write_zero( writer, 4 ); } break; case DL_TYPE_ATOM_BITFIELD: { uint32 j = iMember; do { j++; } while(j < type->member_count && type->members[j].AtomType() == DL_TYPE_ATOM_BITFIELD); if(conv_ctx.m_SourceEndian != conv_ctx.m_TargetEndian) { uint32 nBFMembers = j - iMember; switch(Member.size[conv_ctx.m_SourcePtrSize]) { case 1: { uint8 val = dl_convert_bit_field_format_uint8( *(uint8*)pMemberData, &Member, nBFMembers, &conv_ctx ); dl_binary_writer_write_1byte( writer, &val ); } break; case 2: { uint16 val = dl_convert_bit_field_format_uint16( *(uint16*)pMemberData, &Member, nBFMembers, &conv_ctx ); dl_binary_writer_write_2byte( writer, &val ); } break; case 4: { uint32 val = dl_convert_bit_field_format_uint32( *(uint32*)pMemberData, &Member, nBFMembers, &conv_ctx ); dl_binary_writer_write_4byte( writer, &val ); } break; case 8: { uint64 val = dl_convert_bit_field_format_uint64( *(uint64*)pMemberData, &Member, nBFMembers, &conv_ctx ); dl_binary_writer_write_8byte( writer, &val ); } break; default: DL_ASSERT(false && "Not supported pod-size or bitfield-size!"); } } else dl_binary_writer_write( writer, pMemberData, Member.size[conv_ctx.m_SourcePtrSize] ); iMember = j - 1; } break; default: DL_ASSERT(false && "Invalid ATOM-type!"); } } // we need to write our entire size with zeroes. Our entire size might be less than the sum of teh members. pint PosDiff = dl_binary_writer_tell( writer ) - Pos; if(PosDiff < type->size[conv_ctx.m_TargetPtrSize]) dl_binary_writer_write_zero( writer, type->size[conv_ctx.m_TargetPtrSize] - PosDiff ); DL_ASSERT( dl_binary_writer_tell( writer ) - Pos == type->size[conv_ctx.m_TargetPtrSize] ); return DL_ERROR_OK; }
static dl_error_t dl_internal_store_member( dl_ctx_t dl_ctx, const SDLMember* member, uint8* instance, CDLBinStoreContext* store_ctx ) { dl_type_t atom_type = dl_type_t(member->type & DL_TYPE_ATOM_MASK); dl_type_t storage_type = dl_type_t(member->type & DL_TYPE_STORAGE_MASK); switch ( atom_type ) { case DL_TYPE_ATOM_POD: { switch( storage_type ) { case DL_TYPE_STORAGE_STRUCT: { const SDLType* sub_type = dl_internal_find_type( dl_ctx, member->type_id ); if( sub_type == 0x0 ) { dl_log_error( dl_ctx, "Could not find subtype for member %s", member->name ); return DL_ERROR_TYPE_NOT_FOUND; } dl_internal_instance_store( dl_ctx, sub_type, instance, store_ctx ); } break; case DL_TYPE_STORAGE_STR: dl_internal_store_string( instance, store_ctx ); break; case DL_TYPE_STORAGE_PTR: { uint8* data = *(uint8**)instance; pint offset = store_ctx->FindWrittenPtr( data ); if( data == 0x0 ) // Null-pointer, store pint(-1) to signal to patching! { DL_ASSERT(offset == pint(-1) && "This pointer should not have been found among the written ptrs!"); // keep the -1 in Offset and store it to ptr. } else if( offset == pint(-1) ) // has not been written yet! { pint pos = dl_binary_writer_tell( &store_ctx->writer ); dl_binary_writer_seek_end( &store_ctx->writer ); const SDLType* sub_type = dl_internal_find_type( dl_ctx, member->type_id ); pint size = dl_internal_align_up( sub_type->size[DL_PTR_SIZE_HOST], sub_type->alignment[DL_PTR_SIZE_HOST] ); dl_binary_writer_align( &store_ctx->writer, sub_type->alignment[DL_PTR_SIZE_HOST] ); offset = dl_binary_writer_tell( &store_ctx->writer ); // write data! dl_binary_writer_reserve( &store_ctx->writer, size ); // reserve space for ptr so subdata is placed correctly store_ctx->AddWrittenPtr(data, offset); dl_internal_instance_store(dl_ctx, sub_type, data, store_ctx); dl_binary_writer_seek_set( &store_ctx->writer, pos ); } dl_binary_writer_write( &store_ctx->writer, &offset, sizeof(pint) ); } break; default: // default is a standard pod-type DL_ASSERT( member->IsSimplePod() || storage_type == DL_TYPE_STORAGE_ENUM ); dl_binary_writer_write( &store_ctx->writer, instance, member->size[DL_PTR_SIZE_HOST] ); break; } } return DL_ERROR_OK; case DL_TYPE_ATOM_INLINE_ARRAY: { switch( storage_type ) { case DL_TYPE_STORAGE_STRUCT: dl_binary_writer_write( &store_ctx->writer, instance, member->size[DL_PTR_SIZE_HOST] ); // TODO: I Guess that this is a bug! Will it fix ptrs well? break; case DL_TYPE_STORAGE_STR: { uint32 count = member->size[DL_PTR_SIZE_HOST] / sizeof(char*); for( uint32 elem = 0; elem < count; ++elem ) dl_internal_store_string( instance + (elem * sizeof(char*)), store_ctx ); } break; default: // default is a standard pod-type DL_ASSERT( member->IsSimplePod() || storage_type == DL_TYPE_STORAGE_ENUM ); dl_binary_writer_write( &store_ctx->writer, instance, member->size[DL_PTR_SIZE_HOST] ); break; } } return DL_ERROR_OK; case DL_TYPE_ATOM_ARRAY: { pint size = 0; const SDLType* sub_type = 0x0; uint8* data_ptr = instance; uint32 count = *(uint32*)( data_ptr + sizeof(void*) ); pint offset = 0; if( count == 0 ) offset = DL_NULL_PTR_OFFSET[ DL_PTR_SIZE_HOST ]; else { pint pos = dl_binary_writer_tell( &store_ctx->writer ); dl_binary_writer_seek_end( &store_ctx->writer ); switch(storage_type) { case DL_TYPE_STORAGE_STRUCT: sub_type = dl_internal_find_type( dl_ctx, member->type_id ); size = dl_internal_align_up( sub_type->size[DL_PTR_SIZE_HOST], sub_type->alignment[DL_PTR_SIZE_HOST] ); dl_binary_writer_align( &store_ctx->writer, sub_type->alignment[DL_PTR_SIZE_HOST] ); break; case DL_TYPE_STORAGE_STR: size = sizeof(void*); dl_binary_writer_align( &store_ctx->writer, size ); break; default: size = DLPodSize( member->type ); dl_binary_writer_align( &store_ctx->writer, size ); } offset = dl_binary_writer_tell( &store_ctx->writer ); // write data! dl_binary_writer_reserve( &store_ctx->writer, count * size ); // reserve space for array so subdata is placed correctly uint8* data = *(uint8**)data_ptr; switch(storage_type) { case DL_TYPE_STORAGE_STRUCT: for ( unsigned int elem = 0; elem < count; ++elem ) dl_internal_instance_store( dl_ctx, sub_type, data + (elem * size), store_ctx ); break; case DL_TYPE_STORAGE_STR: for ( unsigned int elem = 0; elem < count; ++elem ) dl_internal_store_string( data + (elem * size), store_ctx ); break; default: for ( unsigned int elem = 0; elem < count; ++elem ) dl_binary_writer_write( &store_ctx->writer, data + (elem * size), size ); break; } dl_binary_writer_seek_set( &store_ctx->writer, pos ); } // make room for ptr dl_binary_writer_write( &store_ctx->writer, &offset, sizeof(pint) ); // write count dl_binary_writer_write( &store_ctx->writer, &count, sizeof(uint32) ); } return DL_ERROR_OK; case DL_TYPE_ATOM_BITFIELD: dl_binary_writer_write( &store_ctx->writer, instance, member->size[DL_PTR_SIZE_HOST] ); break; default: DL_ASSERT(false && "Invalid ATOM-type!"); break; } return DL_ERROR_OK; }
static dl_error_t dl_internal_store_member( dl_ctx_t dl_ctx, const dl_member_desc* member, uint8_t* instance, CDLBinStoreContext* store_ctx ) { dl_type_t atom_type = dl_type_t(member->type & DL_TYPE_ATOM_MASK); dl_type_t storage_type = dl_type_t(member->type & DL_TYPE_STORAGE_MASK); switch ( atom_type ) { case DL_TYPE_ATOM_POD: { switch( storage_type ) { case DL_TYPE_STORAGE_STRUCT: { const dl_type_desc* sub_type = dl_internal_find_type( dl_ctx, member->type_id ); if( sub_type == 0x0 ) { dl_log_error( dl_ctx, "Could not find subtype for member %s", dl_internal_member_name( dl_ctx, member ) ); return DL_ERROR_TYPE_NOT_FOUND; } dl_internal_instance_store( dl_ctx, sub_type, instance, store_ctx ); } break; case DL_TYPE_STORAGE_STR: dl_internal_store_string( instance, store_ctx ); break; case DL_TYPE_STORAGE_PTR: { uint8_t* data = *(uint8_t**)instance; uintptr_t offset = store_ctx->FindWrittenPtr( data ); if( data == 0x0 ) // Null-pointer, store pint(-1) to signal to patching! { DL_ASSERT(offset == (uintptr_t)-1 && "This pointer should not have been found among the written ptrs!"); // keep the -1 in Offset and store it to ptr. } else if( offset == (uintptr_t)-1 ) // has not been written yet! { uintptr_t pos = dl_binary_writer_tell( &store_ctx->writer ); dl_binary_writer_seek_end( &store_ctx->writer ); const dl_type_desc* sub_type = dl_internal_find_type( dl_ctx, member->type_id ); uintptr_t size = dl_internal_align_up( sub_type->size[DL_PTR_SIZE_HOST], sub_type->alignment[DL_PTR_SIZE_HOST] ); dl_binary_writer_align( &store_ctx->writer, sub_type->alignment[DL_PTR_SIZE_HOST] ); offset = dl_binary_writer_tell( &store_ctx->writer ); // write data! dl_binary_writer_reserve( &store_ctx->writer, size ); // reserve space for ptr so subdata is placed correctly store_ctx->AddWrittenPtr(data, offset); dl_internal_instance_store(dl_ctx, sub_type, data, store_ctx); dl_binary_writer_seek_set( &store_ctx->writer, pos ); } dl_binary_writer_write( &store_ctx->writer, &offset, sizeof(uintptr_t) ); } break; default: // default is a standard pod-type DL_ASSERT( member->IsSimplePod() || storage_type == DL_TYPE_STORAGE_ENUM ); dl_binary_writer_write( &store_ctx->writer, instance, member->size[DL_PTR_SIZE_HOST] ); break; } } return DL_ERROR_OK; case DL_TYPE_ATOM_INLINE_ARRAY: { const dl_type_desc* sub_type = 0x0; uint32_t count = member->inline_array_cnt(); if( storage_type == DL_TYPE_STORAGE_STRUCT ) { sub_type = dl_internal_find_type(dl_ctx, member->type_id); if (sub_type == 0x0) { dl_log_error(dl_ctx, "Could not find subtype for member %s", dl_internal_member_name(dl_ctx, member)); return DL_ERROR_TYPE_NOT_FOUND; } } else if( storage_type != DL_TYPE_STORAGE_STR ) count = member->size[DL_PTR_SIZE_HOST]; dl_internal_store_array( dl_ctx, storage_type, sub_type, instance, count, 1, store_ctx ); } return DL_ERROR_OK; case DL_TYPE_ATOM_ARRAY: { uintptr_t size = 0; const dl_type_desc* sub_type = 0x0; uint8_t* data_ptr = instance; uint32_t count = *(uint32_t*)( data_ptr + sizeof(void*) ); uintptr_t offset = 0; if( count == 0 ) offset = DL_NULL_PTR_OFFSET[ DL_PTR_SIZE_HOST ]; else { uintptr_t pos = dl_binary_writer_tell( &store_ctx->writer ); dl_binary_writer_seek_end( &store_ctx->writer ); switch(storage_type) { case DL_TYPE_STORAGE_STRUCT: sub_type = dl_internal_find_type( dl_ctx, member->type_id ); size = dl_internal_align_up( sub_type->size[DL_PTR_SIZE_HOST], sub_type->alignment[DL_PTR_SIZE_HOST] ); dl_binary_writer_align( &store_ctx->writer, sub_type->alignment[DL_PTR_SIZE_HOST] ); break; case DL_TYPE_STORAGE_STR: size = sizeof(void*); dl_binary_writer_align( &store_ctx->writer, size ); break; default: size = dl_pod_size( member->type ); dl_binary_writer_align( &store_ctx->writer, size ); } offset = dl_binary_writer_tell( &store_ctx->writer ); // write data! dl_binary_writer_reserve( &store_ctx->writer, count * size ); // reserve space for array so subdata is placed correctly uint8_t* data = *(uint8_t**)data_ptr; dl_internal_store_array( dl_ctx, storage_type, sub_type, data, count, size, store_ctx ); dl_binary_writer_seek_set( &store_ctx->writer, pos ); } // make room for ptr dl_binary_writer_write( &store_ctx->writer, &offset, sizeof(uintptr_t) ); // write count dl_binary_writer_write( &store_ctx->writer, &count, sizeof(uint32_t) ); } return DL_ERROR_OK; case DL_TYPE_ATOM_BITFIELD: dl_binary_writer_write( &store_ctx->writer, instance, member->size[DL_PTR_SIZE_HOST] ); break; default: DL_ASSERT(false && "Invalid ATOM-type!"); break; } return DL_ERROR_OK; }