refactor: support multiple variants for games in zonecode

src/ZoneCodeGeneratorLib/Domain/Computations/MemberDeclarationModifierComputations.cpp

@@ -263,7 +263,7 @@ bool DeclarationModifierComputations::HasPointerModifier() const
                                });
 }
 
-unsigned DeclarationModifierComputations::GetAlignment() const
+unsigned DeclarationModifierComputations::GetAlignment(const WordSize wordSize) const
 {
     const auto following = GetFollowingDeclarationModifiers();
 
@@ -272,6 +272,6 @@ unsigned DeclarationModifierComputations::GetAlignment() const
                                {
                                    return modifier->GetType() == DeclarationModifierType::POINTER;
                                })
-               ? m_information->m_member->GetAlignment()
-               : m_information->m_member->m_type_declaration->m_type->GetAlignment();
+               ? m_information->m_member->GetAlignment(wordSize)
+               : m_information->m_member->m_type_declaration->m_type->GetAlignment(wordSize);
 }

src/ZoneCodeGeneratorLib/Domain/Computations/MemberDeclarationModifierComputations.h

@@ -28,7 +28,7 @@ public:
     [[nodiscard]] bool IsDynamicArray() const;
     [[nodiscard]] const IEvaluation* GetDynamicArraySizeEvaluation() const;
     [[nodiscard]] bool HasPointerModifier() const;
-    [[nodiscard]] unsigned GetAlignment() const;
+    [[nodiscard]] unsigned GetAlignment(WordSize wordSize) const;
 
 private:
     DeclarationModifierComputations(const MemberInformation* member, std::vector<int> modifierIndices);

src/ZoneCodeGeneratorLib/Domain/Definition/BaseTypeDefinition.cpp

@@ -13,7 +13,7 @@ DataDefinitionType BaseTypeDefinition::GetType() const
     return DataDefinitionType::BASE_TYPE;
 }
 
-unsigned BaseTypeDefinition::GetAlignment() const
+unsigned BaseTypeDefinition::GetAlignment(const WordSize wordSize) const
 {
     return m_size;
 }
@@ -23,7 +23,7 @@ bool BaseTypeDefinition::GetForceAlignment() const
     return false;
 }
 
-unsigned BaseTypeDefinition::GetSize() const
+unsigned BaseTypeDefinition::GetSize(const WordSize wordSize) const
 {
     return m_size;
 }

src/ZoneCodeGeneratorLib/Domain/Definition/BaseTypeDefinition.h

@@ -23,9 +23,9 @@ public:
     static const size_t ALL_BASE_TYPES_COUNT;
 
     [[nodiscard]] DataDefinitionType GetType() const override;
-    [[nodiscard]] unsigned GetAlignment() const override;
+    [[nodiscard]] unsigned GetAlignment(WordSize wordSize) const override;
     [[nodiscard]] bool GetForceAlignment() const override;
-    [[nodiscard]] unsigned GetSize() const override;
+    [[nodiscard]] unsigned GetSize(WordSize wordSize) const override;
 
     const unsigned m_size;
 

src/ZoneCodeGeneratorLib/Domain/Definition/DataDefinition.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "Domain/WordSize.h"
+
 #include <string>
 
 enum class DataDefinitionType
@@ -25,9 +27,9 @@ public:
     DataDefinition& operator=(DataDefinition&& other) noexcept = default;
 
     [[nodiscard]] virtual DataDefinitionType GetType() const = 0;
-    [[nodiscard]] virtual unsigned GetAlignment() const = 0;
+    [[nodiscard]] virtual unsigned GetAlignment(WordSize wordSize) const = 0;
     [[nodiscard]] virtual bool GetForceAlignment() const = 0;
-    [[nodiscard]] virtual unsigned GetSize() const = 0;
+    [[nodiscard]] virtual unsigned GetSize(WordSize wordSize) const = 0;
 
     [[nodiscard]] std::string GetFullName() const;
 

src/ZoneCodeGeneratorLib/Domain/Definition/DefinitionWithMembers.cpp

@@ -11,11 +11,11 @@ DefinitionWithMembers::DefinitionWithMembers(std::string _namespace, std::string
 {
 }
 
-unsigned DefinitionWithMembers::GetAlignment() const
+unsigned DefinitionWithMembers::GetAlignment(const WordSize wordSize) const
 {
     assert(m_flags & FLAG_FIELDS_CALCULATED);
 
-    return m_alignment;
+    return m_alignment[std::to_underlying(wordSize)];
 }
 
 bool DefinitionWithMembers::GetForceAlignment() const
@@ -23,11 +23,11 @@ bool DefinitionWithMembers::GetForceAlignment() const
     return m_flags & FLAG_ALIGNMENT_FORCED;
 }
 
-unsigned DefinitionWithMembers::GetSize() const
+unsigned DefinitionWithMembers::GetSize(const WordSize wordSize) const
 {
     assert(m_flags & FLAG_FIELDS_CALCULATED);
 
-    return m_size;
+    return m_size[std::to_underlying(wordSize)];
 }
 
 bool DefinitionWithMembers::IsAnonymous() const

src/ZoneCodeGeneratorLib/Domain/Definition/DefinitionWithMembers.h

@@ -16,14 +16,14 @@ public:
 
     DefinitionWithMembers(std::string _namespace, std::string name, unsigned pack);
 
-    [[nodiscard]] unsigned GetAlignment() const override;
+    [[nodiscard]] unsigned GetAlignment(WordSize wordSize) const override;
     [[nodiscard]] bool GetForceAlignment() const override;
-    [[nodiscard]] unsigned GetSize() const override;
+    [[nodiscard]] unsigned GetSize(WordSize wordSize) const override;
     [[nodiscard]] bool IsAnonymous() const;
 
     unsigned m_flags;
-    unsigned m_size;
-    unsigned m_alignment;
+    unsigned m_size[WORD_SIZE_COUNT];
+    unsigned m_alignment[WORD_SIZE_COUNT];
     unsigned m_pack;
 
     std::vector<std::shared_ptr<Variable>> m_members;

src/ZoneCodeGeneratorLib/Domain/Definition/EnumDefinition.cpp

@@ -14,9 +14,9 @@ DataDefinitionType EnumDefinition::GetType() const
     return DataDefinitionType::ENUM;
 }
 
-unsigned EnumDefinition::GetAlignment() const
+unsigned EnumDefinition::GetAlignment(const WordSize wordSize) const
 {
-    return m_parent_type->GetAlignment();
+    return m_parent_type->GetAlignment(wordSize);
 }
 
 bool EnumDefinition::GetForceAlignment() const
@@ -24,9 +24,9 @@ bool EnumDefinition::GetForceAlignment() const
     return m_parent_type->GetForceAlignment();
 }
 
-unsigned EnumDefinition::GetSize() const
+unsigned EnumDefinition::GetSize(const WordSize wordSize) const
 {
-    return m_parent_type->GetSize();
+    return m_parent_type->GetSize(wordSize);
 }
 
 void EnumDefinition::AddEnumMember(EnumMember enumMember)

src/ZoneCodeGeneratorLib/Domain/Definition/EnumDefinition.h

@@ -13,9 +13,9 @@ public:
     EnumDefinition(std::string _namespace, std::string name, const BaseTypeDefinition* parentType);
 
     [[nodiscard]] DataDefinitionType GetType() const override;
-    [[nodiscard]] unsigned GetAlignment() const override;
+    [[nodiscard]] unsigned GetAlignment(WordSize wordSize) const override;
     [[nodiscard]] bool GetForceAlignment() const override;
-    [[nodiscard]] unsigned GetSize() const override;
+    [[nodiscard]] unsigned GetSize(WordSize wordSize) const override;
 
     void AddEnumMember(EnumMember enumMember);
 

src/ZoneCodeGeneratorLib/Domain/Definition/ForwardDeclaration.cpp

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

src/ZoneCodeGeneratorLib/Domain/Definition/ForwardDeclaration.h

@@ -8,9 +8,9 @@ public:
     ForwardDeclaration(std::string _namespace, std::string name, DataDefinitionType type);
 
     [[nodiscard]] DataDefinitionType GetType() const override;
-    [[nodiscard]] unsigned GetAlignment() const override;
+    [[nodiscard]] unsigned GetAlignment(WordSize wordSize) const override;
     [[nodiscard]] bool GetForceAlignment() const override;
-    [[nodiscard]] unsigned GetSize() const override;
+    [[nodiscard]] unsigned GetSize(WordSize wordSize) const override;
 
     const DataDefinitionType m_forwarded_type;
     const DataDefinition* m_definition;

src/ZoneCodeGeneratorLib/Domain/Definition/TypeDeclaration.cpp

@@ -10,22 +10,22 @@ TypeDeclaration::TypeDeclaration(const DataDefinition* type)
       m_type(type),
       m_custom_bit_size(0),
       m_flags(0),
-      m_size(0),
-      m_alignment(0)
+      m_size{},
+      m_alignment{}
 {
     assert(m_type != nullptr);
 }
 
-unsigned TypeDeclaration::GetSize() const
+unsigned TypeDeclaration::GetSize(const WordSize wordSize) const
 {
     assert(m_flags & FLAG_FIELDS_CALCULATED);
-    return m_size;
+    return m_size[std::to_underlying(wordSize)];
 }
 
-unsigned TypeDeclaration::GetAlignment() const
+unsigned TypeDeclaration::GetAlignment(const WordSize wordSize) const
 {
     assert(m_flags & FLAG_FIELDS_CALCULATED);
-    return m_alignment;
+    return m_alignment[std::to_underlying(wordSize)];
 }
 
 bool TypeDeclaration::GetForceAlignment() const

src/ZoneCodeGeneratorLib/Domain/Definition/TypeDeclaration.h

@@ -2,6 +2,7 @@
 
 #include "DataDefinition.h"
 #include "DeclarationModifier.h"
+#include "Domain/WordSize.h"
 
 #include <memory>
 #include <vector>
@@ -14,8 +15,8 @@ public:
 
     explicit TypeDeclaration(const DataDefinition* type);
 
-    [[nodiscard]] unsigned GetSize() const;
-    [[nodiscard]] unsigned GetAlignment() const;
+    [[nodiscard]] unsigned GetSize(WordSize wordSize) const;
+    [[nodiscard]] unsigned GetAlignment(WordSize wordSize) const;
     [[nodiscard]] bool GetForceAlignment() const;
 
     std::vector<std::unique_ptr<DeclarationModifier>> m_declaration_modifiers;
@@ -27,6 +28,6 @@ public:
     unsigned m_custom_bit_size;
 
     unsigned m_flags;
-    unsigned m_size;
-    unsigned m_alignment;
+    unsigned m_size[WORD_SIZE_COUNT];
+    unsigned m_alignment[WORD_SIZE_COUNT];
 };

src/ZoneCodeGeneratorLib/Domain/Definition/TypedefDefinition.cpp

@@ -13,13 +13,14 @@ DataDefinitionType TypedefDefinition::GetType() const
     return DataDefinitionType::TYPEDEF;
 }
 
-unsigned TypedefDefinition::GetAlignment() const
+unsigned TypedefDefinition::GetAlignment(WordSize wordSize) const
 {
     if (m_has_alignment_override)
     {
         return m_alignment_override;
     }
-    return m_type_declaration->GetAlignment();
+
+    return m_type_declaration->GetAlignment(wordSize);
 }
 
 bool TypedefDefinition::GetForceAlignment() const
@@ -27,7 +28,7 @@ bool TypedefDefinition::GetForceAlignment() const
     return m_has_alignment_override || m_type_declaration->GetForceAlignment();
 }
 
-unsigned TypedefDefinition::GetSize() const
+unsigned TypedefDefinition::GetSize(const WordSize wordSize) const
 {
-    return m_type_declaration->GetSize();
+    return m_type_declaration->GetSize(wordSize);
 }

src/ZoneCodeGeneratorLib/Domain/Definition/TypedefDefinition.h

@@ -9,9 +9,9 @@ public:
     TypedefDefinition(std::string _namespace, std::string name, std::unique_ptr<TypeDeclaration> typeDeclaration);
 
     [[nodiscard]] DataDefinitionType GetType() const override;
-    [[nodiscard]] unsigned GetAlignment() const override;
+    [[nodiscard]] unsigned GetAlignment(WordSize wordSize) const override;
     [[nodiscard]] bool GetForceAlignment() const override;
-    [[nodiscard]] unsigned GetSize() const override;
+    [[nodiscard]] unsigned GetSize(WordSize wordSize) const override;
 
     bool m_has_alignment_override;
     unsigned m_alignment_override;

src/ZoneCodeGeneratorLib/Domain/Definition/Variable.cpp

@@ -9,12 +9,12 @@ Variable::Variable(std::string name, std::unique_ptr<TypeDeclaration> typeDeclar
 {
 }
 
-unsigned Variable::GetAlignment() const
+unsigned Variable::GetAlignment(const WordSize wordSize) const
 {
     if (m_has_alignment_override)
         return m_alignment_override;
 
-    return m_type_declaration->GetAlignment();
+    return m_type_declaration->GetAlignment(wordSize);
 }
 
 bool Variable::GetForceAlignment() const

src/ZoneCodeGeneratorLib/Domain/Definition/Variable.h

@@ -10,7 +10,7 @@ class Variable
 public:
     Variable(std::string name, std::unique_ptr<TypeDeclaration> typeDeclaration);
 
-    [[nodiscard]] unsigned GetAlignment() const;
+    [[nodiscard]] unsigned GetAlignment(WordSize wordSize) const;
     [[nodiscard]] bool GetForceAlignment() const;
 
     std::string m_name;

src/ZoneCodeGeneratorLib/Domain/GameVariant.cpp

@@ -0,0 +1,8 @@
+#include "GameVariant.h"
+
+GameVariant::GameVariant(std::string name, const WordSize wordSize, const std::endian endianness)
+    : m_name(std::move(name)),
+      m_word_size(wordSize),
+      m_endianness(endianness)
+{
+}

src/ZoneCodeGeneratorLib/Domain/GameVariant.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "WordSize.h"
+
+#include <bit>
+#include <string>
+
+class GameVariant
+{
+public:
+    GameVariant(std::string name, WordSize wordSize, std::endian endianness);
+
+    std::string m_name;
+    WordSize m_word_size;
+    std::endian m_endianness;
+};

src/ZoneCodeGeneratorLib/Domain/Information/MemberInformation.h

@@ -2,7 +2,7 @@
 
 #include "Domain/Definition/Variable.h"
 #include "Domain/Evaluation/IEvaluation.h"
-#include "Domain/FastFile/FastFileBlock.h"
+#include "Domain/FastFileBlock.h"
 #include "StructureInformation.h"
 #include "TypeInformation.h"
 

src/ZoneCodeGeneratorLib/Domain/Information/StructureInformation.h

@@ -3,7 +3,7 @@
 #include "Domain/Definition/DefinitionWithMembers.h"
 #include "Domain/Definition/EnumMember.h"
 #include "Domain/Extension/CustomAction.h"
-#include "Domain/FastFile/FastFileBlock.h"
+#include "Domain/FastFileBlock.h"
 #include "MemberInformation.h"
 #include "TypeInformation.h"
 

src/ZoneCodeGeneratorLib/Domain/WordSize.h

@@ -1,13 +1,16 @@
 #pragma once
 
 #include <cstdint>
+#include <utility>
 
 enum class WordSize : std::uint8_t
 {
-    UNKNOWN,
     BITS_32,
-    BITS_64
+    BITS_64,
+
+    COUNT
 };
+static constexpr auto WORD_SIZE_COUNT = std::to_underlying(WordSize::COUNT);
 
 static constexpr WordSize OWN_WORD_SIZE =
 #if defined(ARCH_x86)