parse typedefs

src/ZoneCodeGeneratorLib/Domain/Definition/ArrayDeclarationModifier.cpp

@@ -1,5 +1,10 @@
 #include "ArrayDeclarationModifier.h"
 
+ArrayDeclarationModifier::ArrayDeclarationModifier(const int size)
+    : m_size(size)
+{
+}
+
 DeclarationModifierType ArrayDeclarationModifier::GetType() const
 {
     return DeclarationModifierType::ARRAY;

src/ZoneCodeGeneratorLib/Domain/Definition/ArrayDeclarationModifier.h

@@ -2,6 +2,7 @@
 
 #include <memory>
 
+#include "Utils/ClassUtils.h"
 #include "DeclarationModifier.h"
 #include "Domain/Evaluation/IEvaluation.h"
 
@@ -20,5 +21,7 @@ public:
      */
     std::unique_ptr<IEvaluation> m_dynamic_count_evaluation;
 
-    DeclarationModifierType GetType() const override;
+    explicit ArrayDeclarationModifier(int size);
+
+    _NODISCARD DeclarationModifierType GetType() const override;
 };

src/ZoneCodeGeneratorLib/Domain/Definition/EnumMember.cpp

@@ -5,7 +5,7 @@ EnumMember::EnumMember()
 {
 }
 
-EnumMember::EnumMember(std::string name, const long long value)
+EnumMember::EnumMember(std::string name, const int value)
     : m_name(std::move(name)),
       m_value(value)
 {

src/ZoneCodeGeneratorLib/Domain/Definition/EnumMember.h

@@ -6,8 +6,8 @@ class EnumMember
 {
 public:
     std::string m_name;
-    long long m_value;
+    int m_value;
 
     EnumMember();
-    EnumMember(std::string name, long long value);
+    EnumMember(std::string name, int value);
 };

src/ZoneCodeGeneratorLib/Domain/Definition/TypeDeclaration.cpp

@@ -4,7 +4,7 @@
 
 #include "ArrayDeclarationModifier.h"
 
-TypeDeclaration::TypeDeclaration(DataDefinition* type)
+TypeDeclaration::TypeDeclaration(const DataDefinition* type)
     : m_flags(0),
       m_size(0),
       m_alignment(0),

src/ZoneCodeGeneratorLib/Domain/Definition/TypeDeclaration.h

@@ -21,12 +21,12 @@ class TypeDeclaration
     void CalculateAlignment();
 
 public:
-    explicit TypeDeclaration(DataDefinition* type);
+    explicit TypeDeclaration(const DataDefinition* type);
 
     bool m_is_const;
     bool m_has_custom_bit_size;
 
-    DataDefinition* m_type;
+    const DataDefinition* m_type;
     unsigned m_custom_bit_size;
 
     std::vector<std::unique_ptr<DeclarationModifier>> m_declaration_modifiers;

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

@@ -72,7 +72,7 @@ EnumMember* HeaderBlockEnum::GetEnumMember(const std::string& name) const
     return nullptr;
 }
 
-long long HeaderBlockEnum::GetNextEnumMemberValue() const
+int HeaderBlockEnum::GetNextEnumMemberValue() const
 {
     return m_next_value;
 }

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

@@ -14,7 +14,7 @@ class HeaderBlockEnum final : public IHeaderBlock, public IHeaderBlockNameHolder
     const BaseTypeDefinition* m_parent_type;
     bool m_is_typedef;
     std::vector<std::unique_ptr<EnumMember>> m_members;
-    long long m_next_value;
+    int m_next_value;
     EnumDefinition* m_enum_definition;
 
     std::string m_variable_name;
@@ -30,7 +30,7 @@ public:
 
     void AddEnumMember(std::unique_ptr<EnumMember> enumMember);
     _NODISCARD EnumMember* GetEnumMember(const std::string& name) const;
-    _NODISCARD long long GetNextEnumMemberValue() const;
+    _NODISCARD int GetNextEnumMemberValue() const;
 
     void SetBlockName(const TokenPos& nameTokenPos, std::string name) override;
     bool IsDefiningVariable() override;

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

@@ -26,7 +26,7 @@ SequenceEnumMember::SequenceEnumMember()
 
 void SequenceEnumMember::ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const
 {
-    long long value;
+    int value;
     auto* enumBlock = dynamic_cast<HeaderBlockEnum*>(state->GetBlock());
 
     if (result.HasNextCapture(CAPTURE_VALUE))

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

@@ -1,5 +1,8 @@
 #include "SequenceTypedef.h"
 
+
+#include "Domain/Definition/ArrayDeclarationModifier.h"
+#include "Domain/Definition/PointerDeclarationModifier.h"
 #include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
 #include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
 
@@ -43,6 +46,71 @@ SequenceTypedef::SequenceTypedef()
     });
 }
 
+void SequenceTypedef::AddPointerDeclarationModifiers(SequenceResult<HeaderParserValue>& result, TypeDeclaration* typeDeclaration) const
+{
+    while (result.PeekAndRemoveIfTag(TAG_POINTER) == TAG_POINTER)
+        typeDeclaration->m_declaration_modifiers.emplace_back(std::make_unique<PointerDeclarationModifier>());
+}
+
+void SequenceTypedef::AddArrayDeclarationModifiers(HeaderParserState* state, SequenceResult<HeaderParserValue>& result, TypeDeclaration* typeDeclaration) const
+{
+    while (result.HasNextCapture(CAPTURE_ARRAY))
+    {
+        const auto& arrayToken = result.NextCapture(CAPTURE_ARRAY);
+
+        if (arrayToken.m_type == HeaderParserValueType::INTEGER)
+        {
+            typeDeclaration->m_declaration_modifiers.emplace_back(std::make_unique<ArrayDeclarationModifier>(arrayToken.IntegerValue()));
+        }
+        else
+        {
+            auto* enumMember = state->FindEnumMember(arrayToken.IdentifierValue());
+
+            if (enumMember == nullptr)
+                throw ParsingException(arrayToken.GetPos(), "Unknown enum member");
+
+            typeDeclaration->m_declaration_modifiers.emplace_back(std::make_unique<ArrayDeclarationModifier>(enumMember->m_value));
+        }
+    }
+}
+
 void SequenceTypedef::ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const
 {
+    const auto modeTag = result.NextTag();
+    assert(modeTag == TAG_ARRAY_OF_POINTERS || modeTag == TAG_POINTER_TO_ARRAY);
+
+    const auto name = result.NextCapture(CAPTURE_NAME).IdentifierValue();
+
+    const auto& typenameToken = result.NextCapture(CAPTURE_TYPE);
+    const auto* type = state->FindType(typenameToken.TypeNameValue());
+    if (type == nullptr && !state->m_namespace.IsEmpty())
+    {
+        const auto fullTypename = NamespaceBuilder::Combine(state->m_namespace.ToString(), typenameToken.TypeNameValue());
+        type = state->FindType(fullTypename);
+    }
+    if (type == nullptr)
+        throw ParsingException(typenameToken.GetPos(), "Unknown type");
+
+    auto typedefDefinition = std::make_unique<TypedefDefinition>(state->m_namespace.ToString(), name, std::make_unique<TypeDeclaration>(type));
+    typedefDefinition->m_type_declaration->m_is_const = result.PeekAndRemoveIfTag(TAG_CONST) == TAG_CONST;
+
+    if(result.HasNextCapture(CAPTURE_ALIGN))
+    {
+        const auto& alignToken = result.NextCapture(CAPTURE_ALIGN);
+        typedefDefinition->m_alignment_override = static_cast<unsigned>(alignToken.IntegerValue());
+        typedefDefinition->m_has_alignment_override = true;
+    }
+
+    if (modeTag == TAG_ARRAY_OF_POINTERS)
+    {
+        AddArrayDeclarationModifiers(state, result, typedefDefinition->m_type_declaration.get());
+        AddPointerDeclarationModifiers(result, typedefDefinition->m_type_declaration.get());
+    }
+    else
+    {
+        AddPointerDeclarationModifiers(result, typedefDefinition->m_type_declaration.get());
+        AddArrayDeclarationModifiers(state, result, typedefDefinition->m_type_declaration.get());
+    }
+
+    state->AddDataType(std::move(typedefDefinition));
 }

src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceTypedef.h

@@ -20,6 +20,9 @@ class SequenceTypedef final : public HeaderParser::sequence_t
     static constexpr auto LABEL_ARRAY_OF_POINTERS = 1;
     static constexpr auto LABEL_POINTER_TO_ARRAY = 2;
 
+    void AddPointerDeclarationModifiers(SequenceResult<HeaderParserValue>& result, TypeDeclaration* typeDeclaration) const;
+    void AddArrayDeclarationModifiers(HeaderParserState* state, SequenceResult<HeaderParserValue>& result, TypeDeclaration* typeDeclaration) const;
+
 protected:
     void ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const override;