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

src/ZoneCodeGeneratorLib/Domain/Information/MemberInformation.cpp

@@ -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),

src/ZoneCodeGeneratorLib/Domain/Information/MemberInformation.h

@@ -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;

src/ZoneCodeGeneratorLib/Domain/Information/StructureInformation.cpp

@@ -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)
 {

src/ZoneCodeGeneratorLib/Domain/Information/StructureInformation.h

@@ -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;

src/ZoneCodeGeneratorLib/Domain/Information/TypeInformation.cpp

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

src/ZoneCodeGeneratorLib/Domain/Information/TypeInformation.h

@@ -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;
+};

src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp

@@ -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("")

src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.cpp

@@ -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;

src/ZoneCodeGeneratorLib/Parsing/Header/HeaderFileReader.cpp

@@ -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>());
 }

src/ZoneCodeGeneratorLib/Parsing/PostProcessing/CreateMemberInformationPostProcessor.cpp

@@ -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;

src/ZoneCodeGeneratorLib/Parsing/PostProcessing/CreateStructureInformationPostProcessor.cpp

@@ -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;

src/ZoneCodeGeneratorLib/Parsing/PostProcessing/CreateTypeInformationPostProcessor.cpp

@@ -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;
+}

src/ZoneCodeGeneratorLib/Parsing/PostProcessing/CreateTypeInformationPostProcessor.h

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

src/ZoneCodeGeneratorLib/Parsing/PostProcessing/UsagesPostProcessor.cpp

@@ -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())
+                if (member->m_is_reusable && member->m_type_info)
-                    member->m_type->m_embedded_reference_exists = true;
+                    member->m_type_info->m_reusable_reference_exists = true;
 
-                if (computations.ContainsNonEmbeddedReference())
+                if (member->m_type)
-                    member->m_type->m_non_embedded_reference_exists = true;
+                {
+                    if (computations.IsArray() || member->m_member->m_type_declaration->m_declaration_modifiers.empty())
+                        member->m_type->m_embedded_reference_exists = true;
 
-                if (computations.ContainsSinglePointerReference())
+                    if (computations.ContainsNonEmbeddedReference())
-                    member->m_type->m_single_pointer_reference_exists = true;
+                        member->m_type->m_non_embedded_reference_exists = true;
 
-                if (computations.ContainsArrayPointerReference())
+                    if (computations.ContainsSinglePointerReference())
-                    member->m_type->m_array_pointer_reference_exists = true;
+                        member->m_type->m_single_pointer_reference_exists = true;
 
-                if (computations.ContainsArrayReference())
+                    if (computations.ContainsArrayPointerReference())
-                    member->m_type->m_array_reference_exists = true;
+                        member->m_type->m_array_pointer_reference_exists = true;
 
-                if (computations.IsNotInDefaultNormalBlock())
+                    if (computations.ContainsArrayReference())
-                    member->m_type->m_reference_from_non_default_normal_block_exists = true;
+                        member->m_type->m_array_reference_exists = true;
 
-                if (member->m_is_reusable)
+                    if (computations.IsNotInDefaultNormalBlock())
-                    member->m_type->m_reusable_reference_exists = true;
+                        member->m_type->m_reference_from_non_default_normal_block_exists = true;
 
-                member->m_type->m_usages.push_back(currentStructure);
+                    member->m_type->m_usages.push_back(currentStructure);
-                processingQueue.push(member->m_type);
+                    processingQueue.push(member->m_type);
+                }
             }
         }
 

src/ZoneCodeGeneratorLib/Persistence/IDataRepository.h

@@ -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;
 };

src/ZoneCodeGeneratorLib/Persistence/InMemory/InMemoryRepository.cpp

@@ -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);

src/ZoneCodeGeneratorLib/Persistence/InMemory/InMemoryRepository.h

@@ -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::unordered_map<std::string, DataDefinition*> m_data_definitions_by_name;
-    std::map<std::string, EnumMember*> m_enum_members_by_name;
+    std::unordered_map<std::string, EnumMember*> m_enum_members_by_name;
-    std::map<std::string, const FastFileBlock*> m_fast_file_blocks_by_name;
+    std::unordered_map<std::string, const FastFileBlock*> m_fast_file_blocks_by_name;
-    std::map<const DefinitionWithMembers*, StructureInformation*> m_structure_information_by_definition;
+    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;
 };