create enum definitions from headers

src/ZoneCodeGeneratorLib/Domain/Definition/BaseTypeDefinition.cpp

@@ -11,32 +11,16 @@ DataDefinitionType BaseTypeDefinition::GetType() const
     return DataDefinitionType::BASE_TYPE;
 }
 
-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;
@@ -72,4 +56,5 @@ const BaseTypeDefinition* const BaseTypeDefinition::ALL_BASE_TYPES[]
     LONG_LONG,
     UNSIGNED_LONG_LONG,
     VOID
-};
+};
+const size_t BaseTypeDefinition::ALL_BASE_TYPES_COUNT = _countof(ALL_BASE_TYPES);

src/ZoneCodeGeneratorLib/Domain/Definition/BaseTypeDefinition.h

@@ -11,12 +11,9 @@ private:
 
 public:
     _NODISCARD DataDefinitionType GetType() const override;
-    _NODISCARD unsigned GetAlignment() override;
+    _NODISCARD unsigned GetAlignment() const override;
-    _NODISCARD unsigned GetAlignment() const;
+    _NODISCARD bool GetForceAlignment() const override;
-    _NODISCARD bool GetForceAlignment() override;
+    _NODISCARD unsigned GetSize() const override;
-    _NODISCARD bool GetForceAlignment() const;
-    _NODISCARD unsigned GetSize() override;
-    _NODISCARD unsigned GetSize() const;
 
     static const BaseTypeDefinition* const FLOAT;
     static const BaseTypeDefinition* const DOUBLE;
@@ -34,4 +31,5 @@ public:
     static const BaseTypeDefinition* const VOID;
 
     static const BaseTypeDefinition* const ALL_BASE_TYPES[];
+    static const size_t ALL_BASE_TYPES_COUNT;
 };

src/ZoneCodeGeneratorLib/Domain/Definition/DataDefinition.h

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

src/ZoneCodeGeneratorLib/Domain/Definition/DefinitionWithMembers.cpp

@@ -1,5 +1,7 @@
 #include "DefinitionWithMembers.h"
 
+#include <cassert>
+
 DefinitionWithMembers::DefinitionWithMembers(std::string _namespace, std::string name, const unsigned pack)
     : DataDefinition(std::move(_namespace), std::move(name)),
       m_flags(0),
@@ -12,46 +14,49 @@ DefinitionWithMembers::DefinitionWithMembers(std::string _namespace, std::string
 {
 }
 
-void DefinitionWithMembers::CalculateAlignment()
+//void DefinitionWithMembers::CalculateAlignment()
-{
+//{
-    if (m_has_alignment_override)
+//    if (m_has_alignment_override)
-    {
+//    {
-        m_flags |= FLAG_ALIGNMENT_FORCED;
+//        m_flags |= FLAG_ALIGNMENT_FORCED;
-        m_alignment = m_alignment_override;
+//        m_alignment = m_alignment_override;
-    }
+//    }
-    else
+//    else
-    {
+//    {
-        m_alignment = 0;
+//        m_alignment = 0;
-        for (const auto& member : m_members)
+//        for (const auto& member : m_members)
-        {
+//        {
-            const auto memberAlignment = member->GetAlignment();
+//            const auto memberAlignment = member->GetAlignment();
-            if (memberAlignment > m_alignment)
+//            if (memberAlignment > m_alignment)
-                m_alignment = memberAlignment;
+//                m_alignment = memberAlignment;
-        }
+//        }
-    }
+//    }
-    m_flags |= FLAG_ALIGNMENT_CALCULATED;
+//    m_flags |= FLAG_ALIGNMENT_CALCULATED;
-}
+//}
 
-unsigned DefinitionWithMembers::GetAlignment()
+unsigned DefinitionWithMembers::GetAlignment() const
 {
-    if ((m_flags & FLAG_ALIGNMENT_CALCULATED) == 0)
+    assert(m_flags & FLAG_ALIGNMENT_CALCULATED);
-        CalculateAlignment();
+    /*if ((m_flags & FLAG_ALIGNMENT_CALCULATED) == 0)
+        CalculateAlignment();*/
 
     return m_alignment;
 }
 
-bool DefinitionWithMembers::GetForceAlignment()
+bool DefinitionWithMembers::GetForceAlignment() const
 {
-    if ((m_flags & FLAG_ALIGNMENT_CALCULATED) == 0)
+    assert(m_flags & FLAG_ALIGNMENT_CALCULATED);
-        CalculateAlignment();
+    /*if ((m_flags & FLAG_ALIGNMENT_CALCULATED) == 0)
+        CalculateAlignment();*/
 
     return m_flags & FLAG_ALIGNMENT_FORCED;
 }
 
-unsigned DefinitionWithMembers::GetSize()
+unsigned DefinitionWithMembers::GetSize() const
 {
-    if ((m_flags & FLAG_SIZE_CALCULATED) == 0)
+    assert(m_flags & FLAG_SIZE_CALCULATED);
-        CalculateSize();
+    /*if ((m_flags & FLAG_SIZE_CALCULATED) == 0)
+        CalculateSize();*/
 
     return m_size;
 }

src/ZoneCodeGeneratorLib/Domain/Definition/DefinitionWithMembers.h

@@ -8,7 +8,7 @@
 
 class DefinitionWithMembers : public DataDefinition
 {
-protected:
+public:
     static constexpr int FLAG_SIZE_CALCULATED = 1 << 0;
     static constexpr int FLAG_ALIGNMENT_CALCULATED = 1 << 1;
     static constexpr int FLAG_ALIGNMENT_FORCED = 1 << 2;
@@ -17,10 +17,9 @@ protected:
     unsigned m_size;
     unsigned m_alignment;
 
-    virtual void CalculateSize() = 0;
+    /*virtual void CalculateSize() = 0;
-    void CalculateAlignment();
+    void CalculateAlignment();*/
 
-public:
     bool m_has_alignment_override;
     bool m_anonymous;
 
@@ -31,7 +30,7 @@ public:
 
     DefinitionWithMembers(std::string _namespace, std::string name, unsigned pack);
 
-    _NODISCARD unsigned GetAlignment() override;
+    _NODISCARD unsigned GetAlignment() const override;
-    _NODISCARD bool GetForceAlignment() override;
+    _NODISCARD bool GetForceAlignment() const override;
-    _NODISCARD unsigned GetSize() override;
+    _NODISCARD unsigned GetSize() const override;
 };

src/ZoneCodeGeneratorLib/Domain/Definition/EnumDefinition.cpp

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

src/ZoneCodeGeneratorLib/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() override;
+    _NODISCARD unsigned GetAlignment() const override;
-    _NODISCARD bool GetForceAlignment() override;
+    _NODISCARD bool GetForceAlignment() const override;
-    _NODISCARD unsigned GetSize() override;
+    _NODISCARD unsigned GetSize() const override;
 
     void AddEnumMember(EnumMember enumMember);
 };

src/ZoneCodeGeneratorLib/Domain/Definition/ForwardDeclaration.cpp

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

src/ZoneCodeGeneratorLib/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() override;
+    _NODISCARD unsigned GetAlignment() const override;
-    _NODISCARD bool GetForceAlignment() override;
+    _NODISCARD bool GetForceAlignment() const override;
-    _NODISCARD unsigned GetSize() override;
+    _NODISCARD unsigned GetSize() const override;
 };

src/ZoneCodeGeneratorLib/Domain/Definition/StructDefinition.cpp

@@ -2,41 +2,41 @@
 
 #include "Utils/AlignmentUtils.h"
 
-void StructDefinition::CalculateSize()
+//void StructDefinition::CalculateSize()
-{
+//{
-    m_size = 0;
+//    m_size = 0;
-    auto currentBitOffset = 0u;
+//    auto currentBitOffset = 0u;
-
+//
-    for(const auto& member : m_members)
+//    for(const auto& member : m_members)
-    {
+//    {
-        if(member->m_type_declaration->m_has_custom_bit_size)
+//        if(member->m_type_declaration->m_has_custom_bit_size)
-        {
+//        {
-            currentBitOffset += member->m_type_declaration->m_custom_bit_size;
+//            currentBitOffset += member->m_type_declaration->m_custom_bit_size;
-        }
+//        }
-        else
+//        else
-        {
+//        {
-            if (currentBitOffset > 0)
+//            if (currentBitOffset > 0)
-            {
+//            {
-                currentBitOffset = AlignmentUtils::Align(currentBitOffset, 8u);
+//                currentBitOffset = AlignmentUtils::Align(currentBitOffset, 8u);
-                m_size += currentBitOffset / 8;
+//                m_size += currentBitOffset / 8;
-                currentBitOffset = 0;
+//                currentBitOffset = 0;
-            }
+//            }
-
+//
-            m_size = AlignmentUtils::Align(m_size, member->GetForceAlignment() ? member->GetAlignment() : std::min(member->GetAlignment(), m_pack));
+//            m_size = AlignmentUtils::Align(m_size, member->GetForceAlignment() ? member->GetAlignment() : std::min(member->GetAlignment(), m_pack));
-            m_size += member->m_type_declaration->GetSize();
+//            m_size += member->m_type_declaration->GetSize();
-        }
+//        }
-    }
+//    }
-
+//
-    if (currentBitOffset > 0)
+//    if (currentBitOffset > 0)
-    {
+//    {
-        currentBitOffset = AlignmentUtils::Align(currentBitOffset, 8u);
+//        currentBitOffset = AlignmentUtils::Align(currentBitOffset, 8u);
-        m_size += currentBitOffset / 8;
+//        m_size += currentBitOffset / 8;
-    }
+//    }
-
+//
-    m_size = AlignmentUtils::Align(m_size, GetAlignment());
+//    m_size = AlignmentUtils::Align(m_size, GetAlignment());
-
+//
-    m_flags |= FLAG_SIZE_CALCULATED;
+//    m_flags |= FLAG_SIZE_CALCULATED;
-}
+//}
 
 StructDefinition::StructDefinition(std::string _namespace, std::string name, const int pack)
     : DefinitionWithMembers(std::move(_namespace), std::move(name), pack)

src/ZoneCodeGeneratorLib/Domain/Definition/StructDefinition.h

@@ -4,8 +4,8 @@
 
 class StructDefinition final : public DefinitionWithMembers
 {
-protected:
+//protected:
-    void CalculateSize() override;
+//    void CalculateSize() override;
 
 public:
     StructDefinition(std::string _namespace, std::string name, int pack);

src/ZoneCodeGeneratorLib/Domain/Definition/TypedefDefinition.cpp

@@ -13,7 +13,7 @@ DataDefinitionType TypedefDefinition::GetType() const
     return DataDefinitionType::TYPEDEF;
 }
 
-unsigned TypedefDefinition::GetAlignment()
+unsigned TypedefDefinition::GetAlignment() const
 {
     if (m_has_alignment_override)
     {
@@ -22,12 +22,12 @@ unsigned TypedefDefinition::GetAlignment()
     return m_type_declaration->GetAlignment();
 }
 
-bool TypedefDefinition::GetForceAlignment()
+bool TypedefDefinition::GetForceAlignment() const
 {
     return m_has_alignment_override || m_type_declaration->GetForceAlignment();
 }
 
-unsigned TypedefDefinition::GetSize()
+unsigned TypedefDefinition::GetSize() const
 {
     return m_type_declaration->GetSize();
 }

src/ZoneCodeGeneratorLib/Domain/Definition/TypedefDefinition.h

@@ -13,7 +13,7 @@ public:
     TypedefDefinition(std::string _namespace, std::string name, std::unique_ptr<TypeDeclaration> typeDeclaration);
 
     _NODISCARD DataDefinitionType GetType() const override;
-    _NODISCARD unsigned GetAlignment() override;
+    _NODISCARD unsigned GetAlignment() const override;
-    _NODISCARD bool GetForceAlignment() override;
+    _NODISCARD bool GetForceAlignment() const override;
-    _NODISCARD unsigned GetSize() override;
+    _NODISCARD unsigned GetSize() const override;
 };

src/ZoneCodeGeneratorLib/Domain/Definition/UnionDefinition.cpp

@@ -2,21 +2,21 @@
 
 #include "Utils/AlignmentUtils.h"
 
-void UnionDefinition::CalculateSize()
+//void UnionDefinition::CalculateSize()
-{
+//{
-    m_size = 0;
+//    m_size = 0;
-
+//
-    for(const auto& member : m_members)
+//    for(const auto& member : m_members)
-    {
+//    {
-        const auto memberSize = member->m_type_declaration->GetSize();
+//        const auto memberSize = member->m_type_declaration->GetSize();
-        if (memberSize > m_size)
+//        if (memberSize > m_size)
-            m_size = memberSize;
+//            m_size = memberSize;
-    }
+//    }
-
+//
-    m_size = AlignmentUtils::Align(m_size, GetAlignment());
+//    m_size = AlignmentUtils::Align(m_size, GetAlignment());
-
+//
-    m_flags |= FLAG_SIZE_CALCULATED;
+//    m_flags |= FLAG_SIZE_CALCULATED;
-}
+//}
 
 UnionDefinition::UnionDefinition(std::string _namespace, std::string name, const int pack)
     : DefinitionWithMembers(std::move(_namespace), std::move(name), pack)

src/ZoneCodeGeneratorLib/Domain/Definition/UnionDefinition.h

@@ -4,8 +4,8 @@
 
 class UnionDefinition final : public DefinitionWithMembers
 {
-protected:
+//protected:
-    void CalculateSize() override;
+//    void CalculateSize() override;
 
 public:
     UnionDefinition(std::string _namespace, std::string name, int pack);

src/ZoneCodeGeneratorLib/Parsing/Commands/Matcher/CommandsCommonMatchers.cpp

@@ -33,7 +33,7 @@ std::unique_ptr<CommandsCommonMatchers::matcher_t> CommandsCommonMatchers::Typen
         }).Transform([](CommandsMatcherFactory::token_list_t& values)
         {
             std::ostringstream str;
-            auto first = false;
+            auto first = true;
 
             for (const auto& token : values)
             {

src/ZoneCodeGeneratorLib/Parsing/Header/Block/HeaderBlockEnum.cpp

@@ -3,9 +3,17 @@
 #include "Parsing/Header/Sequence/SequenceCloseBlock.h"
 #include "Parsing/Header/Sequence/SequenceEnumMember.h"
 
+HeaderBlockEnum::HeaderBlockEnum(std::string typeName, const BaseTypeDefinition* parentType, const bool isTypeDef)
+    : m_type_name(std::move(typeName)),
+      m_parent_type(parentType),
+      m_is_typedef(isTypeDef),
+      m_enum_definition(nullptr)
+{
+}
+
 HeaderBlockType HeaderBlockEnum::GetType()
 {
-    return HeaderBlockType::UNION;
+    return HeaderBlockType::ENUM;
 }
 
 const std::vector<IHeaderBlock::sequence_t*>& HeaderBlockEnum::GetTestsForBlock()
@@ -20,17 +28,53 @@ const std::vector<IHeaderBlock::sequence_t*>& HeaderBlockEnum::GetTestsForBlock(
 
 void HeaderBlockEnum::OnOpen(HeaderParserState* state)
 {
+    m_namespace = state->m_namespace.ToString();
+
+    if (!m_type_name.empty())
+        state->m_namespace.Push(m_type_name);
 }
 
 void HeaderBlockEnum::OnClose(HeaderParserState* state)
 {
+    if (!m_type_name.empty())
+        state->m_namespace.Pop();
+
+    auto enumDefinition = std::make_unique<EnumDefinition>(m_namespace, m_type_name, m_parent_type);
+    m_enum_definition = enumDefinition.get();
+    for (auto& member : m_members)
+        enumDefinition->m_members.emplace_back(std::move(member));
+
+    state->AddDataType(std::move(enumDefinition));
+
+    if (m_is_typedef)
+        state->AddDataType(std::make_unique<TypedefDefinition>(m_namespace, m_variable_name, std::make_unique<TypeDeclaration>(m_enum_definition)));
 }
 
 void HeaderBlockEnum::OnChildBlockClose(HeaderParserState* state, IHeaderBlock* block)
 {
 }
 
-void HeaderBlockEnum::SetVariableName(std::string name)
+void HeaderBlockEnum::AddEnumMember(std::unique_ptr<EnumMember> enumMember)
+{
+    m_members.emplace_back(std::move(enumMember));
+}
+
+void HeaderBlockEnum::SetBlockName(const TokenPos& nameTokenPos, std::string name)
 {
     m_variable_name = std::move(name);
 }
+
+bool HeaderBlockEnum::IsDefiningVariable()
+{
+    return !m_is_typedef && !m_variable_name.empty();
+}
+
+DataDefinition* HeaderBlockEnum::GetVariableType()
+{
+    return m_enum_definition;
+}
+
+std::string HeaderBlockEnum::GetVariableName()
+{
+    return m_variable_name;
+}

src/ZoneCodeGeneratorLib/Parsing/Header/Block/HeaderBlockEnum.h

@@ -1,18 +1,35 @@
 #pragma once
 
 #include "IHeaderBlock.h"
+#include "IHeaderBlockNameHolder.h"
 #include "IHeaderBlockVariableDefining.h"
+#include "Domain/Definition/BaseTypeDefinition.h"
+#include "Domain/Definition/EnumDefinition.h"
 
-class HeaderBlockEnum final : public IHeaderBlock, public IHeaderBlockVariableDefining
+class HeaderBlockEnum final : public IHeaderBlock, public IHeaderBlockNameHolder, public IHeaderBlockVariableDefining
 {
+    std::string m_namespace;
+    std::string m_type_name;
+    const BaseTypeDefinition* m_parent_type;
+    bool m_is_typedef;
+    std::vector<std::unique_ptr<EnumMember>> m_members;
+    EnumDefinition* m_enum_definition;
+
     std::string m_variable_name;
 
 public:
+    HeaderBlockEnum(std::string typeName, const BaseTypeDefinition* parentType, bool isTypeDef);
+
     HeaderBlockType GetType() override;
     const std::vector<sequence_t*>& GetTestsForBlock() override;
     void OnOpen(HeaderParserState* state) override;
     void OnClose(HeaderParserState* state) override;
     void OnChildBlockClose(HeaderParserState* state, IHeaderBlock* block) override;
 
-    void SetVariableName(std::string name) override;
+    void AddEnumMember(std::unique_ptr<EnumMember> enumMember);
+
+    void SetBlockName(const TokenPos& nameTokenPos, std::string name) override;
+    bool IsDefiningVariable() override;
+    DataDefinition* GetVariableType() override;
+    std::string GetVariableName() override;
 };

src/ZoneCodeGeneratorLib/Parsing/Header/Block/HeaderBlockStruct.cpp

@@ -36,7 +36,7 @@ void HeaderBlockStruct::OnChildBlockClose(HeaderParserState* state, IHeaderBlock
 {
 }
 
-void HeaderBlockStruct::SetVariableName(std::string name)
+void HeaderBlockStruct::SetBlockName(const TokenPos& nameTokenPos, std::string name)
 {
     m_variable_name = std::move(name);
-}
+}

src/ZoneCodeGeneratorLib/Parsing/Header/Block/HeaderBlockStruct.h

@@ -1,9 +1,9 @@
 #pragma once
 
 #include "IHeaderBlock.h"
-#include "IHeaderBlockVariableDefining.h"
+#include "IHeaderBlockNameHolder.h"
 
-class HeaderBlockStruct final : public IHeaderBlock, public IHeaderBlockVariableDefining
+class HeaderBlockStruct final : public IHeaderBlock, public IHeaderBlockNameHolder
 {
     std::string m_variable_name;
 
@@ -13,6 +13,6 @@ public:
     void OnOpen(HeaderParserState* state) override;
     void OnClose(HeaderParserState* state) override;
     void OnChildBlockClose(HeaderParserState* state, IHeaderBlock* block) override;
-
+    
-    void SetVariableName(std::string name) override;
+    void SetBlockName(const TokenPos& nameTokenPos, std::string name) override;
 };

src/ZoneCodeGeneratorLib/Parsing/Header/Block/HeaderBlockUnion.cpp

@@ -36,7 +36,7 @@ void HeaderBlockUnion::OnChildBlockClose(HeaderParserState* state, IHeaderBlock*
 {
 }
 
-void HeaderBlockUnion::SetVariableName(std::string name)
+void HeaderBlockUnion::SetBlockName(const TokenPos& nameTokenPos, std::string name)
 {
     m_variable_name = std::move(name);
 }

src/ZoneCodeGeneratorLib/Parsing/Header/Block/HeaderBlockUnion.h

@@ -1,9 +1,9 @@
 #pragma once
 
 #include "IHeaderBlock.h"
-#include "IHeaderBlockVariableDefining.h"
+#include "IHeaderBlockNameHolder.h"
 
-class HeaderBlockUnion final : public IHeaderBlock, public IHeaderBlockVariableDefining
+class HeaderBlockUnion final : public IHeaderBlock, public IHeaderBlockNameHolder
 {
     std::string m_variable_name;
 
@@ -13,6 +13,6 @@ public:
     void OnOpen(HeaderParserState* state) override;
     void OnClose(HeaderParserState* state) override;
     void OnChildBlockClose(HeaderParserState* state, IHeaderBlock* block) override;
-
+    
-    void SetVariableName(std::string name) override;
+    void SetBlockName(const TokenPos& nameTokenPos, std::string name) override;
 };

src/ZoneCodeGeneratorLib/Parsing/Header/Block/IHeaderBlockNameHolder.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <string>
+
+class IHeaderBlockNameHolder
+{
+public:
+    IHeaderBlockNameHolder() = default;
+    virtual ~IHeaderBlockNameHolder() = default;
+    IHeaderBlockNameHolder(const IHeaderBlockNameHolder& other) = default;
+    IHeaderBlockNameHolder(IHeaderBlockNameHolder&& other) noexcept = default;
+    IHeaderBlockNameHolder& operator=(const IHeaderBlockNameHolder& other) = default;
+    IHeaderBlockNameHolder& operator=(IHeaderBlockNameHolder&& other) noexcept = default;
+
+    virtual void SetBlockName(const TokenPos& nameTokenPos, std::string name) = 0;
+};

src/ZoneCodeGeneratorLib/Parsing/Header/Block/IHeaderBlockVariableDefining.h

@@ -2,6 +2,8 @@
 
 #include <string>
 
+#include "Domain/Definition/DataDefinition.h"
+
 class IHeaderBlockVariableDefining
 {
 public:
@@ -12,5 +14,7 @@ public:
     IHeaderBlockVariableDefining& operator=(const IHeaderBlockVariableDefining& other) = default;
     IHeaderBlockVariableDefining& operator=(IHeaderBlockVariableDefining&& other) noexcept = default;
 
-    virtual void SetVariableName(std::string name) = 0;
+    virtual bool IsDefiningVariable() = 0;
+    virtual DataDefinition* GetVariableType() = 0;
+    virtual std::string GetVariableName() = 0;
 };

src/ZoneCodeGeneratorLib/Parsing/Header/HeaderFileReader.cpp

@@ -61,10 +61,12 @@ bool HeaderFileReader::ReadHeaderFile(IDataRepository* repository)
     SetupStreamProxies();
 
     const auto lexer = std::make_unique<HeaderLexer>(m_stream);
-    const auto parser = std::make_unique<HeaderParser>(lexer.get(), repository);
+    const auto parser = std::make_unique<HeaderParser>(lexer.get());
 
     const auto start = std::chrono::steady_clock::now();
     const auto result = parser->Parse();
+    if (result)
+        parser->SaveToRepository(repository);
     const auto end = std::chrono::steady_clock::now();
     std::cout << "Processing header took " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms" << std::endl;
 

src/ZoneCodeGeneratorLib/Parsing/Header/Impl/HeaderParser.cpp

@@ -2,9 +2,8 @@
 
 #include "Parsing/Header/Sequence/SequenceNamespace.h"
 
-HeaderParser::HeaderParser(HeaderLexer* lexer, IDataRepository* targetRepository)
+HeaderParser::HeaderParser(HeaderLexer* lexer)
-    : AbstractParser(lexer, std::make_unique<HeaderParserState>()),
+    : AbstractParser(lexer, std::make_unique<HeaderParserState>())
-      m_repository(targetRepository)
 {
     auto sequenceNamespace = std::make_unique<SequenceNamespace>();
 }
@@ -13,3 +12,8 @@ const std::vector<HeaderParser::sequence_t*>& HeaderParser::GetTestsForState()
 {
     return m_state->GetBlock()->GetTestsForBlock();
 }
+
+void HeaderParser::SaveToRepository(IDataRepository* repository)
+{
+
+}

src/ZoneCodeGeneratorLib/Parsing/Header/Impl/HeaderParser.h

@@ -7,11 +7,11 @@
 
 class HeaderParser final : public AbstractParser<HeaderParserValue, HeaderParserState>
 {
-    IDataRepository* m_repository;
-
 protected:
     const std::vector<sequence_t*>& GetTestsForState() override;
 
 public:
-    HeaderParser(HeaderLexer* lexer, IDataRepository* targetRepository);
+    explicit HeaderParser(HeaderLexer* lexer);
+
+    void SaveToRepository(IDataRepository* repository);
 };

src/ZoneCodeGeneratorLib/Parsing/Header/Impl/HeaderParserState.cpp

@@ -1,10 +1,19 @@
 #include "HeaderParserState.h"
 
+#include "Domain/Definition/EnumDefinition.h"
 #include "Parsing/Header/Block/HeaderBlockNone.h"
 
 HeaderParserState::HeaderParserState()
 {
     m_blocks.push(std::make_unique<HeaderBlockNone>());
+
+    for(auto i = 0u; i < BaseTypeDefinition::ALL_BASE_TYPES_COUNT; i++)
+        AddBaseDataType(BaseTypeDefinition::ALL_BASE_TYPES[i]);
+}
+
+void HeaderParserState::AddBaseDataType(const BaseTypeDefinition* baseType)
+{
+    m_definitions.insert(std::make_pair(baseType->GetFullName(), baseType));
 }
 
 IHeaderBlock* HeaderParserState::GetBlock() const
@@ -29,3 +38,48 @@ void HeaderParserState::PopBlock()
         m_blocks.top()->OnChildBlockClose(this, poppedBlock.get());
     }
 }
+
+void HeaderParserState::AddDataType(std::unique_ptr<DataDefinition> definition)
+{
+    if(definition->GetType() == DataDefinitionType::ENUM)
+    {
+        for(const auto& enumMember : dynamic_cast<EnumDefinition*>(definition.get())->m_members)
+        {
+            m_enum_members.insert(std::make_pair(enumMember->m_name, enumMember.get()));
+        }
+    }
+
+    const DataDefinition* dataDefinition = definition.get();
+    m_header_definitions.emplace_back(std::move(definition));
+    m_definitions.insert(std::make_pair(dataDefinition->m_name, dataDefinition));
+}
+
+void HeaderParserState::AddForwardDeclaration(std::unique_ptr<ForwardDeclaration> forwardDeclaration)
+{
+    m_forward_declarations.insert(std::make_pair(forwardDeclaration->m_name, std::move(forwardDeclaration)));
+}
+
+const DataDefinition* HeaderParserState::FindType(const std::string& typeName)
+{
+    const auto foundDefinitionEntry = m_definitions.find(typeName);
+
+    if (foundDefinitionEntry != m_definitions.end())
+        return foundDefinitionEntry->second;
+
+    const auto foundForwardEntry = m_forward_declarations.find(typeName);
+
+    if (foundForwardEntry != m_forward_declarations.end())
+        return foundForwardEntry->second.get();
+
+    return nullptr;
+}
+
+EnumMember* HeaderParserState::FindEnumMember(const std::string& enumMemberName)
+{
+    const auto foundEntry = m_enum_members.find(enumMemberName);
+
+    if (foundEntry != m_enum_members.end())
+        return foundEntry->second;
+
+    return nullptr;
+}

src/ZoneCodeGeneratorLib/Parsing/Header/Impl/HeaderParserState.h

@@ -2,15 +2,28 @@
 
 #include <memory>
 #include <stack>
+#include <unordered_map>
 
 #include "Utils/ClassUtils.h"
+#include "Domain/Definition/BaseTypeDefinition.h"
+#include "Domain/Definition/DataDefinition.h"
+#include "Domain/Definition/EnumMember.h"
+#include "Domain/Definition/ForwardDeclaration.h"
 #include "Utils/NamespaceBuilder.h"
 #include "Parsing/Header/Block/IHeaderBlock.h"
 
 class IHeaderBlock;
+
 class HeaderParserState
 {
+    std::vector<std::unique_ptr<DataDefinition>> m_header_definitions;
+
     std::stack<std::unique_ptr<IHeaderBlock>> m_blocks;
+    std::unordered_map<std::string, const DataDefinition*> m_definitions;
+    std::unordered_map<std::string, EnumMember*> m_enum_members;
+    std::unordered_map<std::string, std::unique_ptr<ForwardDeclaration>> m_forward_declarations;
+
+    void AddBaseDataType(const BaseTypeDefinition* baseType);
 
 public:
     NamespaceBuilder m_namespace;
@@ -20,4 +33,10 @@ public:
     _NODISCARD IHeaderBlock* GetBlock() const;
     void PushBlock(std::unique_ptr<IHeaderBlock> block);
     void PopBlock();
+
+    void AddDataType(std::unique_ptr<DataDefinition> definition);
+    void AddForwardDeclaration(std::unique_ptr<ForwardDeclaration> forwardDeclaration);
+
+    const DataDefinition* FindType(const std::string& typeName);
+    EnumMember* FindEnumMember(const std::string& enumMemberName);
 };

src/ZoneCodeGeneratorLib/Parsing/Header/Matcher/HeaderCommonMatchers.cpp

@@ -71,7 +71,7 @@ std::unique_ptr<HeaderCommonMatchers::matcher_t> HeaderCommonMatchers::Typename(
         }).Transform([](HeaderMatcherFactory::token_list_t& values)
         {
             std::ostringstream str;
-            auto first = false;
+            auto first = true;
 
             for(const auto& token : values)
             {

src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceCloseBlock.cpp

@@ -1,6 +1,6 @@
 #include "SequenceCloseBlock.h"
 
-#include "Parsing/Header/Block/IHeaderBlockVariableDefining.h"
+#include "Parsing/Header/Block/IHeaderBlockNameHolder.h"
 #include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
 #include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
 
@@ -22,7 +22,7 @@ void SequenceCloseBlock::ProcessMatch(HeaderParserState* state, SequenceResult<H
 {
     if (result.NextTag() == TAG_SEMICOLON)
     {
-        if(!m_semicolon_required)
+        if (!m_semicolon_required)
             throw ParsingException(result.NextCapture(CAPTURE_CLOSING_PARENTHESIS).GetPos(), "Block should not be closed with semicolon");
     }
     else
@@ -33,13 +33,13 @@ void SequenceCloseBlock::ProcessMatch(HeaderParserState* state, SequenceResult<H
 
     if (result.HasNextCapture(CAPTURE_NAME))
     {
-        auto* variableDefiningBlock = dynamic_cast<IHeaderBlockVariableDefining*>(state->GetBlock());
+        auto* variableDefiningBlock = dynamic_cast<IHeaderBlockNameHolder*>(state->GetBlock());
         const auto& name = result.NextCapture(CAPTURE_NAME);
 
         if (variableDefiningBlock == nullptr)
             throw ParsingException(name.GetPos(), "Block does not support holding names.");
 
-        variableDefiningBlock->SetVariableName(name.IdentifierValue());
+        variableDefiningBlock->SetBlockName(name.GetPos(), name.IdentifierValue());
     }
 
     state->PopBlock();

src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceEnum.cpp

@@ -23,5 +23,27 @@ SequenceEnum::SequenceEnum()
 
 void SequenceEnum::ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const
 {
-    state->PushBlock(std::make_unique<HeaderBlockEnum>());
+    auto isTypedef = result.PeekAndRemoveIfTag(TAG_TYPEDEF) == TAG_TYPEDEF;
+    std::string name;
+    const auto* parentType = BaseTypeDefinition::INT;
+
+    if (result.HasNextCapture(CAPTURE_NAME))
+        name = result.NextCapture(CAPTURE_NAME).IdentifierValue();
+
+    if(result.HasNextCapture(CAPTURE_PARENT_TYPE))
+    {
+        const auto& typeNameToken = result.NextCapture(CAPTURE_PARENT_TYPE);
+        const auto* foundTypeDefinition = state->FindType(typeNameToken.TypeNameValue());
+
+        if (foundTypeDefinition == nullptr)
+            throw ParsingException(typeNameToken.GetPos(), "Cannot find type");
+
+        while (foundTypeDefinition->GetType() == DataDefinitionType::TYPEDEF)
+            foundTypeDefinition = dynamic_cast<const TypedefDefinition*>(foundTypeDefinition)->m_type_declaration->m_type;
+
+        if (foundTypeDefinition->GetType() != DataDefinitionType::BASE_TYPE)
+            throw ParsingException(typeNameToken.GetPos(), "Enums can only have base types as parent type");
+    }
+
+    state->PushBlock(std::make_unique<HeaderBlockEnum>(name, parentType, isTypedef));
 }

src/ZoneCodeGeneratorLib/Parsing/Sequence/SequenceResult.h

@@ -52,6 +52,21 @@ public:
         return AbstractMatcher<TokenType>::NO_ID;
     }
 
+    int PeekAndRemoveIfTag(const int tag)
+    {
+        if (m_tag_offset < m_tags.size())
+        {
+            const auto result = m_tags[m_tag_offset];
+            
+            if (result == tag)
+                m_tag_offset++;
+
+            return result;
+        }
+
+        return AbstractMatcher<TokenType>::NO_ID;
+    }
+
     int NextTag()
     {
         if (m_tag_offset < m_tags.size())

src/ZoneCodeGeneratorLib/Utils/NamespaceBuilder.cpp

@@ -4,6 +4,9 @@
 
 std::string NamespaceBuilder::Combine(const std::string& _namespace, const std::string& name)
 {
+    if (_namespace.empty())
+        return name;
+
     std::ostringstream str;
     str << _namespace << "::" << name;