zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2026-03-15 17:33:03 +00:00
Code Activity

fix: not adding offset of reusable type when type is not structure

Browse Source
This commit is contained in:
Jan Laupetin
2026-03-14 15:56:08 +01:00
parent adc3908b90
commit 14b143466d
17 changed files with 135 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/ZoneCodeGeneratorLib/Domain/Information/MemberInformation.cpp
View File

@@ -1,8 +1,9 @@
#include "MemberInformation.h"
MemberInformation::MemberInformation(StructureInformation* parent, StructureInformation* type, Variable* member)
MemberInformation::MemberInformation(StructureInformation* parent, StructureInformation* type, TypeInformation* typeInfo, Variable* member)
: m_parent(parent),
m_type(type),
m_type_info(typeInfo),
m_member(member),
m_is_string(false),
m_is_script_string(false),

4
src/ZoneCodeGeneratorLib/Domain/Information/MemberInformation.h
View File

@@ -4,6 +4,7 @@
#include "Domain/Evaluation/IEvaluation.h"
#include "Domain/FastFile/FastFileBlock.h"
#include "StructureInformation.h"
#include "TypeInformation.h"
#include <memory>
@@ -12,10 +13,11 @@ class StructureInformation;
class MemberInformation
{
public:
MemberInformation(StructureInformation* parent, StructureInformation* type, Variable* member);
MemberInformation(StructureInformation* parent, StructureInformation* type, TypeInformation* typeInfo, Variable* member);
StructureInformation* m_parent;
StructureInformation* m_type;
TypeInformation* m_type_info;
Variable* m_member;
bool m_is_string;
bool m_is_script_string;

5
src/ZoneCodeGeneratorLib/Domain/Information/StructureInformation.cpp
View File

@@ -1,16 +1,17 @@
#include "StructureInformation.h"
StructureInformation::StructureInformation(DefinitionWithMembers* definition)
StructureInformation::StructureInformation(DefinitionWithMembers* definition, TypeInformation* typeInfo)
: m_definition(definition),
m_type_info(typeInfo),
m_is_leaf(false),
m_requires_marking(false),
m_has_matching_cross_platform_structure(false),
m_embedded_reference_exists(false),
m_non_embedded_reference_exists(false),
m_single_pointer_reference_exists(false),
m_array_pointer_reference_exists(false),
m_array_reference_exists(false),
m_reference_from_non_default_normal_block_exists(false),
m_reusable_reference_exists(false),
m_post_load_action(nullptr),
m_block(nullptr)
{

5
src/ZoneCodeGeneratorLib/Domain/Information/StructureInformation.h
View File

@@ -5,6 +5,7 @@
#include "Domain/Extension/CustomAction.h"
#include "Domain/FastFile/FastFileBlock.h"
#include "MemberInformation.h"
#include "TypeInformation.h"
#include <memory>
#include <vector>
@@ -14,9 +15,10 @@ class MemberInformation;
class StructureInformation
{
public:
explicit StructureInformation(DefinitionWithMembers* definition);
StructureInformation(DefinitionWithMembers* definition, TypeInformation* typeInfo);
DefinitionWithMembers* m_definition;
TypeInformation* m_type_info;
std::string m_asset_name;
std::vector<StructureInformation*> m_usages;
@@ -32,7 +34,6 @@ public:
bool m_array_pointer_reference_exists;
bool m_array_reference_exists;
bool m_reference_from_non_default_normal_block_exists;
bool m_reusable_reference_exists;
std::unique_ptr<CustomAction> m_post_load_action;
const FastFileBlock* m_block;

7
src/ZoneCodeGeneratorLib/Domain/Information/TypeInformation.cpp Normal file
View File

@@ -0,0 +1,7 @@
#include "TypeInformation.h"
TypeInformation::TypeInformation(DataDefinition* definition)
: m_definition(definition),
m_reusable_reference_exists(false)
{
}

12
src/ZoneCodeGeneratorLib/Domain/Information/TypeInformation.h Normal file
View File

@@ -0,0 +1,12 @@
#pragma once
#include "Domain/Definition/DataDefinition.h"
class TypeInformation
{
public:
explicit TypeInformation(DataDefinition* definition);
DataDefinition* m_definition;
bool m_reusable_reference_exists;
};

2
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp
View File

@@ -661,7 +661,7 @@ namespace
void PrintFillStruct_Struct(const StructureInformation& info)
{
if (info.m_reusable_reference_exists)
if (info.m_type_info && info.m_type_info->m_reusable_reference_exists)
{
LINEF("m_stream.AddPointerLookup({0}, fillAccessor.BlockBuffer(0));", MakeTypeVarName(info.m_definition))
LINE("")

2
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.cpp
View File

@@ -715,7 +715,7 @@ namespace
if (member->m_is_reusable)
return true;
if (member->m_type == nullptr || !member->m_type->m_reusable_reference_exists)
if (member->m_type_info == nullptr || !member->m_type_info->m_reusable_reference_exists)
return false;
return true;

2
src/ZoneCodeGeneratorLib/Parsing/Header/HeaderFileReader.cpp
View File

@@ -9,6 +9,7 @@
#include "Parsing/Impl/ParserFilesystemStream.h"
#include "Parsing/PostProcessing/CreateMemberInformationPostProcessor.h"
#include "Parsing/PostProcessing/CreateStructureInformationPostProcessor.h"
#include "Parsing/PostProcessing/CreateTypeInformationPostProcessor.h"
#include "Parsing/PostProcessing/IPostProcessor.h"
#include "Utils/Logging/Log.h"
@@ -66,6 +67,7 @@ void HeaderFileReader::SetupStreamProxies()
void HeaderFileReader::SetupPostProcessors()
{
// Order is important
m_post_processors.emplace_back(std::make_unique<CreateTypeInformationPostProcessor>());
m_post_processors.emplace_back(std::make_unique<CreateStructureInformationPostProcessor>());
m_post_processors.emplace_back(std::make_unique<CreateMemberInformationPostProcessor>());
}

5
src/ZoneCodeGeneratorLib/Parsing/PostProcessing/CreateMemberInformationPostProcessor.cpp
View File

@@ -4,7 +4,7 @@
namespace
{
bool CreateMemberInformationForStructure(IDataRepository* repository, StructureInformation* structure)
bool CreateMemberInformationForStructure(const IDataRepository* repository, StructureInformation* structure)
{
for (const auto& member : structure->m_definition->m_members)
{
@@ -21,7 +21,8 @@ namespace
if (memberDefinition != nullptr)
typeInfo = repository->GetInformationFor(memberDefinition);
structure->m_ordered_members.emplace_back(std::make_unique<MemberInformation>(structure, typeInfo, member.get()));
structure->m_ordered_members.emplace_back(
std::make_unique<MemberInformation>(structure, typeInfo, repository->GetTypeInformationFor(member->m_type_declaration->m_type), member.get()));
}
return true;

4
src/ZoneCodeGeneratorLib/Parsing/PostProcessing/CreateStructureInformationPostProcessor.cpp
View File

@@ -6,14 +6,14 @@ bool CreateStructureInformationPostProcessor::PostProcess(IDataRepository* repos
{
auto* information = repository->GetInformationFor(structDefinition);
if (information == nullptr)
repository->Add(std::make_unique<StructureInformation>(structDefinition));
repository->Add(std::make_unique<StructureInformation>(structDefinition, repository->GetTypeInformationFor(structDefinition)));
}
for (auto* unionDefinition : repository->GetAllUnions())
{
auto* information = repository->GetInformationFor(unionDefinition);
if (information == nullptr)
repository->Add(std::make_unique<StructureInformation>(unionDefinition));
repository->Add(std::make_unique<StructureInformation>(unionDefinition, repository->GetTypeInformationFor(unionDefinition)));
}
return true;

34
src/ZoneCodeGeneratorLib/Parsing/PostProcessing/CreateTypeInformationPostProcessor.cpp Normal file
View File

@@ -0,0 +1,34 @@
#include "CreateTypeInformationPostProcessor.h"
bool CreateTypeInformationPostProcessor::PostProcess(IDataRepository* repository)
{
for (auto* _enum : repository->GetAllEnums())
{
const auto* information = repository->GetTypeInformationFor(_enum);
if (information == nullptr)
repository->Add(std::make_unique<TypeInformation>(_enum));
}
for (auto* _typeDef : repository->GetAllTypedefs())
{
const auto* information = repository->GetTypeInformationFor(_typeDef);
if (information == nullptr)
repository->Add(std::make_unique<TypeInformation>(_typeDef));
}
for (auto* _struct : repository->GetAllStructs())
{
const auto* information = repository->GetTypeInformationFor(_struct);
if (information == nullptr)
repository->Add(std::make_unique<TypeInformation>(_struct));
}
for (auto* _union : repository->GetAllUnions())
{
const auto* information = repository->GetTypeInformationFor(_union);
if (information == nullptr)
repository->Add(std::make_unique<TypeInformation>(_union));
}
return true;
}

9
src/ZoneCodeGeneratorLib/Parsing/PostProcessing/CreateTypeInformationPostProcessor.h Normal file
View File

@@ -0,0 +1,9 @@
#pragma once
#include "IPostProcessor.h"
class CreateTypeInformationPostProcessor final : public IPostProcessor
{
public:
bool PostProcess(IDataRepository* repository) override;
};

38
src/ZoneCodeGeneratorLib/Parsing/PostProcessing/UsagesPostProcessor.cpp
View File

@@ -27,37 +27,37 @@ namespace
for (const auto& member : currentStructure->m_ordered_members)
{
if (member->m_type == nullptr)
continue;
const MemberComputations computations(member.get());
if (computations.ShouldIgnore())
continue;
if (computations.IsArray() || member->m_member->m_type_declaration->m_declaration_modifiers.empty())
member->m_type->m_embedded_reference_exists = true;
if (member->m_is_reusable && member->m_type_info)
member->m_type_info->m_reusable_reference_exists = true;
if (computations.ContainsNonEmbeddedReference())
member->m_type->m_non_embedded_reference_exists = true;
if (member->m_type)
{
if (computations.IsArray() || member->m_member->m_type_declaration->m_declaration_modifiers.empty())
member->m_type->m_embedded_reference_exists = true;
if (computations.ContainsSinglePointerReference())
member->m_type->m_single_pointer_reference_exists = true;
if (computations.ContainsNonEmbeddedReference())
member->m_type->m_non_embedded_reference_exists = true;
if (computations.ContainsArrayPointerReference())
member->m_type->m_array_pointer_reference_exists = true;
if (computations.ContainsSinglePointerReference())
member->m_type->m_single_pointer_reference_exists = true;
if (computations.ContainsArrayReference())
member->m_type->m_array_reference_exists = true;
if (computations.ContainsArrayPointerReference())
member->m_type->m_array_pointer_reference_exists = true;
if (computations.IsNotInDefaultNormalBlock())
member->m_type->m_reference_from_non_default_normal_block_exists = true;
if (computations.ContainsArrayReference())
member->m_type->m_array_reference_exists = true;
if (member->m_is_reusable)
member->m_type->m_reusable_reference_exists = true;
if (computations.IsNotInDefaultNormalBlock())
member->m_type->m_reference_from_non_default_normal_block_exists = true;
member->m_type->m_usages.push_back(currentStructure);
processingQueue.push(member->m_type);
member->m_type->m_usages.push_back(currentStructure);
processingQueue.push(member->m_type);
}
}
}

2
src/ZoneCodeGeneratorLib/Persistence/IDataRepository.h
View File

@@ -24,6 +24,7 @@ public:
virtual void Add(std::unique_ptr<StructDefinition> structDefinition) = 0;
virtual void Add(std::unique_ptr<UnionDefinition> unionDefinition) = 0;
virtual void Add(std::unique_ptr<TypedefDefinition> typedefDefinition) = 0;
virtual void Add(std::unique_ptr<TypeInformation> typeInformation) = 0;
virtual void Add(std::unique_ptr<StructureInformation> structureInformation) = 0;
virtual void Add(std::unique_ptr<FastFileBlock> fastFileBlock) = 0;
@@ -41,6 +42,7 @@ public:
[[nodiscard]] virtual DataDefinition* GetDataDefinitionByName(const std::string& name) const = 0;
[[nodiscard]] virtual StructureInformation* GetInformationFor(const DefinitionWithMembers* definitionWithMembers) const = 0;
[[nodiscard]] virtual TypeInformation* GetTypeInformationFor(const DataDefinition* definition) const = 0;
[[nodiscard]] virtual EnumMember* GetEnumMemberByName(const std::string& name) const = 0;
[[nodiscard]] virtual const FastFileBlock* GetFastFileBlockByName(const std::string& name) const = 0;
};

29
src/ZoneCodeGeneratorLib/Persistence/InMemory/InMemoryRepository.cpp
View File

@@ -24,7 +24,7 @@ InMemoryRepository::~InMemoryRepository()
void InMemoryRepository::Add(std::unique_ptr<EnumDefinition> enumsDefinition)
{
auto* raw = enumsDefinition.release();
m_enums.push_back(raw);
m_enums.emplace_back(raw);
m_data_definitions_by_name[raw->m_name] = raw;
for (const auto& enumMember : raw->m_members)
@@ -34,35 +34,42 @@ void InMemoryRepository::Add(std::unique_ptr<EnumDefinition> enumsDefinition)
void InMemoryRepository::Add(std::unique_ptr<StructDefinition> structDefinition)
{
auto* raw = structDefinition.release();
m_structs.push_back(raw);
m_structs.emplace_back(raw);
m_data_definitions_by_name[raw->m_name] = raw;
}
void InMemoryRepository::Add(std::unique_ptr<UnionDefinition> unionDefinition)
{
auto* raw = unionDefinition.release();
m_unions.push_back(raw);
m_unions.emplace_back(raw);
m_data_definitions_by_name[raw->m_name] = raw;
}
void InMemoryRepository::Add(std::unique_ptr<TypedefDefinition> typedefDefinition)
{
auto* raw = typedefDefinition.release();
m_typedefs.push_back(raw);
m_typedefs.emplace_back(raw);
m_data_definitions_by_name[raw->m_name] = raw;
}
void InMemoryRepository::Add(std::unique_ptr<StructureInformation> structureInformation)
{
auto* raw = structureInformation.release();
m_structures_information.push_back(raw);
m_structures_information.emplace_back(raw);
m_structure_information_by_definition[raw->m_definition] = raw;
}
void InMemoryRepository::Add(std::unique_ptr<TypeInformation> typeInformation)
{
auto* raw = typeInformation.release();
m_types_information.emplace_back(raw);
m_type_information_by_definition[raw->m_definition] = raw;
}
void InMemoryRepository::Add(std::unique_ptr<FastFileBlock> fastFileBlock)
{
auto* raw = fastFileBlock.release();
m_fast_file_blocks.push_back(raw);
m_fast_file_blocks.emplace_back(raw);
m_fast_file_blocks_by_name[raw->m_name] = raw;
}
@@ -136,6 +143,16 @@ StructureInformation* InMemoryRepository::GetInformationFor(const DefinitionWith
return nullptr;
}
TypeInformation* InMemoryRepository::GetTypeInformationFor(const DataDefinition* definition) const
{
const auto foundEntry = m_type_information_by_definition.find(definition);
if (foundEntry != m_type_information_by_definition.end())
return foundEntry->second;
return nullptr;
}
EnumMember* InMemoryRepository::GetEnumMemberByName(const std::string& name) const
{
const auto foundEntry = m_enum_members_by_name.find(name);

14
src/ZoneCodeGeneratorLib/Persistence/InMemory/InMemoryRepository.h
View File

@@ -2,7 +2,7 @@
#include "Persistence/IDataRepository.h"
#include <map>
#include <unordered_map>
class InMemoryRepository final : public IDataRepository
{
@@ -19,6 +19,7 @@ public:
void Add(std::unique_ptr<UnionDefinition> unionDefinition) override;
void Add(std::unique_ptr<TypedefDefinition> typedefDefinition) override;
void Add(std::unique_ptr<StructureInformation> structureInformation) override;
void Add(std::unique_ptr<TypeInformation> typeInformation) override;
void Add(std::unique_ptr<FastFileBlock> fastFileBlock) override;
[[nodiscard]] const std::string& GetGameName() const override;
@@ -35,6 +36,7 @@ public:
[[nodiscard]] DataDefinition* GetDataDefinitionByName(const std::string& name) const override;
[[nodiscard]] StructureInformation* GetInformationFor(const DefinitionWithMembers* definitionWithMembers) const override;
[[nodiscard]] TypeInformation* GetTypeInformationFor(const DataDefinition* definition) const override;
[[nodiscard]] EnumMember* GetEnumMemberByName(const std::string& name) const override;
[[nodiscard]] const FastFileBlock* GetFastFileBlockByName(const std::string& name) const override;
@@ -44,11 +46,13 @@ private:
std::vector<UnionDefinition*> m_unions;
std::vector<TypedefDefinition*> m_typedefs;
std::vector<StructureInformation*> m_structures_information;
std::vector<TypeInformation*> m_types_information;
std::vector<const FastFileBlock*> m_fast_file_blocks;
std::map<std::string, DataDefinition*> m_data_definitions_by_name;
std::map<std::string, EnumMember*> m_enum_members_by_name;
std::map<std::string, const FastFileBlock*> m_fast_file_blocks_by_name;
std::map<const DefinitionWithMembers*, StructureInformation*> m_structure_information_by_definition;
std::unordered_map<std::string, DataDefinition*> m_data_definitions_by_name;
std::unordered_map<std::string, EnumMember*> m_enum_members_by_name;
std::unordered_map<std::string, const FastFileBlock*> m_fast_file_blocks_by_name;
std::unordered_map<const DefinitionWithMembers*, StructureInformation*> m_structure_information_by_definition;
std::unordered_map<const DataDefinition*, TypeInformation*> m_type_information_by_definition;
std::string m_game_name;
Architecture m_architecture;
};