Add information and computations to ZCG cpp

src/Utils/Utils/ClassUtils.h

@@ -10,8 +10,10 @@
 #define _CPP_VERSION 0
 #endif
 
+#ifndef _NODISCARD
 #if _CPP_VERSION >= 201703L
-#define _NO_DISCARD [[nodiscard]]
+#define _NODISCARD [[nodiscard]]
 #else
-#define _NO_DISCARD
+#define _NODISCARD
+#endif
 #endif

src/ZoneCodeGeneratorNew/Domain/Computations/MemberComputations.cpp

@@ -0,0 +1,228 @@
+#include "MemberComputations.h"
+
+#include <algorithm>
+#include <cassert>
+
+#include "StructureComputations.h"
+#include "Domain/Definition/ArrayDeclarationModifier.h"
+#include "Domain/Definition/PointerDeclarationModifier.h"
+
+MemberComputations::MemberComputations(const MemberInformation* member)
+    : m_info(member)
+{
+    assert(m_info != nullptr);
+}
+
+bool MemberComputations::ShouldIgnore() const
+{
+    return m_info->m_condition && m_info->m_condition->IsStatic() && m_info->m_condition->EvaluateNumeric() == 0;
+}
+
+bool MemberComputations::ContainsNonEmbeddedReference() const
+{
+    const auto& declarationModifiers = m_info->m_member->m_type_declaration->m_declaration_modifiers;
+    return std::any_of(declarationModifiers.begin(), declarationModifiers.end(), [](const std::unique_ptr<DeclarationModifier>& modifier)
+    {
+        return modifier->GetType() == DeclarationModifierType::POINTER;
+    });
+}
+
+bool MemberComputations::ContainsSinglePointerReference() const
+{
+    const auto& declarationModifiers = m_info->m_member->m_type_declaration->m_declaration_modifiers;
+    if (declarationModifiers.empty())
+        return false;
+
+    const auto* lastModifier = declarationModifiers[declarationModifiers.size() - 1].get();
+    if (lastModifier->GetType() != DeclarationModifierType::POINTER)
+        return false;
+
+    return !dynamic_cast<const PointerDeclarationModifier*>(lastModifier)->AnyCountEvaluationIsArray();
+}
+
+bool MemberComputations::ContainsArrayPointerReference() const
+{
+    const auto& declarationModifiers = m_info->m_member->m_type_declaration->m_declaration_modifiers;
+    if (declarationModifiers.empty())
+        return false;
+
+    const auto* lastModifier = declarationModifiers[declarationModifiers.size() - 1].get();
+    if (lastModifier->GetType() != DeclarationModifierType::POINTER)
+        return false;
+
+    return dynamic_cast<const PointerDeclarationModifier*>(lastModifier)->AnyCountEvaluationIsArray();
+}
+
+bool MemberComputations::ContainsPointerArrayReference() const
+{
+    if (!ContainsSinglePointerReference())
+        return false;
+
+    const auto pointerDepth = GetPointerDepth();
+    const auto isArray = IsArray();
+
+    return isArray && pointerDepth == 1 || !isArray && pointerDepth == 2;
+}
+
+bool MemberComputations::ContainsArrayReference() const
+{
+    const auto& declarationModifiers = m_info->m_member->m_type_declaration->m_declaration_modifiers;
+    if (declarationModifiers.empty())
+        return false;
+
+    const auto* lastModifier = declarationModifiers[declarationModifiers.size() - 1].get();
+    return lastModifier->GetType() == DeclarationModifierType::ARRAY;
+}
+
+const IEvaluation* MemberComputations::GetArrayPointerCountEvaluation() const
+{
+    const auto& declarationModifiers = m_info->m_member->m_type_declaration->m_declaration_modifiers;
+    if (declarationModifiers.empty())
+        return nullptr;
+
+    const auto* lastModifier = declarationModifiers[declarationModifiers.size() - 1].get();
+    return lastModifier->GetType() == DeclarationModifierType::POINTER
+               ? dynamic_cast<const PointerDeclarationModifier*>(lastModifier)->GetCountEvaluation()
+               : nullptr;
+}
+
+bool MemberComputations::IsArray() const
+{
+    const auto& declarationModifiers = m_info->m_member->m_type_declaration->m_declaration_modifiers;
+    if (declarationModifiers.empty())
+        return false;
+
+    return declarationModifiers[0]->GetType() == DeclarationModifierType::ARRAY;
+}
+
+std::vector<int> MemberComputations::GetArraySizes() const
+{
+    std::vector<int> sizes;
+    const auto& declarationModifiers = m_info->m_member->m_type_declaration->m_declaration_modifiers;
+    for (const auto& declarationModifier : declarationModifiers)
+    {
+        if (declarationModifier->GetType() != DeclarationModifierType::ARRAY)
+            break;
+
+        sizes.push_back(dynamic_cast<const ArrayDeclarationModifier*>(declarationModifier.get())->m_size);
+    }
+
+    return sizes;
+}
+
+int MemberComputations::GetArrayDimension() const
+{
+    auto dimension = 0;
+    const auto& declarationModifiers = m_info->m_member->m_type_declaration->m_declaration_modifiers;
+    for (const auto& declarationModifier : declarationModifiers)
+    {
+        if (declarationModifier->GetType() != DeclarationModifierType::ARRAY)
+            break;
+
+        dimension++;
+    }
+
+    return dimension;
+}
+
+bool MemberComputations::IsPointerToArray() const
+{
+    const auto& declarationModifiers = m_info->m_member->m_type_declaration->m_declaration_modifiers;
+    if (declarationModifiers.empty())
+        return false;
+
+    const auto* lastModifier = declarationModifiers[declarationModifiers.size() - 1].get();
+    if (lastModifier->GetType() != DeclarationModifierType::ARRAY)
+        return false;
+
+    return std::any_of(declarationModifiers.begin(), declarationModifiers.end(), [](const std::unique_ptr<DeclarationModifier>& modifier)
+    {
+        return modifier->GetType() == DeclarationModifierType::POINTER;
+    });
+}
+
+std::vector<int> MemberComputations::GetPointerToArraySizes() const
+{
+    std::vector<int> sizes;
+    const auto& declarationModifiers = m_info->m_member->m_type_declaration->m_declaration_modifiers;
+    for (const auto& declarationModifier : declarationModifiers)
+    {
+        if (declarationModifier->GetType() == DeclarationModifierType::ARRAY)
+        {
+            sizes.push_back(dynamic_cast<ArrayDeclarationModifier*>(declarationModifier.get())->m_size);
+        }
+        else
+        {
+            sizes.clear();
+        }
+    }
+
+    return sizes;
+}
+
+int MemberComputations::GetPointerDepth() const
+{
+    auto depth = 0;
+    const auto& declarationModifiers = m_info->m_member->m_type_declaration->m_declaration_modifiers;
+    for(const auto& declarationModifier : declarationModifiers)
+    {
+        if (declarationModifier->GetType() == DeclarationModifierType::POINTER)
+            depth++;
+    }
+
+    return depth;
+}
+
+bool MemberComputations::IsNotInDefaultNormalBlock() const
+{
+    return m_info->m_fast_file_block != nullptr && !(m_info->m_fast_file_block->m_type == FastFileBlockType::NORMAL && m_info->m_fast_file_block->m_is_default);
+}
+
+bool MemberComputations::IsInTempBlock() const
+{
+    return m_info->m_fast_file_block != nullptr && m_info->m_fast_file_block->m_type == FastFileBlockType::TEMP;
+}
+
+bool MemberComputations::IsInRuntimeBlock() const
+{
+    return m_info->m_fast_file_block != nullptr && m_info->m_fast_file_block->m_type == FastFileBlockType::RUNTIME;
+}
+
+bool MemberComputations::IsFirstMember() const
+{
+    const auto parentUsedMembers = StructureComputations(m_info->m_parent).GetUsedMembers();
+    return !parentUsedMembers.empty() && parentUsedMembers[0] == m_info;
+}
+
+bool MemberComputations::IsLastMember() const
+{
+    const auto parentUsedMembers = StructureComputations(m_info->m_parent).GetUsedMembers();
+    return !parentUsedMembers.empty() && parentUsedMembers[parentUsedMembers.size() - 1] == m_info;
+}
+
+bool MemberComputations::HasDynamicArraySize() const
+{
+    const auto& declarationModifiers = m_info->m_member->m_type_declaration->m_declaration_modifiers;
+
+    return std::any_of(declarationModifiers.begin(), declarationModifiers.end(), [](const std::unique_ptr<DeclarationModifier>& declarationModifier)
+    {
+        return declarationModifier->GetType() == DeclarationModifierType::ARRAY
+            && dynamic_cast<ArrayDeclarationModifier*>(declarationModifier.get())->m_dynamic_size_evaluation;
+    });
+}
+
+bool MemberComputations::IsDynamicMember() const
+{
+    if (HasDynamicArraySize())
+        return true;
+
+    return !ContainsNonEmbeddedReference() && m_info->m_type && StructureComputations(m_info->m_type).GetDynamicMember() != nullptr;
+}
+
+bool MemberComputations::IsAfterPartialLoad() const
+{
+    if (IsDynamicMember())
+        return true;
+
+    return m_info->m_parent->m_definition->GetType() == DataDefinitionType::UNION && StructureComputations(m_info->m_parent).GetDynamicMember() != nullptr;
+}

src/ZoneCodeGeneratorNew/Domain/Computations/MemberComputations.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "Domain/Information/MemberInformation.h"
+
+class MemberComputations
+{
+    const MemberInformation* const m_info;
+
+public:
+    explicit MemberComputations(const MemberInformation* member);
+
+    _NODISCARD bool ShouldIgnore() const;
+    _NODISCARD bool ContainsNonEmbeddedReference() const;
+    _NODISCARD bool ContainsSinglePointerReference() const;
+    _NODISCARD bool ContainsArrayPointerReference() const;
+    _NODISCARD bool ContainsPointerArrayReference() const;
+    _NODISCARD bool ContainsArrayReference() const;
+    _NODISCARD const IEvaluation* GetArrayPointerCountEvaluation() const;
+    _NODISCARD bool IsArray() const;
+    _NODISCARD std::vector<int> GetArraySizes() const;
+    _NODISCARD int GetArrayDimension() const;
+    _NODISCARD bool IsPointerToArray() const;
+    _NODISCARD std::vector<int> GetPointerToArraySizes() const;
+    _NODISCARD int GetPointerDepth() const;
+    _NODISCARD bool IsNotInDefaultNormalBlock() const;
+    _NODISCARD bool IsInTempBlock() const;
+    _NODISCARD bool IsInRuntimeBlock() const;
+    _NODISCARD bool IsFirstMember() const;
+    _NODISCARD bool IsLastMember() const;
+    _NODISCARD bool HasDynamicArraySize() const;
+    _NODISCARD bool IsDynamicMember() const;
+    _NODISCARD bool IsAfterPartialLoad() const;
+};

src/ZoneCodeGeneratorNew/Domain/Computations/MemberDeclarationModifierComputations.cpp

@@ -0,0 +1,243 @@
+#include "MemberDeclarationModifierComputations.h"
+
+#include <algorithm>
+#include <cassert>
+
+#include "MemberComputations.h"
+#include "Domain/Definition/ArrayDeclarationModifier.h"
+#include "Domain/Definition/PointerDeclarationModifier.h"
+
+DeclarationModifierComputations::DeclarationModifierComputations(const MemberInformation* member, std::vector<int> modifierIndices)
+    : m_information(member),
+      m_modifier_indices(std::move(modifierIndices))
+{
+    auto combinedIndex = 0;
+    auto arraySizes = MemberComputations(m_information).GetArraySizes();
+    std::vector<int> sizePerDepth(arraySizes.size());
+
+    auto currentDepthSize = 1;
+    for (int i = arraySizes.size(); i > 0; i--)
+    {
+        sizePerDepth[i - 1] = currentDepthSize;
+        currentDepthSize *= arraySizes[i - 1];
+    }
+
+    auto currentDepth = 0;
+    for (auto modifierIndex : m_modifier_indices)
+    {
+        combinedIndex += sizePerDepth[currentDepth++] * modifierIndex;
+    }
+
+    m_combined_index = combinedIndex;
+}
+
+DeclarationModifierComputations::DeclarationModifierComputations(const MemberInformation* member)
+    : m_information(member),
+      m_combined_index(0)
+{
+}
+
+DeclarationModifier* DeclarationModifierComputations::GetDeclarationModifier() const
+{
+    const auto& declarationModifiers = m_information->m_member->m_type_declaration->m_declaration_modifiers;
+    if (m_modifier_indices.size() < declarationModifiers.size())
+        return declarationModifiers[m_modifier_indices.size()].get();
+
+    return nullptr;
+}
+
+DeclarationModifier* DeclarationModifierComputations::GetNextDeclarationModifier() const
+{
+    const auto& declarationModifiers = m_information->m_member->m_type_declaration->m_declaration_modifiers;
+    if (m_modifier_indices.size() + 1 < declarationModifiers.size())
+        return declarationModifiers[m_modifier_indices.size() + 1].get();
+
+    return nullptr;
+}
+
+std::vector<DeclarationModifier*> DeclarationModifierComputations::GetFollowingDeclarationModifiers() const
+{
+    std::vector<DeclarationModifier*> following;
+    const auto& declarationModifiers = m_information->m_member->m_type_declaration->m_declaration_modifiers;
+
+    if (m_modifier_indices.size() + 1 < declarationModifiers.size())
+    {
+        for (auto i = declarationModifiers.begin() + m_modifier_indices.size() + 1; i != declarationModifiers.end(); ++i)
+        {
+            following.push_back(i->get());
+        }
+    }
+
+    return following;
+}
+
+std::vector<int> DeclarationModifierComputations::GetArrayIndices() const
+{
+    return m_modifier_indices;
+}
+
+bool DeclarationModifierComputations::IsArray() const
+{
+    auto* declarationModifier = GetDeclarationModifier();
+    return declarationModifier != nullptr && declarationModifier->GetType() == DeclarationModifierType::ARRAY;
+}
+
+int DeclarationModifierComputations::GetArraySize() const
+{
+    auto* declarationModifier = GetDeclarationModifier();
+    if (declarationModifier != nullptr && declarationModifier->GetType() == DeclarationModifierType::ARRAY)
+    {
+        return dynamic_cast<ArrayDeclarationModifier*>(declarationModifier)->m_size;
+    }
+
+    return 0;
+}
+
+bool DeclarationModifierComputations::HasDynamicArrayCount() const
+{
+    auto* declarationModifier = GetDeclarationModifier();
+    if (declarationModifier != nullptr && declarationModifier->GetType() == DeclarationModifierType::ARRAY)
+    {
+        return dynamic_cast<ArrayDeclarationModifier*>(declarationModifier)->m_dynamic_count_evaluation != nullptr;
+    }
+
+    return false;
+}
+
+const IEvaluation* DeclarationModifierComputations::GetDynamicArrayCountEvaluation() const
+{
+    auto* declarationModifier = GetDeclarationModifier();
+    if (declarationModifier != nullptr && declarationModifier->GetType() == DeclarationModifierType::ARRAY)
+    {
+        return dynamic_cast<ArrayDeclarationModifier*>(declarationModifier)->m_dynamic_count_evaluation.get();
+    }
+
+    return nullptr;
+}
+
+std::vector<DeclarationModifierComputations> DeclarationModifierComputations::GetArrayEntries() const
+{
+    std::vector<DeclarationModifierComputations> arrayEntries;
+
+    const auto arraySize = GetArraySize();
+    for (auto i = 0; i < arraySize; i++)
+    {
+        std::vector<int> childModifierIndices(m_modifier_indices.size() + 1);
+        std::copy(m_modifier_indices.begin(), m_modifier_indices.end(), childModifierIndices.begin());
+        childModifierIndices[childModifierIndices.size() - 1] = i;
+        arrayEntries.push_back(DeclarationModifierComputations(m_information, std::move(childModifierIndices)));
+    }
+
+    return arrayEntries;
+}
+
+bool DeclarationModifierComputations::IsSinglePointer() const
+{
+    auto* declarationModifier = GetDeclarationModifier();
+
+    if (declarationModifier != nullptr
+        && declarationModifier->GetType() == DeclarationModifierType::POINTER
+        && !dynamic_cast<PointerDeclarationModifier*>(declarationModifier)->CountEvaluationIsArray(m_combined_index))
+    {
+        const auto following = GetFollowingDeclarationModifiers();
+
+        return !std::any_of(following.begin(), following.end(), [](const DeclarationModifier* modifier)
+        {
+            return modifier->GetType() == DeclarationModifierType::POINTER;
+        });
+    }
+
+    return false;
+}
+
+bool DeclarationModifierComputations::IsArrayPointer() const
+{
+    auto* declarationModifier = GetDeclarationModifier();
+
+    if (declarationModifier != nullptr
+        && declarationModifier->GetType() == DeclarationModifierType::POINTER
+        && dynamic_cast<PointerDeclarationModifier*>(declarationModifier)->CountEvaluationIsArray(m_combined_index))
+    {
+        const auto following = GetFollowingDeclarationModifiers();
+
+        return !std::any_of(following.begin(), following.end(), [](const DeclarationModifier* modifier)
+        {
+            return modifier->GetType() == DeclarationModifierType::POINTER;
+        });
+    }
+
+    return false;
+}
+
+const IEvaluation* DeclarationModifierComputations::GetArrayPointerCountEvaluation() const
+{
+    auto* declarationModifier = GetDeclarationModifier();
+    if (declarationModifier == nullptr || declarationModifier->GetType() != DeclarationModifierType::POINTER)
+        return nullptr;
+
+    return dynamic_cast<PointerDeclarationModifier*>(declarationModifier)->GetCountEvaluationForArrayIndex(m_combined_index);
+}
+
+bool DeclarationModifierComputations::IsPointerArray() const
+{
+    auto* declarationModifier = GetDeclarationModifier();
+    if (declarationModifier == nullptr)
+        return false;
+
+    auto* nextDeclarationModifier = GetNextDeclarationModifier();
+    if (nextDeclarationModifier == nullptr)
+        return false;
+
+    const auto thisDeclModIsArray = declarationModifier->GetType() == DeclarationModifierType::POINTER
+        && dynamic_cast<PointerDeclarationModifier*>(declarationModifier)->CountEvaluationIsArray(m_combined_index)
+        || declarationModifier->GetType() == DeclarationModifierType::ARRAY;
+
+    if (!thisDeclModIsArray)
+        return false;
+
+    const auto nextDeclModIsSinglePointer = nextDeclarationModifier->GetType() == DeclarationModifierType::POINTER
+        && !dynamic_cast<PointerDeclarationModifier*>(nextDeclarationModifier)->AnyCountEvaluationIsArray();
+
+    return nextDeclModIsSinglePointer;
+}
+
+const IEvaluation* DeclarationModifierComputations::GetPointerArrayCountEvaluation() const
+{
+    auto* declarationModifier = GetDeclarationModifier();
+    if (declarationModifier == nullptr)
+        return nullptr;
+
+    if (declarationModifier->GetType() == DeclarationModifierType::POINTER)
+    {
+        return dynamic_cast<PointerDeclarationModifier*>(declarationModifier)->GetCountEvaluationForArrayIndex(m_combined_index);
+    }
+
+    if (declarationModifier->GetType() == DeclarationModifierType::ARRAY)
+    {
+        auto* arrayDeclarationModifier = dynamic_cast<ArrayDeclarationModifier*>(declarationModifier);
+        return arrayDeclarationModifier->m_dynamic_count_evaluation.get(); // This might be null in which case there is no evaluation but a static size
+    }
+
+    assert(false);
+    return nullptr;
+}
+
+bool DeclarationModifierComputations::IsDynamicArray() const
+{
+    auto* declarationModifier = GetDeclarationModifier();
+    if (declarationModifier == nullptr)
+        return false;
+
+    return declarationModifier->GetType() == DeclarationModifierType::ARRAY
+        && dynamic_cast<ArrayDeclarationModifier*>(declarationModifier)->m_dynamic_size_evaluation != nullptr;
+}
+
+const IEvaluation* DeclarationModifierComputations::GetDynamicArraySizeEvaluation() const
+{
+    auto* declarationModifier = GetDeclarationModifier();
+    if (declarationModifier == nullptr
+        || declarationModifier->GetType() != DeclarationModifierType::ARRAY)
+        return nullptr;
+
+    return dynamic_cast<ArrayDeclarationModifier*>(declarationModifier)->m_dynamic_size_evaluation.get();
+}

src/ZoneCodeGeneratorNew/Domain/Computations/MemberDeclarationModifierComputations.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "Utils/ClassUtils.h"
+#include "Domain/Information/MemberInformation.h"
+#include "Domain/Evaluation/IEvaluation.h"
+
+class DeclarationModifierComputations
+{
+    const MemberInformation* const m_information;
+    std::vector<int> m_modifier_indices;
+    int m_combined_index;
+
+    DeclarationModifierComputations(const MemberInformation* member, std::vector<int> modifierIndices);
+
+public:
+    explicit DeclarationModifierComputations(const MemberInformation* member);
+
+    _NODISCARD DeclarationModifier* GetDeclarationModifier() const;
+    _NODISCARD DeclarationModifier* GetNextDeclarationModifier() const;
+    _NODISCARD std::vector<DeclarationModifier*> GetFollowingDeclarationModifiers() const;
+    _NODISCARD std::vector<int> GetArrayIndices() const;
+    _NODISCARD bool IsArray() const;
+    _NODISCARD int GetArraySize() const;
+    _NODISCARD bool HasDynamicArrayCount() const;
+    _NODISCARD const IEvaluation* GetDynamicArrayCountEvaluation() const;
+    _NODISCARD std::vector<DeclarationModifierComputations> GetArrayEntries() const;
+    _NODISCARD bool IsSinglePointer() const;
+    _NODISCARD bool IsArrayPointer() const;
+    _NODISCARD const IEvaluation* GetArrayPointerCountEvaluation() const;
+    _NODISCARD bool IsPointerArray() const;
+    _NODISCARD const IEvaluation* GetPointerArrayCountEvaluation() const;
+    _NODISCARD bool IsDynamicArray() const;
+    _NODISCARD const IEvaluation* GetDynamicArraySizeEvaluation() const;
+};

src/ZoneCodeGeneratorNew/Domain/Computations/StructureComputations.cpp

@@ -0,0 +1,51 @@
+#include "StructureComputations.h"
+
+#include <cassert>
+
+#include "MemberComputations.h"
+
+StructureComputations::StructureComputations(const StructureInformation* structure)
+    : m_info(structure)
+{
+    assert(m_info != nullptr);
+}
+
+bool StructureComputations::IsAsset() const
+{
+    return m_info->m_asset_enum_entry != nullptr;
+}
+
+MemberInformation* StructureComputations::GetDynamicMember() const
+{
+    for (const auto& member : m_info->m_ordered_members)
+    {
+        if (MemberComputations(member.get()).IsDynamicMember())
+            return member.get();
+    }
+
+    return nullptr;
+}
+
+std::vector<MemberInformation*> StructureComputations::GetUsedMembers() const
+{
+    std::vector<MemberInformation*> members;
+
+    if (m_info->m_definition->GetType() == DataDefinitionType::UNION && GetDynamicMember() != nullptr)
+    {
+        for (const auto& member : m_info->m_ordered_members)
+        {
+            if (!MemberComputations(member.get()).ShouldIgnore())
+                members.push_back(member.get());
+        }
+    }
+    else
+    {
+        for (const auto& member : m_info->m_ordered_members)
+        {
+            if (!member->m_is_leaf && !MemberComputations(member.get()).ShouldIgnore())
+                members.push_back(member.get());
+        }
+    }
+
+    return members;
+}

src/ZoneCodeGeneratorNew/Domain/Computations/StructureComputations.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "Domain/Information/StructureInformation.h"
+
+class StructureComputations
+{
+    const StructureInformation* const m_info;
+
+public:
+    explicit StructureComputations(const StructureInformation* structure);
+
+    _NODISCARD bool IsAsset() const;
+    _NODISCARD MemberInformation* GetDynamicMember() const;
+    _NODISCARD std::vector<MemberInformation*> GetUsedMembers() const;
+};

src/ZoneCodeGeneratorNew/Domain/Definition/ArrayDeclarationModifier.cpp

@@ -1,6 +1,6 @@
 #include "ArrayDeclarationModifier.h"
 
-DeclarationModifierType ArrayDeclarationModifier::GetType()
+DeclarationModifierType ArrayDeclarationModifier::GetType() const
 {
     return DeclarationModifierType::ARRAY;
 }

src/ZoneCodeGeneratorNew/Domain/Definition/ArrayDeclarationModifier.h

@@ -20,5 +20,5 @@ public:
      */
     std::unique_ptr<IEvaluation> m_dynamic_count_evaluation;
 
-    DeclarationModifierType GetType() override;
+    DeclarationModifierType GetType() const override;
 };

src/ZoneCodeGeneratorNew/Domain/Definition/BaseTypeDefinition.cpp

@@ -11,17 +11,32 @@ DataDefinitionType BaseTypeDefinition::GetType() const
     return DataDefinitionType::BASE_TYPE;
 }
 
-unsigned BaseTypeDefinition::GetAlignment() const
+unsigned BaseTypeDefinition::GetAlignment()
 {
     // Since this type has no members the alignment is always equal to the size.
     return m_size;
 }
 
+unsigned BaseTypeDefinition::GetAlignment() const
+{
+    return m_size;
+}
+
+bool BaseTypeDefinition::GetForceAlignment()
+{
+    return false;
+}
+
 bool BaseTypeDefinition::GetForceAlignment() const
 {
     return false;
 }
 
+unsigned BaseTypeDefinition::GetSize()
+{
+    return m_size;
+}
+
 unsigned BaseTypeDefinition::GetSize() const
 {
     return m_size;

src/ZoneCodeGeneratorNew/Domain/Definition/BaseTypeDefinition.h

@@ -11,9 +11,12 @@ private:
 
 public:
     _NODISCARD DataDefinitionType GetType() const override;
-    _NODISCARD unsigned GetAlignment() const override;
-    _NODISCARD bool GetForceAlignment() const override;
-    _NODISCARD unsigned GetSize() const override;
+    _NODISCARD unsigned GetAlignment() override;
+    _NODISCARD unsigned GetAlignment() const;
+    _NODISCARD bool GetForceAlignment() override;
+    _NODISCARD bool GetForceAlignment() const;
+    _NODISCARD unsigned GetSize() override;
+    _NODISCARD unsigned GetSize() const;
 
     static const BaseTypeDefinition* const FLOAT;
     static const BaseTypeDefinition* const DOUBLE;

src/ZoneCodeGeneratorNew/Domain/Definition/DataDefinition.h

@@ -28,10 +28,10 @@ public:
     std::string m_namespace;
     std::string m_name;
     
-    _NO_DISCARD virtual DataDefinitionType GetType() const = 0;
-    _NO_DISCARD virtual unsigned GetAlignment() = 0;
-    _NO_DISCARD virtual bool GetForceAlignment() = 0;
-    _NO_DISCARD virtual unsigned GetSize() = 0;
+    _NODISCARD virtual DataDefinitionType GetType() const = 0;
+    _NODISCARD virtual unsigned GetAlignment() = 0;
+    _NODISCARD virtual bool GetForceAlignment() = 0;
+    _NODISCARD virtual unsigned GetSize() = 0;
 
-    _NO_DISCARD std::string GetFullName() const;
+    _NODISCARD std::string GetFullName() const;
 };

src/ZoneCodeGeneratorNew/Domain/Definition/DeclarationModifier.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "Utils/ClassUtils.h"
+
 enum class DeclarationModifierType
 {
     POINTER,
@@ -12,5 +14,5 @@ public:
     DeclarationModifier() = default;
     virtual ~DeclarationModifier() = default;
 
-    virtual DeclarationModifierType GetType() = 0;
+    _NODISCARD virtual DeclarationModifierType GetType() const = 0;
 };

src/ZoneCodeGeneratorNew/Domain/Definition/EnumDefinition.cpp

@@ -14,17 +14,17 @@ DataDefinitionType EnumDefinition::GetType() const
     return DataDefinitionType::ENUM;
 }
 
-unsigned EnumDefinition::GetAlignment() const
+unsigned EnumDefinition::GetAlignment()
 {
     return m_parent_type->GetAlignment();
 }
 
-bool EnumDefinition::GetForceAlignment() const
+bool EnumDefinition::GetForceAlignment()
 {
     return m_parent_type->GetForceAlignment();
 }
 
-unsigned EnumDefinition::GetSize() const
+unsigned EnumDefinition::GetSize()
 {
     return m_parent_type->GetSize();
 }

src/ZoneCodeGeneratorNew/Domain/Definition/EnumDefinition.h

@@ -16,9 +16,9 @@ public:
     EnumDefinition(std::string _namespace, std::string name, const BaseTypeDefinition* parentType);
 
     _NODISCARD DataDefinitionType GetType() const override;
-    _NODISCARD unsigned GetAlignment() const override;
-    _NODISCARD bool GetForceAlignment() const override;
-    _NODISCARD unsigned GetSize() const override;
+    _NODISCARD unsigned GetAlignment() override;
+    _NODISCARD bool GetForceAlignment() override;
+    _NODISCARD unsigned GetSize() override;
 
     void AddEnumMember(EnumMember enumMember);
 };

src/ZoneCodeGeneratorNew/Domain/Definition/ForwardDeclaration.cpp

@@ -12,17 +12,17 @@ DataDefinitionType ForwardDeclaration::GetType() const
     return DataDefinitionType::FORWARD_DECLARATION;
 }
 
-unsigned ForwardDeclaration::GetAlignment() const
+unsigned ForwardDeclaration::GetAlignment()
 {
     return 0;
 }
 
-bool ForwardDeclaration::GetForceAlignment() const
+bool ForwardDeclaration::GetForceAlignment()
 {
     return false;
 }
 
-unsigned ForwardDeclaration::GetSize() const
+unsigned ForwardDeclaration::GetSize()
 {
     return 0;
 }

src/ZoneCodeGeneratorNew/Domain/Definition/ForwardDeclaration.h

@@ -11,7 +11,7 @@ public:
     ForwardDeclaration(std::string _namespace, std::string name, DataDefinitionType type);
 
     _NODISCARD DataDefinitionType GetType() const override;
-    _NODISCARD unsigned GetAlignment() const override;
-    _NODISCARD bool GetForceAlignment() const override;
-    _NODISCARD unsigned GetSize() const override;
+    _NODISCARD unsigned GetAlignment() override;
+    _NODISCARD bool GetForceAlignment() override;
+    _NODISCARD unsigned GetSize() override;
 };

src/ZoneCodeGeneratorNew/Domain/Definition/PointerDeclarationModifier.cpp

@@ -1,6 +1,72 @@
 #include "PointerDeclarationModifier.h"
 
-DeclarationModifierType PointerDeclarationModifier::GetType()
+#include "Domain/Evaluation/OperandStatic.h"
+
+const IEvaluation* const PointerDeclarationModifier::DEFAULT_COUNT = new OperandStatic(1);
+
+DeclarationModifierType PointerDeclarationModifier::GetType() const
 {
     return DeclarationModifierType::POINTER;
 }
+
+const IEvaluation* PointerDeclarationModifier::GetCountEvaluation() const
+{
+    if (m_count_evaluation)
+        return m_count_evaluation.get();
+
+    return DEFAULT_COUNT;
+}
+
+const IEvaluation* PointerDeclarationModifier::GetCountEvaluationForArrayIndex(const int index)
+{
+    if (index >= 0 && m_count_evaluation_by_array_index.size() > static_cast<unsigned>(index))
+    {
+        return m_count_evaluation_by_array_index[index].get();
+    }
+
+    if (m_count_evaluation)
+    {
+        return m_count_evaluation.get();
+    }
+
+    return DEFAULT_COUNT;
+}
+
+bool PointerDeclarationModifier::EvaluationIsArray(const IEvaluation* evaluation)
+{
+    return !evaluation->IsStatic() || evaluation->EvaluateNumeric() > 1;
+}
+
+bool PointerDeclarationModifier::CountEvaluationIsArray() const
+{
+    if (m_count_evaluation)
+    {
+        return EvaluationIsArray(m_count_evaluation.get());
+    }
+
+    return EvaluationIsArray(DEFAULT_COUNT);
+}
+
+bool PointerDeclarationModifier::CountEvaluationIsArray(const int index) const
+{
+    if(index >= 0 && m_count_evaluation_by_array_index.size() > static_cast<unsigned>(index))
+    {
+        return EvaluationIsArray(m_count_evaluation_by_array_index[index].get());
+    }
+
+    return CountEvaluationIsArray();
+}
+
+bool PointerDeclarationModifier::AnyCountEvaluationIsArray() const
+{
+    if (m_count_evaluation && EvaluationIsArray(m_count_evaluation.get()))
+        return true;
+
+    for(const auto& arrayCountEvaluation : m_count_evaluation_by_array_index)
+    {
+        if (EvaluationIsArray(arrayCountEvaluation.get()))
+            return true;
+    }
+
+    return EvaluationIsArray(DEFAULT_COUNT);
+}

src/ZoneCodeGeneratorNew/Domain/Definition/PointerDeclarationModifier.h

@@ -1,8 +1,26 @@
 #pragma once
+
+#include <memory>
+#include <vector>
+
 #include "DeclarationModifier.h"
+#include "Domain/Evaluation/IEvaluation.h"
 
 class PointerDeclarationModifier final : public DeclarationModifier
 {
+    static const IEvaluation* const DEFAULT_COUNT;
+
+    static bool EvaluationIsArray(const IEvaluation* evaluation);
+
 public:
-    DeclarationModifierType GetType() override;
+    std::unique_ptr<IEvaluation> m_count_evaluation;
+    std::vector<std::unique_ptr<IEvaluation>> m_count_evaluation_by_array_index;
+
+    _NODISCARD DeclarationModifierType GetType() const override;
+    _NODISCARD const IEvaluation* GetCountEvaluation() const;
+    _NODISCARD const IEvaluation* GetCountEvaluationForArrayIndex(int index);
+
+    _NODISCARD bool CountEvaluationIsArray() const;
+    _NODISCARD bool CountEvaluationIsArray(int index) const;
+    _NODISCARD bool AnyCountEvaluationIsArray() const;
 };

src/ZoneCodeGeneratorNew/Domain/Evaluation/IEvaluation.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "Utils/ClassUtils.h"
+
 enum class EvaluationType
 {
     OPERAND_DYNAMIC,
@@ -18,7 +20,7 @@ public:
     IEvaluation& operator=(const IEvaluation& other) = default;
     IEvaluation& operator=(IEvaluation&& other) noexcept = default;
 
-    virtual EvaluationType GetType() = 0;
-    virtual bool IsStatic() = 0;
-    virtual int EvaluateNumeric() = 0;
+    _NODISCARD virtual EvaluationType GetType() const = 0;
+    _NODISCARD virtual bool IsStatic() const = 0;
+    _NODISCARD virtual int EvaluateNumeric() const = 0;
 };

src/ZoneCodeGeneratorNew/Domain/Evaluation/OperandDynamic.cpp

@@ -7,17 +7,17 @@ OperandDynamic::OperandDynamic(StructureInformation* structure)
 {
 }
 
-EvaluationType OperandDynamic::GetType()
+EvaluationType OperandDynamic::GetType() const
 {
     return EvaluationType::OPERAND_DYNAMIC;
 }
 
-bool OperandDynamic::IsStatic()
+bool OperandDynamic::IsStatic() const
 {
     return false;
 }
 
-int OperandDynamic::EvaluateNumeric()
+int OperandDynamic::EvaluateNumeric() const
 {
     assert(false);
     return 0;

src/ZoneCodeGeneratorNew/Domain/Evaluation/OperandDynamic.h

@@ -15,7 +15,7 @@ public:
 
     explicit OperandDynamic(StructureInformation* structure);
 
-    EvaluationType GetType() override;
-    bool IsStatic() override;
-    int EvaluateNumeric() override;
+    _NODISCARD EvaluationType GetType() const override;
+    _NODISCARD bool IsStatic() const override;
+    _NODISCARD int EvaluateNumeric() const override;
 };

src/ZoneCodeGeneratorNew/Domain/Evaluation/OperandStatic.cpp

@@ -12,17 +12,17 @@ OperandStatic::OperandStatic(const int value, EnumMember* enumMember)
 {
 }
 
-EvaluationType OperandStatic::GetType()
+EvaluationType OperandStatic::GetType() const
 {
     return EvaluationType::OPERAND_STATIC;
 }
 
-bool OperandStatic::IsStatic()
+bool OperandStatic::IsStatic() const
 {
     return true;
 }
 
-int OperandStatic::EvaluateNumeric()
+int OperandStatic::EvaluateNumeric() const
 {
     return m_value;
 }

src/ZoneCodeGeneratorNew/Domain/Evaluation/OperandStatic.h

@@ -12,7 +12,7 @@ public:
     explicit OperandStatic(int value);
     OperandStatic(int value, EnumMember* enumMember);
 
-    EvaluationType GetType() override;
-    bool IsStatic() override;
-    int EvaluateNumeric() override;
+    _NODISCARD EvaluationType GetType() const override;
+    _NODISCARD bool IsStatic() const override;
+    _NODISCARD int EvaluateNumeric() const override;
 };

src/ZoneCodeGeneratorNew/Domain/Evaluation/Operation.cpp

@@ -5,17 +5,17 @@ Operation::Operation(const OperationType* type)
 {
 }
 
-EvaluationType Operation::GetType()
+EvaluationType Operation::GetType() const
 {
     return EvaluationType::OPERATION;
 }
 
-bool Operation::IsStatic()
+bool Operation::IsStatic() const
 {
     return m_operand1->IsStatic() && m_operand2->IsStatic();
 }
 
-int Operation::EvaluateNumeric()
+int Operation::EvaluateNumeric() const
 {
     return m_operation_type->m_evaluation_function(m_operand1->EvaluateNumeric(), m_operand2->EvaluateNumeric());
 }

src/ZoneCodeGeneratorNew/Domain/Evaluation/Operation.h

@@ -15,9 +15,9 @@ public:
 
     explicit Operation(const OperationType* type);
 
-    EvaluationType GetType() override;
-    bool IsStatic() override;
-    int EvaluateNumeric() override;
+    _NODISCARD EvaluationType GetType() const override;
+    _NODISCARD bool IsStatic() const override;
+    _NODISCARD int EvaluateNumeric() const override;
 
     _NODISCARD bool Operand1NeedsParenthesis() const;
     _NODISCARD bool Operand2NeedsParenthesis() const;

src/ZoneCodeGeneratorNew/Domain/Extension/CustomAction.cpp

@@ -0,0 +1,6 @@
+#include "CustomAction.h"
+
+CustomAction::CustomAction(std::string actionName)
+    : m_action_name(std::move(actionName))
+{
+}

src/ZoneCodeGeneratorNew/Domain/Extension/CustomAction.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "Domain/Definition/DataDefinition.h"
+
+class CustomAction
+{
+public:
+    std::string m_action_name;
+    std::vector<DataDefinition*> m_parameter_types;
+
+    explicit CustomAction(std::string actionName);
+};

src/ZoneCodeGeneratorNew/Domain/Information/MemberInformation.cpp

@@ -0,0 +1,13 @@
+#include "MemberInformation.h"
+
+MemberInformation::MemberInformation(StructureInformation* parent, StructureInformation* type, Variable* member)
+    : m_parent(parent),
+      m_type(type),
+      m_member(member),
+      m_is_string(false),
+      m_is_script_string(false),
+      m_is_reusable(false),
+      m_is_leaf(false),
+      m_fast_file_block(nullptr)
+{
+}

src/ZoneCodeGeneratorNew/Domain/Information/MemberInformation.h

@@ -1,6 +1,26 @@
 #pragma once
 
+#include <memory>
+
+#include "Utils/ClassUtils.h"
+#include "StructureInformation.h"
+#include "Domain/Definition/Variable.h"
+#include "Domain/FastFile/FastFileBlock.h"
+#include "Domain/Evaluation/IEvaluation.h"
+
+class StructureInformation;
 class MemberInformation
 {
+public:
+    StructureInformation* m_parent;
+    StructureInformation* m_type;
+    Variable* m_member;
+    bool m_is_string;
+    bool m_is_script_string;
+    bool m_is_reusable;
+    bool m_is_leaf;
+    std::unique_ptr<IEvaluation> m_condition;
+    FastFileBlock* m_fast_file_block;
 
+    MemberInformation(StructureInformation* parent, StructureInformation* type, Variable* member);
 };

src/ZoneCodeGeneratorNew/Domain/Information/StructureInformation.cpp

@@ -0,0 +1,17 @@
+#include "StructureInformation.h"
+
+StructureInformation::StructureInformation(DefinitionWithMembers* definition)
+    : m_has_non_default_fast_file_align(false),
+      m_custom_fast_file_align(0),
+      m_definition(definition),
+      m_asset_enum_entry(nullptr),
+      m_is_leaf(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_post_load_action(nullptr),
+      m_block(nullptr)
+{
+}

src/ZoneCodeGeneratorNew/Domain/Information/StructureInformation.h

@@ -1,6 +1,36 @@
 #pragma once
 
+#include "Utils/ClassUtils.h"
+#include "MemberInformation.h"
+#include "Domain/Definition/DefinitionWithMembers.h"
+#include "Domain/Definition/EnumMember.h"
+#include "Domain/Extension/CustomAction.h"
+#include "Domain/FastFile/FastFileBlock.h"
+
+class MemberInformation;
 class StructureInformation
 {
+public:
+    bool m_has_non_default_fast_file_align;
+    unsigned m_custom_fast_file_align;
 
+    DefinitionWithMembers* const m_definition;
+    EnumMember* m_asset_enum_entry;
+
+    std::vector<StructureInformation*> m_usages;
+    std::vector<std::unique_ptr<MemberInformation>> m_ordered_members;
+
+    bool m_is_leaf;
+
+    bool m_non_embedded_reference_exists;
+    bool m_single_pointer_reference_exists;
+    bool m_array_pointer_reference_exists;
+    bool m_array_reference_exists;
+    bool m_reference_from_non_default_normal_block_exists;
+
+    std::unique_ptr<CustomAction> m_post_load_action;
+    FastFileBlock* m_block;
+    std::vector<MemberInformation*> m_name_chain;
+
+    explicit StructureInformation(DefinitionWithMembers* definition);
 };

src/ZoneCodeGeneratorNew/Persistence/IDataRepository.h

@@ -1,6 +1,10 @@
 #pragma once
+
 #include <vector>
 
+#include "Utils/ClassUtils.h"
+#include "Domain/Definition/EnumDefinition.h"
+
 class IDataRepository
 {
 public:
@@ -14,5 +18,10 @@ public:
         IEnumerable<StructureInformation> GetAllStructureInformation();
         IEnumerable<FastFileBlock> GetAllFastFileBlocks();
      */
-    const std::vector<>& 
+    _NODISCARD const std::vector<EnumDefinition*>& GetAllEnums() const;
+    _NODISCARD const std::vector<EnumDefinition*>& GetAllStructs() const;
+    _NODISCARD const std::vector<EnumDefinition*>& GetAllUnions() const;
+    _NODISCARD const std::vector<EnumDefinition*>& GetAllTypedefs() const;
+    _NODISCARD const std::vector<EnumDefinition*>& GetAllStructureInformation() const;
+    _NODISCARD const std::vector<EnumDefinition*>& GetAllFastFileBlocks() const;
 };