zone/OpenAssetTools
zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2025-04-20 16:15:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

create enum definitions from headers

Browse Source
This commit is contained in:
Jan 2021-02-18 17:15:46 +01:00
parent 3c1599c1a0
commit 5d5fc86923
34 changed files with 350 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
src/ZoneCodeGeneratorLib/Domain/Definition/BaseTypeDefinition.cpp
View File

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

10
src/ZoneCodeGeneratorLib/Domain/Definition/BaseTypeDefinition.h
View File

@ -11,12 +11,9 @@ private:
public:
_NODISCARD DataDefinitionType GetType() 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;
_NODISCARD unsigned GetAlignment() const override;
_NODISCARD bool GetForceAlignment() const override;
_NODISCARD unsigned GetSize() const override;
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;
};

6
src/ZoneCodeGeneratorLib/Domain/Definition/DataDefinition.h
View File

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

61
src/ZoneCodeGeneratorLib/Domain/Definition/DefinitionWithMembers.cpp
View File

@ -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()
{
if (m_has_alignment_override)
{
m_flags |= FLAG_ALIGNMENT_FORCED;
m_alignment = m_alignment_override;
}
else
{
m_alignment = 0;
for (const auto& member : m_members)
{
const auto memberAlignment = member->GetAlignment();
if (memberAlignment > m_alignment)
m_alignment = memberAlignment;
}
}
m_flags |= FLAG_ALIGNMENT_CALCULATED;
}
//void DefinitionWithMembers::CalculateAlignment()
//{
// if (m_has_alignment_override)
// {
// m_flags |= FLAG_ALIGNMENT_FORCED;
// m_alignment = m_alignment_override;
// }
// else
// {
// m_alignment = 0;
// for (const auto& member : m_members)
// {
// const auto memberAlignment = member->GetAlignment();
// if (memberAlignment > m_alignment)
// m_alignment = memberAlignment;
// }
// }
// m_flags |= FLAG_ALIGNMENT_CALCULATED;
//}
unsigned DefinitionWithMembers::GetAlignment()
unsigned DefinitionWithMembers::GetAlignment() const
{
if ((m_flags & FLAG_ALIGNMENT_CALCULATED) == 0)
CalculateAlignment();
assert(m_flags & FLAG_ALIGNMENT_CALCULATED);
/*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)
CalculateAlignment();
assert(m_flags & FLAG_ALIGNMENT_CALCULATED);
/*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)
CalculateSize();
assert(m_flags & FLAG_SIZE_CALCULATED);
/*if ((m_flags & FLAG_SIZE_CALCULATED) == 0)
CalculateSize();*/
return m_size;
}

13
src/ZoneCodeGeneratorLib/Domain/Definition/DefinitionWithMembers.h
View File

@ -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;
void CalculateAlignment();
/*virtual void CalculateSize() = 0;
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 bool GetForceAlignment() override;
_NODISCARD unsigned GetSize() override;
_NODISCARD unsigned GetAlignment() const override;
_NODISCARD bool GetForceAlignment() const override;
_NODISCARD unsigned GetSize() const override;
};

6
src/ZoneCodeGeneratorLib/Domain/Definition/EnumDefinition.cpp
View File

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

6
src/ZoneCodeGeneratorLib/Domain/Definition/EnumDefinition.h
View File

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

6
src/ZoneCodeGeneratorLib/Domain/Definition/ForwardDeclaration.cpp
View File

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

6
src/ZoneCodeGeneratorLib/Domain/Definition/ForwardDeclaration.h
View File

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

70
src/ZoneCodeGeneratorLib/Domain/Definition/StructDefinition.cpp
View File

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

4
src/ZoneCodeGeneratorLib/Domain/Definition/StructDefinition.h
View File

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

6
src/ZoneCodeGeneratorLib/Domain/Definition/TypedefDefinition.cpp
View File

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

6
src/ZoneCodeGeneratorLib/Domain/Definition/TypedefDefinition.h
View File

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

30
src/ZoneCodeGeneratorLib/Domain/Definition/UnionDefinition.cpp
View File

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

4
src/ZoneCodeGeneratorLib/Domain/Definition/UnionDefinition.h
View File

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

2
src/ZoneCodeGeneratorLib/Parsing/Commands/Matcher/CommandsCommonMatchers.cpp
View File

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

48
src/ZoneCodeGeneratorLib/Parsing/Header/Block/HeaderBlockEnum.cpp
View File

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

21
src/ZoneCodeGeneratorLib/Parsing/Header/Block/HeaderBlockEnum.h
View File

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

4
src/ZoneCodeGeneratorLib/Parsing/Header/Block/HeaderBlockStruct.cpp
View File

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

8
src/ZoneCodeGeneratorLib/Parsing/Header/Block/HeaderBlockStruct.h
View File

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

2
src/ZoneCodeGeneratorLib/Parsing/Header/Block/HeaderBlockUnion.cpp
View File

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

8
src/ZoneCodeGeneratorLib/Parsing/Header/Block/HeaderBlockUnion.h
View File

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

16
src/ZoneCodeGeneratorLib/Parsing/Header/Block/IHeaderBlockNameHolder.h Normal file
View File

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

6
src/ZoneCodeGeneratorLib/Parsing/Header/Block/IHeaderBlockVariableDefining.h
View File

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

4
src/ZoneCodeGeneratorLib/Parsing/Header/HeaderFileReader.cpp
View File

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

10
src/ZoneCodeGeneratorLib/Parsing/Header/Impl/HeaderParser.cpp
View File

@ -2,9 +2,8 @@
#include "Parsing/Header/Sequence/SequenceNamespace.h"
HeaderParser::HeaderParser(HeaderLexer* lexer, IDataRepository* targetRepository)
: AbstractParser(lexer, std::make_unique<HeaderParserState>()),
m_repository(targetRepository)
HeaderParser::HeaderParser(HeaderLexer* lexer)
: AbstractParser(lexer, std::make_unique<HeaderParserState>())
{
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)
{
}

6
src/ZoneCodeGeneratorLib/Parsing/Header/Impl/HeaderParser.h
View File

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

54
src/ZoneCodeGeneratorLib/Parsing/Header/Impl/HeaderParserState.cpp
View File

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

19
src/ZoneCodeGeneratorLib/Parsing/Header/Impl/HeaderParserState.h
View File

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

2
src/ZoneCodeGeneratorLib/Parsing/Header/Matcher/HeaderCommonMatchers.cpp
View File

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

8
src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceCloseBlock.cpp
View File

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

24
src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceEnum.cpp
View File

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

15
src/ZoneCodeGeneratorLib/Parsing/Sequence/SequenceResult.h
View File

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

3
src/ZoneCodeGeneratorLib/Utils/NamespaceBuilder.cpp
View File

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