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

chore: update ZoneCodeGenerator code style

Browse Source
This commit is contained in:
Jan 2025-04-19 23:01:22 +02:00
parent 6d594d1651
commit 9f80909de8
No known key found for this signature in database
GPG Key ID: 44B581F78FF5C57C
135 changed files with 4406 additions and 4299 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
src/ZoneCodeGeneratorLib/Domain/Computations/MemberComputations.h
View File

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

50
src/ZoneCodeGeneratorLib/Domain/Computations/MemberDeclarationModifierComputations.h
View File

@ -2,34 +2,36 @@
#include "Domain/Evaluation/IEvaluation.h" #include "Domain/Evaluation/IEvaluation.h"
#include "Domain/Information/MemberInformation.h" #include "Domain/Information/MemberInformation.h"
#include "Utils/ClassUtils.h"
#include <vector>
class DeclarationModifierComputations 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: public:
explicit DeclarationModifierComputations(const MemberInformation* member); explicit DeclarationModifierComputations(const MemberInformation* member);
_NODISCARD DeclarationModifier* GetDeclarationModifier() const; [[nodiscard]] DeclarationModifier* GetDeclarationModifier() const;
_NODISCARD DeclarationModifier* GetNextDeclarationModifier() const; [[nodiscard]] DeclarationModifier* GetNextDeclarationModifier() const;
_NODISCARD std::vector<DeclarationModifier*> GetFollowingDeclarationModifiers() const; [[nodiscard]] std::vector<DeclarationModifier*> GetFollowingDeclarationModifiers() const;
_NODISCARD std::vector<int> GetArrayIndices() const; [[nodiscard]] std::vector<int> GetArrayIndices() const;
_NODISCARD bool IsArray() const; [[nodiscard]] bool IsArray() const;
_NODISCARD int GetArraySize() const; [[nodiscard]] int GetArraySize() const;
_NODISCARD bool HasDynamicArrayCount() const; [[nodiscard]] bool HasDynamicArrayCount() const;
_NODISCARD const IEvaluation* GetDynamicArrayCountEvaluation() const; [[nodiscard]] const IEvaluation* GetDynamicArrayCountEvaluation() const;
_NODISCARD std::vector<DeclarationModifierComputations> GetArrayEntries() const; [[nodiscard]] std::vector<DeclarationModifierComputations> GetArrayEntries() const;
_NODISCARD bool IsSinglePointer() const; [[nodiscard]] bool IsSinglePointer() const;
_NODISCARD bool IsArrayPointer() const; [[nodiscard]] bool IsArrayPointer() const;
_NODISCARD const IEvaluation* GetArrayPointerCountEvaluation() const; [[nodiscard]] const IEvaluation* GetArrayPointerCountEvaluation() const;
_NODISCARD bool IsPointerArray() const; [[nodiscard]] bool IsPointerArray() const;
_NODISCARD const IEvaluation* GetPointerArrayCountEvaluation() const; [[nodiscard]] const IEvaluation* GetPointerArrayCountEvaluation() const;
_NODISCARD bool IsDynamicArray() const; [[nodiscard]] bool IsDynamicArray() const;
_NODISCARD const IEvaluation* GetDynamicArraySizeEvaluation() const; [[nodiscard]] const IEvaluation* GetDynamicArraySizeEvaluation() const;
_NODISCARD unsigned GetAlignment() const; [[nodiscard]] unsigned GetAlignment() const;
private:
DeclarationModifierComputations(const MemberInformation* member, std::vector<int> modifierIndices);
const MemberInformation* const m_information;
std::vector<int> m_modifier_indices;
int m_combined_index;
}; };

11
src/ZoneCodeGeneratorLib/Domain/Computations/StructureComputations.h
View File

@ -4,12 +4,13 @@
class StructureComputations class StructureComputations
{ {
const StructureInformation* const m_info;
public: public:
explicit StructureComputations(const StructureInformation* structure); explicit StructureComputations(const StructureInformation* structure);
_NODISCARD bool IsAsset() const; [[nodiscard]] bool IsAsset() const;
_NODISCARD MemberInformation* GetDynamicMember() const; [[nodiscard]] MemberInformation* GetDynamicMember() const;
_NODISCARD std::vector<MemberInformation*> GetUsedMembers() const; [[nodiscard]] std::vector<MemberInformation*> GetUsedMembers() const;
private:
const StructureInformation* m_info;
}; };

9
src/ZoneCodeGeneratorLib/Domain/Definition/ArrayDeclarationModifier.h
View File

@ -2,13 +2,16 @@
#include "DeclarationModifier.h" #include "DeclarationModifier.h"
#include "Domain/Evaluation/IEvaluation.h" #include "Domain/Evaluation/IEvaluation.h"
#include "Utils/ClassUtils.h"
#include <memory> #include <memory>
class ArrayDeclarationModifier final : public DeclarationModifier class ArrayDeclarationModifier final : public DeclarationModifier
{ {
public: public:
explicit ArrayDeclarationModifier(int size);
[[nodiscard]] DeclarationModifierType GetType() const override;
int m_size; int m_size;
/** /**
@ -20,8 +23,4 @@ public:
* \brief The array has a size that is given by \c m_size but only a certain dynamic amount is handled by generated count. * \brief The array has a size that is given by \c m_size but only a certain dynamic amount is handled by generated count.
*/ */
std::unique_ptr<IEvaluation> m_dynamic_count_evaluation; std::unique_ptr<IEvaluation> m_dynamic_count_evaluation;
explicit ArrayDeclarationModifier(int size);
_NODISCARD DeclarationModifierType GetType() const override;
}; };

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

@ -4,17 +4,6 @@
class BaseTypeDefinition final : public DataDefinition class BaseTypeDefinition final : public DataDefinition
{ {
public: public:
const unsigned m_size;
private:
BaseTypeDefinition(std::string name, unsigned size);
public:
_NODISCARD DataDefinitionType GetType() const override;
_NODISCARD unsigned GetAlignment() const override;
_NODISCARD bool GetForceAlignment() const override;
_NODISCARD unsigned GetSize() const override;
static const BaseTypeDefinition* const FLOAT; static const BaseTypeDefinition* const FLOAT;
static const BaseTypeDefinition* const DOUBLE; static const BaseTypeDefinition* const DOUBLE;
static const BaseTypeDefinition* const BOOL; static const BaseTypeDefinition* const BOOL;
@ -32,4 +21,14 @@ public:
static const BaseTypeDefinition* const ALL_BASE_TYPES[]; static const BaseTypeDefinition* const ALL_BASE_TYPES[];
static const size_t ALL_BASE_TYPES_COUNT; static const size_t ALL_BASE_TYPES_COUNT;
[[nodiscard]] DataDefinitionType GetType() const override;
[[nodiscard]] unsigned GetAlignment() const override;
[[nodiscard]] bool GetForceAlignment() const override;
[[nodiscard]] unsigned GetSize() const override;
const unsigned m_size;
private:
BaseTypeDefinition(std::string name, unsigned size);
}; };

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

@ -25,13 +25,13 @@ public:
DataDefinition& operator=(const DataDefinition& other) = default; DataDefinition& operator=(const DataDefinition& other) = default;
DataDefinition& operator=(DataDefinition&& other) noexcept = default; DataDefinition& operator=(DataDefinition&& other) noexcept = default;
[[nodiscard]] virtual DataDefinitionType GetType() const = 0;
[[nodiscard]] virtual unsigned GetAlignment() const = 0;
[[nodiscard]] virtual bool GetForceAlignment() const = 0;
[[nodiscard]] virtual unsigned GetSize() const = 0;
[[nodiscard]] std::string GetFullName() const;
std::string m_namespace; std::string m_namespace;
std::string m_name; std::string m_name;
_NODISCARD virtual DataDefinitionType GetType() const = 0;
_NODISCARD virtual unsigned GetAlignment() const = 0;
_NODISCARD virtual bool GetForceAlignment() const = 0;
_NODISCARD virtual unsigned GetSize() const = 0;
_NODISCARD std::string GetFullName() const;
}; };

2
src/ZoneCodeGeneratorLib/Domain/Definition/DeclarationModifier.h
View File

@ -18,5 +18,5 @@ public:
DeclarationModifier& operator=(const DeclarationModifier& other) = default; DeclarationModifier& operator=(const DeclarationModifier& other) = default;
DeclarationModifier& operator=(DeclarationModifier&& other) noexcept = default; DeclarationModifier& operator=(DeclarationModifier&& other) noexcept = default;
_NODISCARD virtual DeclarationModifierType GetType() const = 0; [[nodiscard]] virtual DeclarationModifierType GetType() const = 0;
}; };

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

@ -14,26 +14,6 @@ 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;
// }
unsigned DefinitionWithMembers::GetAlignment() const unsigned DefinitionWithMembers::GetAlignment() const
{ {
assert(m_flags & FLAG_FIELDS_CALCULATED); assert(m_flags & FLAG_FIELDS_CALCULATED);

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

@ -13,6 +13,12 @@ public:
static constexpr int FLAG_FIELDS_CALCULATING = 1 << 1; static constexpr int FLAG_FIELDS_CALCULATING = 1 << 1;
static constexpr int FLAG_ALIGNMENT_FORCED = 1 << 2; static constexpr int FLAG_ALIGNMENT_FORCED = 1 << 2;
DefinitionWithMembers(std::string _namespace, std::string name, unsigned pack);
[[nodiscard]] unsigned GetAlignment() const override;
[[nodiscard]] bool GetForceAlignment() const override;
[[nodiscard]] unsigned GetSize() const override;
unsigned m_flags; unsigned m_flags;
unsigned m_size; unsigned m_size;
unsigned m_alignment; unsigned m_alignment;
@ -24,10 +30,4 @@ public:
unsigned m_alignment_override; unsigned m_alignment_override;
std::vector<std::shared_ptr<Variable>> m_members; std::vector<std::shared_ptr<Variable>> m_members;
DefinitionWithMembers(std::string _namespace, std::string name, unsigned pack);
_NODISCARD unsigned GetAlignment() const override;
_NODISCARD bool GetForceAlignment() const override;
_NODISCARD unsigned GetSize() const override;
}; };

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

@ -10,15 +10,15 @@
class EnumDefinition final : public DataDefinition class EnumDefinition final : public DataDefinition
{ {
public: public:
const BaseTypeDefinition* m_parent_type;
std::vector<std::unique_ptr<EnumMember>> m_members;
EnumDefinition(std::string _namespace, std::string name, const BaseTypeDefinition* parentType); EnumDefinition(std::string _namespace, std::string name, const BaseTypeDefinition* parentType);
_NODISCARD DataDefinitionType GetType() const override; [[nodiscard]] DataDefinitionType GetType() const override;
_NODISCARD unsigned GetAlignment() const override; [[nodiscard]] unsigned GetAlignment() const override;
_NODISCARD bool GetForceAlignment() const override; [[nodiscard]] bool GetForceAlignment() const override;
_NODISCARD unsigned GetSize() const override; [[nodiscard]] unsigned GetSize() const override;
void AddEnumMember(EnumMember enumMember); void AddEnumMember(EnumMember enumMember);
const BaseTypeDefinition* m_parent_type;
std::vector<std::unique_ptr<EnumMember>> m_members;
}; };

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

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

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

@ -5,13 +5,13 @@
class ForwardDeclaration final : public DataDefinition class ForwardDeclaration final : public DataDefinition
{ {
public: public:
const DataDefinitionType m_forwarded_type;
const DataDefinition* m_definition;
ForwardDeclaration(std::string _namespace, std::string name, DataDefinitionType type); ForwardDeclaration(std::string _namespace, std::string name, DataDefinitionType type);
_NODISCARD DataDefinitionType GetType() const override; [[nodiscard]] DataDefinitionType GetType() const override;
_NODISCARD unsigned GetAlignment() const override; [[nodiscard]] unsigned GetAlignment() const override;
_NODISCARD bool GetForceAlignment() const override; [[nodiscard]] bool GetForceAlignment() const override;
_NODISCARD unsigned GetSize() const override; [[nodiscard]] unsigned GetSize() const override;
const DataDefinitionType m_forwarded_type;
const DataDefinition* m_definition;
}; };

22
src/ZoneCodeGeneratorLib/Domain/Definition/PointerDeclarationModifier.h
View File

@ -8,19 +8,19 @@
class PointerDeclarationModifier final : public DeclarationModifier class PointerDeclarationModifier final : public DeclarationModifier
{ {
static const IEvaluation* const DEFAULT_COUNT;
static bool EvaluationIsArray(const IEvaluation* evaluation);
public: public:
[[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;
std::unique_ptr<IEvaluation> m_count_evaluation; std::unique_ptr<IEvaluation> m_count_evaluation;
std::vector<std::unique_ptr<IEvaluation>> m_count_evaluation_by_array_index; std::vector<std::unique_ptr<IEvaluation>> m_count_evaluation_by_array_index;
_NODISCARD DeclarationModifierType GetType() const override; private:
_NODISCARD const IEvaluation* GetCountEvaluation() const; static const IEvaluation* const DEFAULT_COUNT;
_NODISCARD const IEvaluation* GetCountEvaluationForArrayIndex(int index); static bool EvaluationIsArray(const IEvaluation* evaluation);
_NODISCARD bool CountEvaluationIsArray() const;
_NODISCARD bool CountEvaluationIsArray(int index) const;
_NODISCARD bool AnyCountEvaluationIsArray() const;
}; };

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

@ -7,5 +7,5 @@ class StructDefinition final : public DefinitionWithMembers
public: public:
StructDefinition(std::string _namespace, std::string name, int pack); StructDefinition(std::string _namespace, std::string name, int pack);
_NODISCARD DataDefinitionType GetType() const override; [[nodiscard]] DataDefinitionType GetType() const override;
}; };

18
src/ZoneCodeGeneratorLib/Domain/Definition/TypeDeclaration.h
View File

@ -13,21 +13,21 @@ public:
static constexpr int FLAG_FIELDS_CALCULATED = 1 << 0; static constexpr int FLAG_FIELDS_CALCULATED = 1 << 0;
static constexpr int FLAG_ALIGNMENT_FORCED = 1 << 1; static constexpr int FLAG_ALIGNMENT_FORCED = 1 << 1;
unsigned m_flags;
unsigned m_size;
unsigned m_alignment;
explicit TypeDeclaration(const DataDefinition* type); explicit TypeDeclaration(const DataDefinition* type);
[[nodiscard]] unsigned GetSize() const;
[[nodiscard]] unsigned GetAlignment() const;
[[nodiscard]] bool GetForceAlignment() const;
std::vector<std::unique_ptr<DeclarationModifier>> m_declaration_modifiers;
bool m_is_const; bool m_is_const;
bool m_has_custom_bit_size; bool m_has_custom_bit_size;
const DataDefinition* m_type; const DataDefinition* m_type;
unsigned m_custom_bit_size; unsigned m_custom_bit_size;
std::vector<std::unique_ptr<DeclarationModifier>> m_declaration_modifiers; unsigned m_flags;
unsigned m_size;
_NODISCARD unsigned GetSize() const; unsigned m_alignment;
_NODISCARD unsigned GetAlignment() const;
_NODISCARD bool GetForceAlignment() const;
}; };

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

@ -6,14 +6,14 @@
class TypedefDefinition final : public DataDefinition class TypedefDefinition final : public DataDefinition
{ {
public: public:
TypedefDefinition(std::string _namespace, std::string name, std::unique_ptr<TypeDeclaration> typeDeclaration);
[[nodiscard]] DataDefinitionType GetType() const override;
[[nodiscard]] unsigned GetAlignment() const override;
[[nodiscard]] bool GetForceAlignment() const override;
[[nodiscard]] unsigned GetSize() const override;
bool m_has_alignment_override; bool m_has_alignment_override;
unsigned m_alignment_override; unsigned m_alignment_override;
std::unique_ptr<TypeDeclaration> m_type_declaration; std::unique_ptr<TypeDeclaration> m_type_declaration;
TypedefDefinition(std::string _namespace, std::string name, std::unique_ptr<TypeDeclaration> typeDeclaration);
_NODISCARD DataDefinitionType GetType() const override;
_NODISCARD unsigned GetAlignment() const override;
_NODISCARD bool GetForceAlignment() const override;
_NODISCARD unsigned GetSize() const override;
}; };

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

@ -4,11 +4,8 @@
class UnionDefinition final : public DefinitionWithMembers class UnionDefinition final : public DefinitionWithMembers
{ {
// protected:
// void CalculateSize() override;
public: public:
UnionDefinition(std::string _namespace, std::string name, int pack); UnionDefinition(std::string _namespace, std::string name, int pack);
_NODISCARD DataDefinitionType GetType() const override; [[nodiscard]] DataDefinitionType GetType() const override;
}; };

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

@ -9,14 +9,14 @@
class Variable class Variable
{ {
public: public:
Variable(std::string name, std::unique_ptr<TypeDeclaration> typeDeclaration);
[[nodiscard]] unsigned GetAlignment() const;
[[nodiscard]] bool GetForceAlignment() const;
std::string m_name; std::string m_name;
bool m_has_alignment_override; bool m_has_alignment_override;
unsigned m_alignment_override; unsigned m_alignment_override;
unsigned m_offset; unsigned m_offset;
std::unique_ptr<TypeDeclaration> m_type_declaration; std::unique_ptr<TypeDeclaration> m_type_declaration;
Variable(std::string name, std::unique_ptr<TypeDeclaration> typeDeclaration);
_NODISCARD unsigned GetAlignment() const;
_NODISCARD bool GetForceAlignment() const;
}; };

8
src/ZoneCodeGeneratorLib/Domain/Evaluation/IEvaluation.h
View File

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

14
src/ZoneCodeGeneratorLib/Domain/Evaluation/OperandDynamic.h
View File

@ -9,16 +9,16 @@
class OperandDynamic final : public IEvaluation class OperandDynamic final : public IEvaluation
{ {
public: public:
StructureInformation* const m_structure;
std::vector<MemberInformation*> m_referenced_member_chain;
std::vector<std::unique_ptr<IEvaluation>> m_array_indices;
explicit OperandDynamic(StructureInformation* structure); explicit OperandDynamic(StructureInformation* structure);
OperandDynamic(StructureInformation* structure, OperandDynamic(StructureInformation* structure,
std::vector<MemberInformation*> referencedMemberChain, std::vector<MemberInformation*> referencedMemberChain,
std::vector<std::unique_ptr<IEvaluation>> arrayIndices); std::vector<std::unique_ptr<IEvaluation>> arrayIndices);
_NODISCARD EvaluationType GetType() const override; [[nodiscard]] EvaluationType GetType() const override;
_NODISCARD bool IsStatic() const override; [[nodiscard]] bool IsStatic() const override;
_NODISCARD int EvaluateNumeric() const override; [[nodiscard]] int EvaluateNumeric() const override;
StructureInformation* const m_structure;
std::vector<MemberInformation*> m_referenced_member_chain;
std::vector<std::unique_ptr<IEvaluation>> m_array_indices;
}; };

12
src/ZoneCodeGeneratorLib/Domain/Evaluation/OperandStatic.h
View File

@ -6,13 +6,13 @@
class OperandStatic final : public IEvaluation class OperandStatic final : public IEvaluation
{ {
public: public:
const int m_value;
EnumMember* const m_enum_member;
explicit OperandStatic(int value); explicit OperandStatic(int value);
explicit OperandStatic(EnumMember* enumMember); explicit OperandStatic(EnumMember* enumMember);
_NODISCARD EvaluationType GetType() const override; [[nodiscard]] EvaluationType GetType() const override;
_NODISCARD bool IsStatic() const override; [[nodiscard]] bool IsStatic() const override;
_NODISCARD int EvaluateNumeric() const override; [[nodiscard]] int EvaluateNumeric() const override;
const int m_value;
EnumMember* const m_enum_member;
}; };

18
src/ZoneCodeGeneratorLib/Domain/Evaluation/Operation.h
View File

@ -9,17 +9,17 @@
class Operation final : public IEvaluation class Operation final : public IEvaluation
{ {
public: public:
const OperationType* const m_operation_type;
std::unique_ptr<IEvaluation> m_operand1;
std::unique_ptr<IEvaluation> m_operand2;
explicit Operation(const OperationType* type); explicit Operation(const OperationType* type);
Operation(const OperationType* type, std::unique_ptr<IEvaluation> operand1, std::unique_ptr<IEvaluation> operand2); Operation(const OperationType* type, std::unique_ptr<IEvaluation> operand1, std::unique_ptr<IEvaluation> operand2);
_NODISCARD EvaluationType GetType() const override; [[nodiscard]] EvaluationType GetType() const override;
_NODISCARD bool IsStatic() const override; [[nodiscard]] bool IsStatic() const override;
_NODISCARD int EvaluateNumeric() const override; [[nodiscard]] int EvaluateNumeric() const override;
_NODISCARD bool Operand1NeedsParenthesis() const; [[nodiscard]] bool Operand1NeedsParenthesis() const;
_NODISCARD bool Operand2NeedsParenthesis() const; [[nodiscard]] bool Operand2NeedsParenthesis() const;
const OperationType* const m_operation_type;
std::unique_ptr<IEvaluation> m_operand1;
std::unique_ptr<IEvaluation> m_operand2;
}; };

15
src/ZoneCodeGeneratorLib/Domain/Evaluation/OperationType.h
View File

@ -20,14 +20,6 @@ enum class OperationPrecedence
class OperationType class OperationType
{ {
public:
std::string m_syntax;
OperationPrecedence m_precedence;
std::function<int(int operand1, int operand2)> m_evaluation_function;
private:
OperationType(std::string syntax, OperationPrecedence precedence, std::function<int(int, int)> evaluationFunction);
public: public:
static const OperationType* const OPERATION_ADD; static const OperationType* const OPERATION_ADD;
static const OperationType* const OPERATION_SUBTRACT; static const OperationType* const OPERATION_SUBTRACT;
@ -49,4 +41,11 @@ public:
static const OperationType* const OPERATION_OR; static const OperationType* const OPERATION_OR;
static const OperationType* const ALL_OPERATION_TYPES[]; static const OperationType* const ALL_OPERATION_TYPES[];
std::string m_syntax;
OperationPrecedence m_precedence;
std::function<int(int operand1, int operand2)> m_evaluation_function;
private:
OperationType(std::string syntax, OperationPrecedence precedence, std::function<int(int, int)> evaluationFunction);
}; };

4
src/ZoneCodeGeneratorLib/Domain/Extension/CustomAction.h
View File

@ -8,8 +8,8 @@
class CustomAction class CustomAction
{ {
public: public:
CustomAction(std::string actionName, std::vector<DataDefinition*> parameterTypes);
std::string m_action_name; std::string m_action_name;
std::vector<DataDefinition*> m_parameter_types; std::vector<DataDefinition*> m_parameter_types;
CustomAction(std::string actionName, std::vector<DataDefinition*> parameterTypes);
}; };

4
src/ZoneCodeGeneratorLib/Domain/FastFile/FastFileBlock.h
View File

@ -13,10 +13,10 @@ enum class FastFileBlockType
class FastFileBlock class FastFileBlock
{ {
public: public:
FastFileBlock(std::string name, unsigned index, FastFileBlockType type, bool isDefault);
std::string m_name; std::string m_name;
unsigned m_index; unsigned m_index;
FastFileBlockType m_type; FastFileBlockType m_type;
bool m_is_default; bool m_is_default;
FastFileBlock(std::string name, unsigned index, FastFileBlockType type, bool isDefault);
}; };

4
src/ZoneCodeGeneratorLib/Domain/Information/MemberInformation.h
View File

@ -12,6 +12,8 @@ class StructureInformation;
class MemberInformation class MemberInformation
{ {
public: public:
MemberInformation(StructureInformation* parent, StructureInformation* type, Variable* member);
StructureInformation* m_parent; StructureInformation* m_parent;
StructureInformation* m_type; StructureInformation* m_type;
Variable* m_member; Variable* m_member;
@ -24,6 +26,4 @@ public:
std::unique_ptr<CustomAction> m_post_load_action; std::unique_ptr<CustomAction> m_post_load_action;
const FastFileBlock* m_fast_file_block; const FastFileBlock* m_fast_file_block;
const EnumMember* m_asset_ref; const EnumMember* m_asset_ref;
MemberInformation(StructureInformation* parent, StructureInformation* type, Variable* member);
}; };

8
src/ZoneCodeGeneratorLib/Domain/Information/StructureInformation.h
View File

@ -5,13 +5,17 @@
#include "Domain/Extension/CustomAction.h" #include "Domain/Extension/CustomAction.h"
#include "Domain/FastFile/FastFileBlock.h" #include "Domain/FastFile/FastFileBlock.h"
#include "MemberInformation.h" #include "MemberInformation.h"
#include "Utils/ClassUtils.h"
#include <memory>
#include <vector>
class MemberInformation; class MemberInformation;
class StructureInformation class StructureInformation
{ {
public: public:
explicit StructureInformation(DefinitionWithMembers* definition);
DefinitionWithMembers* const m_definition; DefinitionWithMembers* const m_definition;
EnumMember* m_asset_enum_entry; EnumMember* m_asset_enum_entry;
@ -31,6 +35,4 @@ public:
std::unique_ptr<CustomAction> m_post_load_action; std::unique_ptr<CustomAction> m_post_load_action;
const FastFileBlock* m_block; const FastFileBlock* m_block;
std::vector<MemberInformation*> m_name_chain; std::vector<MemberInformation*> m_name_chain;
explicit StructureInformation(DefinitionWithMembers* definition);
}; };

13
src/ZoneCodeGeneratorLib/Generating/CodeGenerator.h
View File

@ -3,21 +3,24 @@
#include "ICodeTemplate.h" #include "ICodeTemplate.h"
#include "ZoneCodeGeneratorArguments.h" #include "ZoneCodeGeneratorArguments.h"
#include <memory>
#include <string>
#include <unordered_map> #include <unordered_map>
class CodeGenerator class CodeGenerator
{ {
const ZoneCodeGeneratorArguments* m_args; public:
explicit CodeGenerator(const ZoneCodeGeneratorArguments* args);
std::unordered_map<std::string, std::unique_ptr<ICodeTemplate>> m_template_mapping; bool GenerateCode(IDataRepository* repository);
private:
void SetupTemplates(); void SetupTemplates();
bool GenerateCodeForTemplate(RenderingContext* context, ICodeTemplate* codeTemplate) const; bool GenerateCodeForTemplate(RenderingContext* context, ICodeTemplate* codeTemplate) const;
static bool GetAssetWithName(IDataRepository* repository, const std::string& name, StructureInformation*& asset); static bool GetAssetWithName(IDataRepository* repository, const std::string& name, StructureInformation*& asset);
public: const ZoneCodeGeneratorArguments* m_args;
explicit CodeGenerator(const ZoneCodeGeneratorArguments* args);
bool GenerateCode(IDataRepository* repository); std::unordered_map<std::string, std::unique_ptr<ICodeTemplate>> m_template_mapping;
}; };

31
src/ZoneCodeGeneratorLib/Generating/RenderingContext.h
View File

@ -10,6 +10,8 @@
class RenderingUsedType class RenderingUsedType
{ {
public: public:
RenderingUsedType(const DataDefinition* type, StructureInformation* info);
bool m_members_loaded; bool m_members_loaded;
const DataDefinition* m_type; const DataDefinition* m_type;
StructureInformation* m_info; StructureInformation* m_info;
@ -20,25 +22,13 @@ public:
bool m_array_reference_exists; bool m_array_reference_exists;
bool m_pointer_array_reference_exists; bool m_pointer_array_reference_exists;
bool m_pointer_array_reference_is_reusable; bool m_pointer_array_reference_is_reusable;
RenderingUsedType(const DataDefinition* type, StructureInformation* info);
}; };
class RenderingContext class RenderingContext
{ {
std::unordered_map<const DataDefinition*, std::unique_ptr<RenderingUsedType>> m_used_types_lookup;
RenderingContext(std::string game, std::vector<const FastFileBlock*> fastFileBlocks);
RenderingUsedType* AddUsedType(std::unique_ptr<RenderingUsedType> usedType);
RenderingUsedType* GetBaseType(const IDataRepository* repository, MemberComputations* computations, RenderingUsedType* usedType);
void AddMembersToContext(const IDataRepository* repository, StructureInformation* info);
void ScanUsedTypeIfNeeded(const IDataRepository* repository, MemberComputations* computations, RenderingUsedType* usedType);
void MakeAsset(const IDataRepository* repository, StructureInformation* asset);
void CreateUsedTypeCollections();
bool UsedTypeHasActions(const RenderingUsedType* usedType) const;
public: public:
static std::unique_ptr<RenderingContext> BuildContext(const IDataRepository* repository, StructureInformation* asset);
std::string m_game; std::string m_game;
std::vector<const FastFileBlock*> m_blocks; std::vector<const FastFileBlock*> m_blocks;
@ -52,5 +42,16 @@ public:
const FastFileBlock* m_default_normal_block; const FastFileBlock* m_default_normal_block;
const FastFileBlock* m_default_temp_block; const FastFileBlock* m_default_temp_block;
static std::unique_ptr<RenderingContext> BuildContext(const IDataRepository* repository, StructureInformation* asset); private:
RenderingContext(std::string game, std::vector<const FastFileBlock*> fastFileBlocks);
RenderingUsedType* AddUsedType(std::unique_ptr<RenderingUsedType> usedType);
RenderingUsedType* GetBaseType(const IDataRepository* repository, MemberComputations* computations, RenderingUsedType* usedType);
void AddMembersToContext(const IDataRepository* repository, StructureInformation* info);
void ScanUsedTypeIfNeeded(const IDataRepository* repository, MemberComputations* computations, RenderingUsedType* usedType);
void MakeAsset(const IDataRepository* repository, StructureInformation* asset);
void CreateUsedTypeCollections();
bool UsedTypeHasActions(const RenderingUsedType* usedType) const;
std::unordered_map<const DataDefinition*, std::unique_ptr<RenderingUsedType>> m_used_types_lookup;
}; };

118
src/ZoneCodeGeneratorLib/Generating/Templates/AssetStructTestsTemplate.cpp
View File

@ -6,69 +6,75 @@
#include <iostream> #include <iostream>
#include <sstream> #include <sstream>
class AssetStructTestsTemplate::Internal final : BaseTemplate namespace
{ {
void TestMethod(StructureInformation* structure) static constexpr int TAG_SOURCE = 1;
{
LINE("TEST_CASE(\"" << m_env.m_game << "::" << m_env.m_asset->m_definition->GetFullName() << ": Tests for " << structure->m_definition->GetFullName()
<< "\", \"[assetstruct]\")")
LINE("{")
m_intendation++;
for (const auto& member : structure->m_ordered_members) class Template final : BaseTemplate
{
public:
Template(std::ostream& stream, RenderingContext* context)
: BaseTemplate(stream, context)
{ {
if (!member->m_member->m_name.empty() && !member->m_member->m_type_declaration->m_has_custom_bit_size) }
void Source()
{
LINE("// ====================================================================")
LINE("// This file has been generated by ZoneCodeGenerator.")
LINE("// Do not modify.")
LINE("// Any changes will be discarded when regenerating.")
LINE("// ====================================================================")
LINE("")
LINE("#include <catch2/catch_test_macros.hpp>")
LINE("#include <catch2/generators/catch_generators.hpp>")
LINE("#include <cstddef>")
LINE("#include \"Game/" << m_env.m_game << "/" << m_env.m_game << ".h\"")
LINE("")
LINE("using namespace " << m_env.m_game << ";")
LINE("")
LINE("namespace game::" << m_env.m_game << "::xassets::asset_" << Lower(m_env.m_asset->m_definition->m_name))
LINE("{")
m_intendation++;
TestMethod(m_env.m_asset);
for (auto* structure : m_env.m_used_structures)
{ {
LINE("REQUIRE(offsetof(" << structure->m_definition->GetFullName() << ", " << member->m_member->m_name << ") == " << member->m_member->m_offset StructureComputations computations(structure->m_info);
<< ");") if (!structure->m_info->m_definition->m_anonymous && !computations.IsAsset())
TestMethod(structure->m_info);
} }
m_intendation--;
LINE("}")
} }
LINE("") private:
void TestMethod(StructureInformation* structure)
LINE("REQUIRE(" << structure->m_definition->GetSize() << "u == sizeof(" << structure->m_definition->GetFullName() << "));")
LINE("REQUIRE(" << structure->m_definition->GetAlignment() << "u == alignof(" << structure->m_definition->GetFullName() << "));")
m_intendation--;
LINE("}")
}
public:
Internal(std::ostream& stream, RenderingContext* context)
: BaseTemplate(stream, context)
{
}
void Source()
{
LINE("// ====================================================================")
LINE("// This file has been generated by ZoneCodeGenerator.")
LINE("// Do not modify.")
LINE("// Any changes will be discarded when regenerating.")
LINE("// ====================================================================")
LINE("")
LINE("#include <catch2/catch_test_macros.hpp>")
LINE("#include <catch2/generators/catch_generators.hpp>")
LINE("#include <cstddef>")
LINE("#include \"Game/" << m_env.m_game << "/" << m_env.m_game << ".h\"")
LINE("")
LINE("using namespace " << m_env.m_game << ";")
LINE("")
LINE("namespace game::" << m_env.m_game << "::xassets::asset_" << Lower(m_env.m_asset->m_definition->m_name))
LINE("{")
m_intendation++;
TestMethod(m_env.m_asset);
for (auto* structure : m_env.m_used_structures)
{ {
StructureComputations computations(structure->m_info); LINE("TEST_CASE(\"" << m_env.m_game << "::" << m_env.m_asset->m_definition->GetFullName() << ": Tests for "
if (!structure->m_info->m_definition->m_anonymous && !computations.IsAsset()) << structure->m_definition->GetFullName() << "\", \"[assetstruct]\")")
TestMethod(structure->m_info); LINE("{")
} m_intendation++;
m_intendation--; for (const auto& member : structure->m_ordered_members)
LINE("}") {
} if (!member->m_member->m_name.empty() && !member->m_member->m_type_declaration->m_has_custom_bit_size)
}; {
LINE("REQUIRE(offsetof(" << structure->m_definition->GetFullName() << ", " << member->m_member->m_name
<< ") == " << member->m_member->m_offset << ");")
}
}
LINE("")
LINE("REQUIRE(" << structure->m_definition->GetSize() << "u == sizeof(" << structure->m_definition->GetFullName() << "));")
LINE("REQUIRE(" << structure->m_definition->GetAlignment() << "u == alignof(" << structure->m_definition->GetFullName() << "));")
m_intendation--;
LINE("}")
}
};
} // namespace
std::vector<CodeTemplateFile> AssetStructTestsTemplate::GetFilesToRender(RenderingContext* context) std::vector<CodeTemplateFile> AssetStructTestsTemplate::GetFilesToRender(RenderingContext* context)
{ {
@ -89,10 +95,10 @@ std::vector<CodeTemplateFile> AssetStructTestsTemplate::GetFilesToRender(Renderi
void AssetStructTestsTemplate::RenderFile(std::ostream& stream, const int fileTag, RenderingContext* context) void AssetStructTestsTemplate::RenderFile(std::ostream& stream, const int fileTag, RenderingContext* context)
{ {
Internal internal(stream, context); Template t(stream, context);
if (fileTag == TAG_SOURCE) if (fileTag == TAG_SOURCE)
internal.Source(); t.Source();
else else
std::cout << "Invalid tag in AssetStructTestsTemplate\n"; std::cout << "Invalid tag in AssetStructTestsTemplate\n";
} }

4
src/ZoneCodeGeneratorLib/Generating/Templates/AssetStructTestsTemplate.h
View File

@ -3,10 +3,6 @@
class AssetStructTestsTemplate final : public ICodeTemplate class AssetStructTestsTemplate final : public ICodeTemplate
{ {
static constexpr int TAG_SOURCE = 1;
class Internal;
public: public:
std::vector<CodeTemplateFile> GetFilesToRender(RenderingContext* context) override; std::vector<CodeTemplateFile> GetFilesToRender(RenderingContext* context) override;
void RenderFile(std::ostream& stream, int fileTag, RenderingContext* context) override; void RenderFile(std::ostream& stream, int fileTag, RenderingContext* context) override;

33
src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.h
View File

@ -15,27 +15,10 @@ class BaseTemplate
protected: protected:
static constexpr const char* INTENDATION = " "; static constexpr const char* INTENDATION = " ";
std::ostream& m_out;
RenderingContext& m_env;
unsigned m_intendation;
BaseTemplate(std::ostream& stream, RenderingContext* context); BaseTemplate(std::ostream& stream, RenderingContext* context);
void DoIntendation() const; void DoIntendation() const;
private:
static void MakeSafeTypeNameInternal(const DataDefinition* def, std::ostringstream& str);
static void MakeTypeVarNameInternal(const DataDefinition* def, std::ostringstream& str);
static void MakeTypeWrittenVarNameInternal(const DataDefinition* def, std::ostringstream& str);
static void MakeTypePtrVarNameInternal(const DataDefinition* def, std::ostringstream& str);
static void MakeTypeWrittenPtrVarNameInternal(const DataDefinition* def, std::ostringstream& str);
static void MakeArrayIndicesInternal(const DeclarationModifierComputations& modifierComputations, std::ostringstream& str);
static void MakeOperandStatic(const OperandStatic* op, std::ostringstream& str);
static void MakeOperandDynamic(const OperandDynamic* op, std::ostringstream& str);
static void MakeOperation(const Operation* operation, std::ostringstream& str);
static void MakeEvaluationInternal(const IEvaluation* evaluation, std::ostringstream& str);
protected:
static std::string Upper(std::string str); static std::string Upper(std::string str);
static std::string Lower(std::string str); static std::string Lower(std::string str);
static std::string MakeTypeVarName(const DataDefinition* def); static std::string MakeTypeVarName(const DataDefinition* def);
@ -55,6 +38,22 @@ protected:
static std::string MakeCustomActionCall(CustomAction* action); static std::string MakeCustomActionCall(CustomAction* action);
static std::string MakeArrayCount(const ArrayDeclarationModifier* arrayModifier); static std::string MakeArrayCount(const ArrayDeclarationModifier* arrayModifier);
static std::string MakeEvaluation(const IEvaluation* evaluation); static std::string MakeEvaluation(const IEvaluation* evaluation);
std::ostream& m_out;
RenderingContext& m_env;
unsigned m_intendation;
private:
static void MakeSafeTypeNameInternal(const DataDefinition* def, std::ostringstream& str);
static void MakeTypeVarNameInternal(const DataDefinition* def, std::ostringstream& str);
static void MakeTypeWrittenVarNameInternal(const DataDefinition* def, std::ostringstream& str);
static void MakeTypePtrVarNameInternal(const DataDefinition* def, std::ostringstream& str);
static void MakeTypeWrittenPtrVarNameInternal(const DataDefinition* def, std::ostringstream& str);
static void MakeArrayIndicesInternal(const DeclarationModifierComputations& modifierComputations, std::ostringstream& str);
static void MakeOperandStatic(const OperandStatic* op, std::ostringstream& str);
static void MakeOperandDynamic(const OperandDynamic* op, std::ostringstream& str);
static void MakeOperation(const Operation* operation, std::ostringstream& str);
static void MakeEvaluationInternal(const IEvaluation* evaluation, std::ostringstream& str);
}; };
#define LINE(x) \ #define LINE(x) \

2458
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp
View File

File diff suppressed because it is too large Load Diff

5
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.h
View File

@ -3,11 +3,6 @@
class ZoneLoadTemplate final : public ICodeTemplate class ZoneLoadTemplate final : public ICodeTemplate
{ {
static constexpr int TAG_HEADER = 1;
static constexpr int TAG_SOURCE = 2;
class Internal;
public: public:
std::vector<CodeTemplateFile> GetFilesToRender(RenderingContext* context) override; std::vector<CodeTemplateFile> GetFilesToRender(RenderingContext* context) override;
void RenderFile(std::ostream& stream, int fileTag, RenderingContext* context) override; void RenderFile(std::ostream& stream, int fileTag, RenderingContext* context) override;

1420
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneMarkTemplate.cpp
View File

File diff suppressed because it is too large Load Diff

5
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneMarkTemplate.h
View File

@ -3,11 +3,6 @@
class ZoneMarkTemplate final : public ICodeTemplate class ZoneMarkTemplate final : public ICodeTemplate
{ {
static constexpr int TAG_HEADER = 1;
static constexpr int TAG_SOURCE = 2;
class Internal;
public: public:
std::vector<CodeTemplateFile> GetFilesToRender(RenderingContext* context) override; std::vector<CodeTemplateFile> GetFilesToRender(RenderingContext* context) override;
void RenderFile(std::ostream& stream, int fileTag, RenderingContext* context) override; void RenderFile(std::ostream& stream, int fileTag, RenderingContext* context) override;

2209
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.cpp
View File

File diff suppressed because it is too large Load Diff

5
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.h
View File

@ -3,11 +3,6 @@
class ZoneWriteTemplate final : public ICodeTemplate class ZoneWriteTemplate final : public ICodeTemplate
{ {
static constexpr int TAG_HEADER = 1;
static constexpr int TAG_SOURCE = 2;
class Internal;
public: public:
std::vector<CodeTemplateFile> GetFilesToRender(RenderingContext* context) override; std::vector<CodeTemplateFile> GetFilesToRender(RenderingContext* context) override;
void RenderFile(std::ostream& stream, int fileTag, RenderingContext* context) override; void RenderFile(std::ostream& stream, int fileTag, RenderingContext* context) override;

14
src/ZoneCodeGeneratorLib/Parsing/Commands/CommandsFileReader.cpp
View File

@ -17,6 +17,12 @@
#include <chrono> #include <chrono>
#include <iostream> #include <iostream>
namespace
{
static constexpr const char* ZONE_CODE_GENERATOR_DEFINE_NAME = "__zonecodegenerator";
static constexpr const char* ZONE_CODE_GENERATOR_DEFINE_VALUE = "1";
} // namespace
CommandsFileReader::CommandsFileReader(const ZoneCodeGeneratorArguments* args, std::string filename) CommandsFileReader::CommandsFileReader(const ZoneCodeGeneratorArguments* args, std::string filename)
: m_args(args), : m_args(args),
m_filename(std::move(filename)), m_filename(std::move(filename)),
@ -30,7 +36,7 @@ bool CommandsFileReader::OpenBaseStream()
auto stream = std::make_unique<ParserFilesystemStream>(m_filename); auto stream = std::make_unique<ParserFilesystemStream>(m_filename);
if (!stream->IsOpen()) if (!stream->IsOpen())
{ {
std::cout << "Could not open commands file\n"; std::cerr << "Could not open commands file\n";
return false; return false;
} }
@ -68,7 +74,7 @@ bool CommandsFileReader::ReadCommandsFile(IDataRepository* repository)
{ {
if (m_args->m_verbose) if (m_args->m_verbose)
{ {
std::cout << "Reading commands file: " << m_filename << "\n"; std::cout << std::format("Reading commands file: {}\n", m_filename);
} }
if (!OpenBaseStream()) if (!OpenBaseStream())
@ -84,9 +90,7 @@ bool CommandsFileReader::ReadCommandsFile(IDataRepository* repository)
const auto end = std::chrono::steady_clock::now(); const auto end = std::chrono::steady_clock::now();
if (m_args->m_verbose) if (m_args->m_verbose)
{ std::cout << std::format("Processing commands took {}ms\n", std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count());
std::cout << "Processing commands took " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms\n";
}
if (!result) if (!result)
return false; return false;

20
src/ZoneCodeGeneratorLib/Parsing/Commands/CommandsFileReader.h
View File

@ -9,8 +9,15 @@
class CommandsFileReader class CommandsFileReader
{ {
static constexpr const char* ZONE_CODE_GENERATOR_DEFINE_NAME = "__zonecodegenerator"; public:
static constexpr const char* ZONE_CODE_GENERATOR_DEFINE_VALUE = "1"; CommandsFileReader(const ZoneCodeGeneratorArguments* args, std::string filename);
bool ReadCommandsFile(IDataRepository* repository);
private:
bool OpenBaseStream();
void SetupStreamProxies();
void SetupPostProcessors();
const ZoneCodeGeneratorArguments* m_args; const ZoneCodeGeneratorArguments* m_args;
std::string m_filename; std::string m_filename;
@ -19,13 +26,4 @@ class CommandsFileReader
IParserLineStream* m_stream; IParserLineStream* m_stream;
std::vector<std::unique_ptr<IPostProcessor>> m_post_processors; std::vector<std::unique_ptr<IPostProcessor>> m_post_processors;
bool OpenBaseStream();
void SetupStreamProxies();
void SetupPostProcessors();
public:
explicit CommandsFileReader(const ZoneCodeGeneratorArguments* args, std::string filename);
bool ReadCommandsFile(IDataRepository* repository);
}; };

6
src/ZoneCodeGeneratorLib/Parsing/Commands/Impl/CommandsLexer.h
View File

@ -5,9 +5,9 @@
class CommandsLexer final : public AbstractLexer<CommandsParserValue> class CommandsLexer final : public AbstractLexer<CommandsParserValue>
{ {
protected:
CommandsParserValue GetNextToken() override;
public: public:
explicit CommandsLexer(IParserLineStream* stream); explicit CommandsLexer(IParserLineStream* stream);
protected:
CommandsParserValue GetNextToken() override;
}; };

7
src/ZoneCodeGeneratorLib/Parsing/Commands/Impl/CommandsParser.h
View File

@ -8,11 +8,12 @@
class CommandsParser final : public AbstractParser<CommandsParserValue, CommandsParserState> class CommandsParser final : public AbstractParser<CommandsParserValue, CommandsParserState>
{ {
IDataRepository* m_repository; public:
CommandsParser(CommandsLexer* lexer, IDataRepository* targetRepository);
protected: protected:
const std::vector<sequence_t*>& GetTestsForState() override; const std::vector<sequence_t*>& GetTestsForState() override;
public: private:
CommandsParser(CommandsLexer* lexer, IDataRepository* targetRepository); IDataRepository* m_repository;
}; };

34
src/ZoneCodeGeneratorLib/Parsing/Commands/Impl/CommandsParserState.h
View File

@ -1,16 +1,28 @@
#pragma once #pragma once
#include "Persistence/IDataRepository.h" #include "Persistence/IDataRepository.h"
#include "Utils/ClassUtils.h"
#include <memory> #include <memory>
#include <string> #include <string>
class CommandsParserState class CommandsParserState
{ {
IDataRepository* m_repository; public:
StructureInformation* m_in_use; explicit CommandsParserState(IDataRepository* repository);
[[nodiscard]] const IDataRepository* GetRepository() const;
void AddBlock(std::unique_ptr<FastFileBlock> block) const;
void SetArchitecture(Architecture architecture) const;
void SetGame(std::string gameName) const;
[[nodiscard]] StructureInformation* GetInUse() const;
void SetInUse(StructureInformation* structure);
bool GetMembersFromTypename(const std::string& typeNameValue, StructureInformation* baseType, std::vector<MemberInformation*>& members) const;
bool GetTypenameAndMembersFromTypename(const std::string& typeNameValue, StructureInformation*& structure, std::vector<MemberInformation*>& members) const;
private:
static MemberInformation* GetMemberWithName(const std::string& memberName, StructureInformation* type); static MemberInformation* GetMemberWithName(const std::string& memberName, StructureInformation* type);
static bool GetNextTypenameSeparatorPos(const std::string& typeNameValue, unsigned startPos, unsigned& separatorPos); static bool GetNextTypenameSeparatorPos(const std::string& typeNameValue, unsigned startPos, unsigned& separatorPos);
static bool ExtractMembersFromTypenameInternal(const std::string& typeNameValue, static bool ExtractMembersFromTypenameInternal(const std::string& typeNameValue,
@ -18,18 +30,6 @@ class CommandsParserState
StructureInformation* type, StructureInformation* type,
std::vector<MemberInformation*>& members); std::vector<MemberInformation*>& members);
public: IDataRepository* m_repository;
explicit CommandsParserState(IDataRepository* repository); StructureInformation* m_in_use;
_NODISCARD const IDataRepository* GetRepository() const;
void AddBlock(std::unique_ptr<FastFileBlock> block) const;
void SetArchitecture(Architecture architecture) const;
void SetGame(std::string gameName) const;
_NODISCARD StructureInformation* GetInUse() const;
void SetInUse(StructureInformation* structure);
bool GetMembersFromTypename(const std::string& typeNameValue, StructureInformation* baseType, std::vector<MemberInformation*>& members) const;
bool GetTypenameAndMembersFromTypename(const std::string& typeNameValue, StructureInformation*& structure, std::vector<MemberInformation*>& members) const;
}; };

37
src/ZoneCodeGeneratorLib/Parsing/Commands/Impl/CommandsParserValue.h
View File

@ -52,10 +52,6 @@ enum class CommandsParserValueType
class CommandsParserValue final : public IParserValue class CommandsParserValue final : public IParserValue
{ {
public: public:
TokenPos m_pos;
CommandsParserValueType m_type;
size_t m_hash;
union ValueType union ValueType
{ {
char char_value; char char_value;
@ -83,25 +79,28 @@ public:
static CommandsParserValue TypeName(TokenPos pos, std::string* typeName); static CommandsParserValue TypeName(TokenPos pos, std::string* typeName);
static CommandsParserValue OpType(TokenPos pos, const OperationType* operationType); static CommandsParserValue OpType(TokenPos pos, const OperationType* operationType);
private:
CommandsParserValue(TokenPos pos, CommandsParserValueType type);
public:
~CommandsParserValue() override;
CommandsParserValue(const CommandsParserValue& other) = delete; CommandsParserValue(const CommandsParserValue& other) = delete;
~CommandsParserValue() override;
CommandsParserValue(CommandsParserValue&& other) noexcept; CommandsParserValue(CommandsParserValue&& other) noexcept;
CommandsParserValue& operator=(const CommandsParserValue& other) = delete; CommandsParserValue& operator=(const CommandsParserValue& other) = delete;
CommandsParserValue& operator=(CommandsParserValue&& other) noexcept; CommandsParserValue& operator=(CommandsParserValue&& other) noexcept;
_NODISCARD bool IsEof() const override; [[nodiscard]] bool IsEof() const override;
_NODISCARD const TokenPos& GetPos() const override; [[nodiscard]] const TokenPos& GetPos() const override;
_NODISCARD char CharacterValue() const; [[nodiscard]] char CharacterValue() const;
_NODISCARD int IntegerValue() const; [[nodiscard]] int IntegerValue() const;
_NODISCARD double FloatingPointValue() const; [[nodiscard]] double FloatingPointValue() const;
_NODISCARD std::string& StringValue() const; [[nodiscard]] std::string& StringValue() const;
_NODISCARD std::string& IdentifierValue() const; [[nodiscard]] std::string& IdentifierValue() const;
_NODISCARD size_t IdentifierHash() const; [[nodiscard]] size_t IdentifierHash() const;
_NODISCARD std::string& TypeNameValue() const; [[nodiscard]] std::string& TypeNameValue() const;
_NODISCARD const OperationType* OpTypeValue() const; [[nodiscard]] const OperationType* OpTypeValue() const;
TokenPos m_pos;
CommandsParserValueType m_type;
size_t m_hash;
private:
CommandsParserValue(TokenPos pos, CommandsParserValueType type);
}; };

7
src/ZoneCodeGeneratorLib/Parsing/Commands/Matcher/CommandsMatcherCharacter.h
View File

@ -5,11 +5,12 @@
class CommandsMatcherCharacter final : public AbstractMatcher<CommandsParserValue> class CommandsMatcherCharacter final : public AbstractMatcher<CommandsParserValue>
{ {
char m_char; public:
explicit CommandsMatcherCharacter(char c);
protected: protected:
MatcherResult<CommandsParserValue> CanMatch(ILexer<CommandsParserValue>* lexer, unsigned tokenOffset) override; MatcherResult<CommandsParserValue> CanMatch(ILexer<CommandsParserValue>* lexer, unsigned tokenOffset) override;
public: private:
explicit CommandsMatcherCharacter(char c); char m_char;
}; };

12
src/ZoneCodeGeneratorLib/Parsing/Commands/Matcher/CommandsMatcherFactory.h
View File

@ -10,10 +10,10 @@ class CommandsMatcherFactory final : public AbstractMatcherFactory<CommandsParse
public: public:
explicit CommandsMatcherFactory(const IMatcherForLabelSupplier<CommandsParserValue>* labelSupplier); explicit CommandsMatcherFactory(const IMatcherForLabelSupplier<CommandsParserValue>* labelSupplier);
_NODISCARD MatcherFactoryWrapper<CommandsParserValue> Type(CommandsParserValueType type) const; [[nodiscard]] MatcherFactoryWrapper<CommandsParserValue> Type(CommandsParserValueType type) const;
_NODISCARD MatcherFactoryWrapper<CommandsParserValue> Keyword(std::string value) const; [[nodiscard]] MatcherFactoryWrapper<CommandsParserValue> Keyword(std::string value) const;
_NODISCARD MatcherFactoryWrapper<CommandsParserValue> Identifier() const; [[nodiscard]] MatcherFactoryWrapper<CommandsParserValue> Identifier() const;
_NODISCARD MatcherFactoryWrapper<CommandsParserValue> Integer() const; [[nodiscard]] MatcherFactoryWrapper<CommandsParserValue> Integer() const;
_NODISCARD MatcherFactoryWrapper<CommandsParserValue> FloatingPoint() const; [[nodiscard]] MatcherFactoryWrapper<CommandsParserValue> FloatingPoint() const;
_NODISCARD MatcherFactoryWrapper<CommandsParserValue> Char(char c) const; [[nodiscard]] MatcherFactoryWrapper<CommandsParserValue> Char(char c) const;
}; };

9
src/ZoneCodeGeneratorLib/Parsing/Commands/Matcher/CommandsMatcherKeyword.h
View File

@ -7,12 +7,13 @@
class CommandsMatcherKeyword final : public AbstractMatcher<CommandsParserValue> class CommandsMatcherKeyword final : public AbstractMatcher<CommandsParserValue>
{ {
size_t m_hash; public:
std::string m_value; explicit CommandsMatcherKeyword(std::string value);
protected: protected:
MatcherResult<CommandsParserValue> CanMatch(ILexer<CommandsParserValue>* lexer, unsigned tokenOffset) override; MatcherResult<CommandsParserValue> CanMatch(ILexer<CommandsParserValue>* lexer, unsigned tokenOffset) override;
public: private:
explicit CommandsMatcherKeyword(std::string value); size_t m_hash;
std::string m_value;
}; };

7
src/ZoneCodeGeneratorLib/Parsing/Commands/Matcher/CommandsMatcherValueType.h
View File

@ -5,11 +5,12 @@
class CommandsMatcherValueType final : public AbstractMatcher<CommandsParserValue> class CommandsMatcherValueType final : public AbstractMatcher<CommandsParserValue>
{ {
CommandsParserValueType m_type; public:
explicit CommandsMatcherValueType(CommandsParserValueType type);
protected: protected:
MatcherResult<CommandsParserValue> CanMatch(ILexer<CommandsParserValue>* lexer, unsigned tokenOffset) override; MatcherResult<CommandsParserValue> CanMatch(ILexer<CommandsParserValue>* lexer, unsigned tokenOffset) override;
public: private:
explicit CommandsMatcherValueType(CommandsParserValueType type); CommandsParserValueType m_type;
}; };

9
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceAction.cpp
View File

@ -3,6 +3,15 @@
#include "Parsing/Commands/Matcher/CommandsCommonMatchers.h" #include "Parsing/Commands/Matcher/CommandsCommonMatchers.h"
#include "Parsing/Commands/Matcher/CommandsMatcherFactory.h" #include "Parsing/Commands/Matcher/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_ACTION_NAME = 1;
static constexpr auto CAPTURE_TYPE = 2;
static constexpr auto CAPTURE_ARG_TYPE = 3;
static constexpr auto LABEL_ACTION_ARGS = 1;
} // namespace
SequenceAction::SequenceAction() SequenceAction::SequenceAction()
{ {
const CommandsMatcherFactory create(this); const CommandsMatcherFactory create(this);

10
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceAction.h
View File

@ -4,15 +4,9 @@
class SequenceAction final : public CommandsParser::sequence_t class SequenceAction final : public CommandsParser::sequence_t
{ {
static constexpr auto CAPTURE_ACTION_NAME = 1; public:
static constexpr auto CAPTURE_TYPE = 2; SequenceAction();
static constexpr auto CAPTURE_ARG_TYPE = 3;
static constexpr auto LABEL_ACTION_ARGS = 1;
protected: protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override; void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public:
SequenceAction();
}; };

5
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceAllocAlign.cpp
View File

@ -3,6 +3,11 @@
#include "Parsing/Commands/Matcher/CommandsCommonMatchers.h" #include "Parsing/Commands/Matcher/CommandsCommonMatchers.h"
#include "Parsing/Commands/Matcher/CommandsMatcherFactory.h" #include "Parsing/Commands/Matcher/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_TYPE = 1;
}
SequenceAllocAlign::SequenceAllocAlign() SequenceAllocAlign::SequenceAllocAlign()
{ {
const CommandsMatcherFactory create(this); const CommandsMatcherFactory create(this);

6
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceAllocAlign.h
View File

@ -4,11 +4,9 @@
class SequenceAllocAlign final : public CommandsParser::sequence_t class SequenceAllocAlign final : public CommandsParser::sequence_t
{ {
static constexpr auto CAPTURE_TYPE = 1; public:
SequenceAllocAlign();
protected: protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override; void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public:
SequenceAllocAlign();
}; };

5
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceArchitecture.cpp
View File

@ -3,6 +3,11 @@
#include "Parsing/Commands/Matcher/CommandsCommonMatchers.h" #include "Parsing/Commands/Matcher/CommandsCommonMatchers.h"
#include "Parsing/Commands/Matcher/CommandsMatcherFactory.h" #include "Parsing/Commands/Matcher/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_ARCHITECTURE = 1;
}
SequenceArchitecture::SequenceArchitecture() SequenceArchitecture::SequenceArchitecture()
{ {
const CommandsMatcherFactory create(this); const CommandsMatcherFactory create(this);

11
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceArchitecture.h
View File

@ -2,15 +2,16 @@
#include "Parsing/Commands/Impl/CommandsParser.h" #include "Parsing/Commands/Impl/CommandsParser.h"
#include <unordered_map>
class SequenceArchitecture final : public CommandsParser::sequence_t class SequenceArchitecture final : public CommandsParser::sequence_t
{ {
static constexpr auto CAPTURE_ARCHITECTURE = 1; public:
SequenceArchitecture();
std::unordered_map<std::string, Architecture> m_architecture_mapping;
protected: protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override; void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public: private:
SequenceArchitecture(); std::unordered_map<std::string, Architecture> m_architecture_mapping;
}; };

5
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceArrayCount.cpp
View File

@ -4,6 +4,11 @@
#include "Parsing/Commands/Matcher/CommandsCommonMatchers.h" #include "Parsing/Commands/Matcher/CommandsCommonMatchers.h"
#include "Parsing/Commands/Matcher/CommandsMatcherFactory.h" #include "Parsing/Commands/Matcher/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_TYPE = 1;
}
SequenceArrayCount::SequenceArrayCount() SequenceArrayCount::SequenceArrayCount()
{ {
const CommandsMatcherFactory create(this); const CommandsMatcherFactory create(this);

6
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceArrayCount.h
View File

@ -4,11 +4,9 @@
class SequenceArrayCount final : public CommandsParser::sequence_t class SequenceArrayCount final : public CommandsParser::sequence_t
{ {
static constexpr auto CAPTURE_TYPE = 1; public:
SequenceArrayCount();
protected: protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override; void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public:
SequenceArrayCount();
}; };

6
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceArraySize.cpp
View File

@ -4,6 +4,12 @@
#include "Parsing/Commands/Matcher/CommandsCommonMatchers.h" #include "Parsing/Commands/Matcher/CommandsCommonMatchers.h"
#include "Parsing/Commands/Matcher/CommandsMatcherFactory.h" #include "Parsing/Commands/Matcher/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_TYPE = 1;
static constexpr auto CAPTURE_EVALUATION = 2;
} // namespace
SequenceArraySize::SequenceArraySize() SequenceArraySize::SequenceArraySize()
{ {
const CommandsMatcherFactory create(this); const CommandsMatcherFactory create(this);

7
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceArraySize.h
View File

@ -4,12 +4,9 @@
class SequenceArraySize final : public CommandsParser::sequence_t class SequenceArraySize final : public CommandsParser::sequence_t
{ {
static constexpr auto CAPTURE_TYPE = 1; public:
static constexpr auto CAPTURE_EVALUATION = 2; SequenceArraySize();
protected: protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override; void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public:
SequenceArraySize();
}; };

6
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceAsset.cpp
View File

@ -3,6 +3,12 @@
#include "Parsing/Commands/Matcher/CommandsCommonMatchers.h" #include "Parsing/Commands/Matcher/CommandsCommonMatchers.h"
#include "Parsing/Commands/Matcher/CommandsMatcherFactory.h" #include "Parsing/Commands/Matcher/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_TYPE = 1;
static constexpr auto CAPTURE_ENUM_ENTRY = 2;
} // namespace
SequenceAsset::SequenceAsset() SequenceAsset::SequenceAsset()
{ {
const CommandsMatcherFactory create(this); const CommandsMatcherFactory create(this);

7
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceAsset.h
View File

@ -4,12 +4,9 @@
class SequenceAsset final : public CommandsParser::sequence_t class SequenceAsset final : public CommandsParser::sequence_t
{ {
static constexpr auto CAPTURE_TYPE = 1; public:
static constexpr auto CAPTURE_ENUM_ENTRY = 2; SequenceAsset();
protected: protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override; void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public:
SequenceAsset();
}; };

8
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceAssetRef.cpp
View File

@ -5,6 +5,14 @@
#include <algorithm> #include <algorithm>
namespace
{
static constexpr auto TAG_DEFAULT = 1;
static constexpr auto CAPTURE_TYPE = 1;
static constexpr auto CAPTURE_ASSET_TYPE_ENUM_ENTRY = 2;
} // namespace
SequenceAssetRef::SequenceAssetRef() SequenceAssetRef::SequenceAssetRef()
{ {
const CommandsMatcherFactory create(this); const CommandsMatcherFactory create(this);

9
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceAssetRef.h
View File

@ -4,14 +4,9 @@
class SequenceAssetRef final : public CommandsParser::sequence_t class SequenceAssetRef final : public CommandsParser::sequence_t
{ {
static constexpr auto TAG_DEFAULT = 1; public:
SequenceAssetRef();
static constexpr auto CAPTURE_TYPE = 1;
static constexpr auto CAPTURE_ASSET_TYPE_ENUM_ENTRY = 2;
protected: protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override; void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public:
SequenceAssetRef();
}; };

8
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceBlock.cpp
View File

@ -3,6 +3,14 @@
#include "Parsing/Commands/Matcher/CommandsCommonMatchers.h" #include "Parsing/Commands/Matcher/CommandsCommonMatchers.h"
#include "Parsing/Commands/Matcher/CommandsMatcherFactory.h" #include "Parsing/Commands/Matcher/CommandsMatcherFactory.h"
namespace
{
static constexpr auto TAG_DEFAULT = 1;
static constexpr auto CAPTURE_BLOCK_ENUM_ENTRY = 1;
static constexpr auto CAPTURE_BLOCK_TYPE = 2;
} // namespace
SequenceBlock::SequenceBlock() SequenceBlock::SequenceBlock()
{ {
const CommandsMatcherFactory create(this); const CommandsMatcherFactory create(this);

18
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceBlock.h
View File

@ -7,19 +7,15 @@
class SequenceBlock final : public CommandsParser::sequence_t class SequenceBlock final : public CommandsParser::sequence_t
{ {
static constexpr auto TAG_DEFAULT = 1; public:
SequenceBlock();
static constexpr auto CAPTURE_BLOCK_ENUM_ENTRY = 1;
static constexpr auto CAPTURE_BLOCK_TYPE = 2;
std::unordered_map<std::string, FastFileBlockType> m_type_lookup;
void AddFastFileBlockToLookup(std::string name, FastFileBlockType type);
_NODISCARD bool GetFastFileBlockNameByType(const std::string& name, FastFileBlockType& type) const;
protected: protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override; void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public: private:
SequenceBlock(); void AddFastFileBlockToLookup(std::string name, FastFileBlockType type);
[[nodiscard]] bool GetFastFileBlockNameByType(const std::string& name, FastFileBlockType& type) const;
std::unordered_map<std::string, FastFileBlockType> m_type_lookup;
}; };

10
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceCondition.cpp
View File

@ -4,6 +4,16 @@
#include "Parsing/Commands/Matcher/CommandsCommonMatchers.h" #include "Parsing/Commands/Matcher/CommandsCommonMatchers.h"
#include "Parsing/Commands/Matcher/CommandsMatcherFactory.h" #include "Parsing/Commands/Matcher/CommandsMatcherFactory.h"
namespace
{
static constexpr auto TAG_ALWAYS = 1;
static constexpr auto TAG_NEVER = 2;
static constexpr auto TAG_EVALUATION = 3;
static constexpr auto CAPTURE_TYPE = 1;
static constexpr auto CAPTURE_EVALUATION = 2;
} // namespace
SequenceCondition::SequenceCondition() SequenceCondition::SequenceCondition()
{ {
const CommandsMatcherFactory create(this); const CommandsMatcherFactory create(this);

11
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceCondition.h
View File

@ -4,16 +4,9 @@
class SequenceCondition final : public CommandsParser::sequence_t class SequenceCondition final : public CommandsParser::sequence_t
{ {
static constexpr auto TAG_ALWAYS = 1; public:
static constexpr auto TAG_NEVER = 2; SequenceCondition();
static constexpr auto TAG_EVALUATION = 3;
static constexpr auto CAPTURE_TYPE = 1;
static constexpr auto CAPTURE_EVALUATION = 2;
protected: protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override; void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public:
SequenceCondition();
}; };

128
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceCount.cpp
View File

@ -5,6 +5,76 @@
#include "Parsing/Commands/Matcher/CommandsCommonMatchers.h" #include "Parsing/Commands/Matcher/CommandsCommonMatchers.h"
#include "Parsing/Commands/Matcher/CommandsMatcherFactory.h" #include "Parsing/Commands/Matcher/CommandsMatcherFactory.h"
#include <memory>
#include <vector>
namespace
{
static constexpr auto TAG_POINTER_RESOLVE = 1;
static constexpr auto CAPTURE_START = 1;
static constexpr auto CAPTURE_TYPE = 2;
static constexpr auto CAPTURE_ARRAY_INDEX = 3;
void SetCountByArrayIndex(CommandsParserState* state,
SequenceResult<CommandsParserValue>& result,
MemberInformation* member,
PointerDeclarationModifier* pointer,
std::unique_ptr<IEvaluation> evaluation)
{
std::vector<int> arraySizes;
std::vector<int> depthSize;
for (const auto& modifier : member->m_member->m_type_declaration->m_declaration_modifiers)
{
if (modifier->GetType() == DeclarationModifierType::ARRAY)
arraySizes.push_back(dynamic_cast<ArrayDeclarationModifier*>(modifier.get())->m_size);
}
depthSize.resize(arraySizes.size());
auto currentDepthSize = 1u;
for (auto i = arraySizes.size(); i > 0; i--)
{
if (i < arraySizes.size())
currentDepthSize *= arraySizes[i];
depthSize[i - 1] = currentDepthSize;
}
if (pointer->m_count_evaluation_by_array_index.empty())
{
auto neededCapacity = 0u;
for (auto arraySize : arraySizes)
{
if (neededCapacity == 0)
neededCapacity = arraySize;
else
neededCapacity *= arraySize;
}
pointer->m_count_evaluation_by_array_index.resize(neededCapacity);
}
auto currentIndex = 0u;
auto currentIndexOffset = 0u;
while (result.HasNextCapture(CAPTURE_ARRAY_INDEX) && currentIndexOffset < depthSize.size())
{
const auto& arrayIndexToken = result.NextCapture(CAPTURE_ARRAY_INDEX);
if (arrayIndexToken.m_type == CommandsParserValueType::INTEGER)
{
currentIndex += depthSize[currentIndexOffset++] * arrayIndexToken.IntegerValue();
}
else
{
auto* enumEntry = state->GetRepository()->GetEnumMemberByName(arrayIndexToken.IdentifierValue());
if (enumEntry == nullptr)
throw ParsingException(arrayIndexToken.GetPos(), "Unknown enum entry");
currentIndex += depthSize[currentIndexOffset++] * enumEntry->m_value;
}
}
pointer->m_count_evaluation_by_array_index[currentIndex] = std::move(evaluation);
}
} // namespace
SequenceCount::SequenceCount() SequenceCount::SequenceCount()
{ {
const CommandsMatcherFactory create(this); const CommandsMatcherFactory create(this);
@ -23,64 +93,6 @@ SequenceCount::SequenceCount()
}); });
} }
void SequenceCount::SetCountByArrayIndex(CommandsParserState* state,
SequenceResult<CommandsParserValue>& result,
MemberInformation* member,
PointerDeclarationModifier* pointer,
std::unique_ptr<IEvaluation> evaluation)
{
std::vector<int> arraySizes;
std::vector<int> depthSize;
for (const auto& modifier : member->m_member->m_type_declaration->m_declaration_modifiers)
{
if (modifier->GetType() == DeclarationModifierType::ARRAY)
arraySizes.push_back(dynamic_cast<ArrayDeclarationModifier*>(modifier.get())->m_size);
}
depthSize.resize(arraySizes.size());
auto currentDepthSize = 1u;
for (auto i = arraySizes.size(); i > 0; i--)
{
if (i < arraySizes.size())
currentDepthSize *= arraySizes[i];
depthSize[i - 1] = currentDepthSize;
}
if (pointer->m_count_evaluation_by_array_index.empty())
{
auto neededCapacity = 0u;
for (auto arraySize : arraySizes)
{
if (neededCapacity == 0)
neededCapacity = arraySize;
else
neededCapacity *= arraySize;
}
pointer->m_count_evaluation_by_array_index.resize(neededCapacity);
}
auto currentIndex = 0u;
auto currentIndexOffset = 0u;
while (result.HasNextCapture(CAPTURE_ARRAY_INDEX) && currentIndexOffset < depthSize.size())
{
const auto& arrayIndexToken = result.NextCapture(CAPTURE_ARRAY_INDEX);
if (arrayIndexToken.m_type == CommandsParserValueType::INTEGER)
{
currentIndex += depthSize[currentIndexOffset++] * arrayIndexToken.IntegerValue();
}
else
{
auto* enumEntry = state->GetRepository()->GetEnumMemberByName(arrayIndexToken.IdentifierValue());
if (enumEntry == nullptr)
throw ParsingException(arrayIndexToken.GetPos(), "Unknown enum entry");
currentIndex += depthSize[currentIndexOffset++] * enumEntry->m_value;
}
}
pointer->m_count_evaluation_by_array_index[currentIndex] = std::move(evaluation);
}
void SequenceCount::ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const void SequenceCount::ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const
{ {
const auto& typeNameToken = result.NextCapture(CAPTURE_TYPE); const auto& typeNameToken = result.NextCapture(CAPTURE_TYPE);

16
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceCount.h
View File

@ -5,21 +5,9 @@
class SequenceCount final : public CommandsParser::sequence_t class SequenceCount final : public CommandsParser::sequence_t
{ {
static constexpr auto TAG_POINTER_RESOLVE = 1; public:
SequenceCount();
static constexpr auto CAPTURE_START = 1;
static constexpr auto CAPTURE_TYPE = 2;
static constexpr auto CAPTURE_ARRAY_INDEX = 3;
static void SetCountByArrayIndex(CommandsParserState* state,
SequenceResult<CommandsParserValue>& result,
MemberInformation* member,
PointerDeclarationModifier* pointer,
std::unique_ptr<IEvaluation> evaluation);
protected: protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override; void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public:
SequenceCount();
}; };

5
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceGame.cpp
View File

@ -3,6 +3,11 @@
#include "Parsing/Commands/Matcher/CommandsCommonMatchers.h" #include "Parsing/Commands/Matcher/CommandsCommonMatchers.h"
#include "Parsing/Commands/Matcher/CommandsMatcherFactory.h" #include "Parsing/Commands/Matcher/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_GAME = 1;
}
SequenceGame::SequenceGame() SequenceGame::SequenceGame()
{ {
const CommandsMatcherFactory create(this); const CommandsMatcherFactory create(this);

6
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceGame.h
View File

@ -4,11 +4,9 @@
class SequenceGame final : public CommandsParser::sequence_t class SequenceGame final : public CommandsParser::sequence_t
{ {
static constexpr auto CAPTURE_GAME = 1; public:
SequenceGame();
protected: protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override; void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public:
SequenceGame();
}; };

5
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceName.cpp
View File

@ -3,6 +3,11 @@
#include "Parsing/Commands/Matcher/CommandsCommonMatchers.h" #include "Parsing/Commands/Matcher/CommandsCommonMatchers.h"
#include "Parsing/Commands/Matcher/CommandsMatcherFactory.h" #include "Parsing/Commands/Matcher/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_TYPE = 1;
}
SequenceName::SequenceName() SequenceName::SequenceName()
{ {
const CommandsMatcherFactory create(this); const CommandsMatcherFactory create(this);

6
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceName.h
View File

@ -4,11 +4,9 @@
class SequenceName final : public CommandsParser::sequence_t class SequenceName final : public CommandsParser::sequence_t
{ {
static constexpr auto CAPTURE_TYPE = 1; public:
SequenceName();
protected: protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override; void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public:
SequenceName();
}; };

65
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceReorder.cpp
View File

@ -5,6 +5,43 @@
#include <list> #include <list>
namespace
{
static constexpr auto TAG_FIND_FIRST = 1;
static constexpr auto CAPTURE_START = 1;
static constexpr auto CAPTURE_TYPE = 2;
static constexpr auto CAPTURE_ENTRY = 3;
StructureInformation* GetType(CommandsParserState* state, SequenceResult<CommandsParserValue>& result)
{
if (result.HasNextCapture(CAPTURE_TYPE))
{
const auto& typeNameToken = result.NextCapture(CAPTURE_TYPE);
StructureInformation* information;
std::vector<MemberInformation*> memberChain;
if (!state->GetTypenameAndMembersFromTypename(typeNameToken.TypeNameValue(), information, memberChain))
throw ParsingException(typeNameToken.GetPos(), "Unknown type");
if (memberChain.empty())
return information;
auto* lastMember = memberChain.back();
if (lastMember->m_type == nullptr)
throw ParsingException(typeNameToken.GetPos(), "Member type must either be struct or union");
return lastMember->m_type;
}
if (state->GetInUse() != nullptr)
return state->GetInUse();
throw ParsingException(result.NextCapture(CAPTURE_START).GetPos(), "No type is used. Therefore one needs to be specified directly.");
}
} // namespace
SequenceReorder::SequenceReorder() SequenceReorder::SequenceReorder()
{ {
const CommandsMatcherFactory create(this); const CommandsMatcherFactory create(this);
@ -26,34 +63,6 @@ SequenceReorder::SequenceReorder()
}); });
} }
StructureInformation* SequenceReorder::GetType(CommandsParserState* state, SequenceResult<CommandsParserValue>& result)
{
if (result.HasNextCapture(CAPTURE_TYPE))
{
const auto& typeNameToken = result.NextCapture(CAPTURE_TYPE);
StructureInformation* information;
std::vector<MemberInformation*> memberChain;
if (!state->GetTypenameAndMembersFromTypename(typeNameToken.TypeNameValue(), information, memberChain))
throw ParsingException(typeNameToken.GetPos(), "Unknown type");
if (memberChain.empty())
return information;
auto* lastMember = memberChain.back();
if (lastMember->m_type == nullptr)
throw ParsingException(typeNameToken.GetPos(), "Member type must either be struct or union");
return lastMember->m_type;
}
if (state->GetInUse() != nullptr)
return state->GetInUse();
throw ParsingException(result.NextCapture(CAPTURE_START).GetPos(), "No type is used. Therefore one needs to be specified directly.");
}
void SequenceReorder::ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const void SequenceReorder::ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const
{ {
auto* information = GetType(state, result); auto* information = GetType(state, result);

12
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceReorder.h
View File

@ -4,17 +4,9 @@
class SequenceReorder final : public CommandsParser::sequence_t class SequenceReorder final : public CommandsParser::sequence_t
{ {
static constexpr auto TAG_FIND_FIRST = 1; public:
SequenceReorder();
static constexpr auto CAPTURE_START = 1;
static constexpr auto CAPTURE_TYPE = 2;
static constexpr auto CAPTURE_ENTRY = 3;
static StructureInformation* GetType(CommandsParserState* state, SequenceResult<CommandsParserValue>& result);
protected: protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override; void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public:
SequenceReorder();
}; };

5
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceReusable.cpp
View File

@ -3,6 +3,11 @@
#include "Parsing/Commands/Matcher/CommandsCommonMatchers.h" #include "Parsing/Commands/Matcher/CommandsCommonMatchers.h"
#include "Parsing/Commands/Matcher/CommandsMatcherFactory.h" #include "Parsing/Commands/Matcher/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_TYPE = 1;
}
SequenceReusable::SequenceReusable() SequenceReusable::SequenceReusable()
{ {
const CommandsMatcherFactory create(this); const CommandsMatcherFactory create(this);

6
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceReusable.h
View File

@ -4,11 +4,9 @@
class SequenceReusable final : public CommandsParser::sequence_t class SequenceReusable final : public CommandsParser::sequence_t
{ {
static constexpr auto CAPTURE_TYPE = 1; public:
SequenceReusable();
protected: protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override; void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public:
SequenceReusable();
}; };

5
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceScriptString.cpp
View File

@ -3,6 +3,11 @@
#include "Parsing/Commands/Matcher/CommandsCommonMatchers.h" #include "Parsing/Commands/Matcher/CommandsCommonMatchers.h"
#include "Parsing/Commands/Matcher/CommandsMatcherFactory.h" #include "Parsing/Commands/Matcher/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_TYPE = 1;
}
SequenceScriptString::SequenceScriptString() SequenceScriptString::SequenceScriptString()
{ {
const CommandsMatcherFactory create(this); const CommandsMatcherFactory create(this);

6
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceScriptString.h
View File

@ -4,11 +4,9 @@
class SequenceScriptString final : public CommandsParser::sequence_t class SequenceScriptString final : public CommandsParser::sequence_t
{ {
static constexpr auto CAPTURE_TYPE = 1; public:
SequenceScriptString();
protected: protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override; void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public:
SequenceScriptString();
}; };

7
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceSetBlock.cpp
View File

@ -3,6 +3,13 @@
#include "Parsing/Commands/Matcher/CommandsCommonMatchers.h" #include "Parsing/Commands/Matcher/CommandsCommonMatchers.h"
#include "Parsing/Commands/Matcher/CommandsMatcherFactory.h" #include "Parsing/Commands/Matcher/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_START = 1;
static constexpr auto CAPTURE_TYPE = 2;
static constexpr auto CAPTURE_BLOCK_ENUM_ENTRY = 3;
} // namespace
SequenceSetBlock::SequenceSetBlock() SequenceSetBlock::SequenceSetBlock()
{ {
const CommandsMatcherFactory create(this); const CommandsMatcherFactory create(this);

8
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceSetBlock.h
View File

@ -4,13 +4,9 @@
class SequenceSetBlock final : public CommandsParser::sequence_t class SequenceSetBlock final : public CommandsParser::sequence_t
{ {
static constexpr auto CAPTURE_START = 1; public:
static constexpr auto CAPTURE_TYPE = 2; SequenceSetBlock();
static constexpr auto CAPTURE_BLOCK_ENUM_ENTRY = 3;
protected: protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override; void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public:
SequenceSetBlock();
}; };

5
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceString.cpp
View File

@ -5,6 +5,11 @@
#include <algorithm> #include <algorithm>
namespace
{
static constexpr auto CAPTURE_TYPE = 1;
}
SequenceString::SequenceString() SequenceString::SequenceString()
{ {
const CommandsMatcherFactory create(this); const CommandsMatcherFactory create(this);

6
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceString.h
View File

@ -4,11 +4,9 @@
class SequenceString final : public CommandsParser::sequence_t class SequenceString final : public CommandsParser::sequence_t
{ {
static constexpr auto CAPTURE_TYPE = 1; public:
SequenceString();
protected: protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override; void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public:
SequenceString();
}; };

5
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceUse.cpp
View File

@ -3,6 +3,11 @@
#include "Parsing/Commands/Matcher/CommandsCommonMatchers.h" #include "Parsing/Commands/Matcher/CommandsCommonMatchers.h"
#include "Parsing/Commands/Matcher/CommandsMatcherFactory.h" #include "Parsing/Commands/Matcher/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_TYPE = 1;
}
SequenceUse::SequenceUse() SequenceUse::SequenceUse()
{ {
const CommandsMatcherFactory create(this); const CommandsMatcherFactory create(this);

6
src/ZoneCodeGeneratorLib/Parsing/Commands/Sequence/SequenceUse.h
View File

@ -4,11 +4,9 @@
class SequenceUse final : public CommandsParser::sequence_t class SequenceUse final : public CommandsParser::sequence_t
{ {
static constexpr auto CAPTURE_TYPE = 1; public:
SequenceUse();
protected: protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override; void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public:
SequenceUse();
}; };

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

@ -7,18 +7,12 @@
#include "IHeaderBlockVariableDefining.h" #include "IHeaderBlockVariableDefining.h"
#include "Utils/ClassUtils.h" #include "Utils/ClassUtils.h"
#include <memory>
#include <string>
#include <vector>
class HeaderBlockEnum final : public IHeaderBlock, public IHeaderBlockNameHolder, 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;
int m_next_value;
EnumDefinition* m_enum_definition;
std::string m_variable_name;
public: public:
HeaderBlockEnum(std::string typeName, const BaseTypeDefinition* parentType, bool isTypeDef); HeaderBlockEnum(std::string typeName, const BaseTypeDefinition* parentType, bool isTypeDef);
@ -29,11 +23,22 @@ public:
void OnChildBlockClose(HeaderParserState* state, IHeaderBlock* block) override; void OnChildBlockClose(HeaderParserState* state, IHeaderBlock* block) override;
void AddEnumMember(std::unique_ptr<EnumMember> enumMember); void AddEnumMember(std::unique_ptr<EnumMember> enumMember);
_NODISCARD EnumMember* GetEnumMember(const std::string& name) const; [[nodiscard]] EnumMember* GetEnumMember(const std::string& name) const;
_NODISCARD int GetNextEnumMemberValue() const; [[nodiscard]] int GetNextEnumMemberValue() const;
void SetBlockName(const TokenPos& nameTokenPos, std::string name) override; void SetBlockName(const TokenPos& nameTokenPos, std::string name) override;
bool IsDefiningVariable() override; bool IsDefiningVariable() override;
DataDefinition* GetVariableType() override; DataDefinition* GetVariableType() override;
std::string GetVariableName() override; std::string GetVariableName() override;
private:
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;
int m_next_value;
EnumDefinition* m_enum_definition;
std::string m_variable_name;
}; };

7
src/ZoneCodeGeneratorLib/Parsing/Header/Block/HeaderBlockNamespace.h
View File

@ -2,10 +2,11 @@
#include "IHeaderBlock.h" #include "IHeaderBlock.h"
#include <string>
#include <vector>
class HeaderBlockNamespace final : public IHeaderBlock class HeaderBlockNamespace final : public IHeaderBlock
{ {
std::string m_namespace_name;
public: public:
explicit HeaderBlockNamespace(std::string namespaceName); explicit HeaderBlockNamespace(std::string namespaceName);
@ -14,4 +15,6 @@ public:
void OnOpen(HeaderParserState* state) override; void OnOpen(HeaderParserState* state) override;
void OnClose(HeaderParserState* state) override; void OnClose(HeaderParserState* state) override;
void OnChildBlockClose(HeaderParserState* state, IHeaderBlock* block) override; void OnChildBlockClose(HeaderParserState* state, IHeaderBlock* block) override;
std::string m_namespace_name;
}; };

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

@ -7,23 +7,12 @@
#include "IHeaderBlockVariableDefining.h" #include "IHeaderBlockVariableDefining.h"
#include "IHeaderBlockVariableHolder.h" #include "IHeaderBlockVariableHolder.h"
#include <memory>
#include <string> #include <string>
#include <vector>
class HeaderBlockStruct final : public IHeaderBlock, public IHeaderBlockNameHolder, public IHeaderBlockVariableDefining, public IHeaderBlockVariableHolder class HeaderBlockStruct final : public IHeaderBlock, public IHeaderBlockNameHolder, public IHeaderBlockVariableDefining, public IHeaderBlockVariableHolder
{ {
std::string m_namespace;
std::string m_type_name;
std::vector<std::shared_ptr<Variable>> m_members;
StructDefinition* m_struct_definition;
int m_custom_alignment;
bool m_is_typedef;
bool m_has_custom_align;
bool m_is_anonymous;
std::string m_variable_name;
public: public:
HeaderBlockStruct(std::string name, bool isTypedef); HeaderBlockStruct(std::string name, bool isTypedef);
@ -41,4 +30,18 @@ public:
bool IsDefiningVariable() override; bool IsDefiningVariable() override;
DataDefinition* GetVariableType() override; DataDefinition* GetVariableType() override;
std::string GetVariableName() override; std::string GetVariableName() override;
private:
std::string m_namespace;
std::string m_type_name;
std::vector<std::shared_ptr<Variable>> m_members;
StructDefinition* m_struct_definition;
int m_custom_alignment;
bool m_is_typedef;
bool m_has_custom_align;
bool m_is_anonymous;
std::string m_variable_name;
}; };

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

@ -5,21 +5,12 @@
#include "IHeaderBlockVariableDefining.h" #include "IHeaderBlockVariableDefining.h"
#include "IHeaderBlockVariableHolder.h" #include "IHeaderBlockVariableHolder.h"
#include <memory>
#include <string>
#include <vector>
class HeaderBlockUnion final : public IHeaderBlock, public IHeaderBlockNameHolder, public IHeaderBlockVariableDefining, public IHeaderBlockVariableHolder class HeaderBlockUnion final : public IHeaderBlock, public IHeaderBlockNameHolder, public IHeaderBlockVariableDefining, public IHeaderBlockVariableHolder
{ {
std::string m_namespace;
std::string m_type_name;
std::vector<std::shared_ptr<Variable>> m_members;
UnionDefinition* m_union_definition;
int m_custom_alignment;
bool m_is_typedef;
bool m_has_custom_align;
bool m_is_anonymous;
std::string m_variable_name;
public: public:
HeaderBlockUnion(std::string name, bool isTypedef); HeaderBlockUnion(std::string name, bool isTypedef);
@ -37,4 +28,18 @@ public:
bool IsDefiningVariable() override; bool IsDefiningVariable() override;
DataDefinition* GetVariableType() override; DataDefinition* GetVariableType() override;
std::string GetVariableName() override; std::string GetVariableName() override;
private:
std::string m_namespace;
std::string m_type_name;
std::vector<std::shared_ptr<Variable>> m_members;
UnionDefinition* m_union_definition;
int m_custom_alignment;
bool m_is_typedef;
bool m_has_custom_align;
bool m_is_anonymous;
std::string m_variable_name;
}; };

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

@ -13,8 +13,15 @@
#include <algorithm> #include <algorithm>
#include <chrono> #include <chrono>
#include <format>
#include <iostream> #include <iostream>
namespace
{
static constexpr const char* ZONE_CODE_GENERATOR_DEFINE_NAME = "__zonecodegenerator";
static constexpr const char* ZONE_CODE_GENERATOR_DEFINE_VALUE = "1";
} // namespace
HeaderFileReader::HeaderFileReader(const ZoneCodeGeneratorArguments* args, std::string filename) HeaderFileReader::HeaderFileReader(const ZoneCodeGeneratorArguments* args, std::string filename)
: m_args(args), : m_args(args),
m_filename(std::move(filename)), m_filename(std::move(filename)),
@ -29,7 +36,7 @@ bool HeaderFileReader::OpenBaseStream()
auto stream = std::make_unique<ParserFilesystemStream>(m_filename); auto stream = std::make_unique<ParserFilesystemStream>(m_filename);
if (!stream->IsOpen()) if (!stream->IsOpen())
{ {
std::cout << "Could not open header file\n"; std::cerr << "Could not open header file\n";
return false; return false;
} }
@ -65,9 +72,7 @@ void HeaderFileReader::SetupPostProcessors()
bool HeaderFileReader::ReadHeaderFile(IDataRepository* repository) bool HeaderFileReader::ReadHeaderFile(IDataRepository* repository)
{ {
if (m_args->m_verbose) if (m_args->m_verbose)
{ std::cout << std::format("Reading header file: {}\n", m_filename);
std::cout << "Reading header file: " << m_filename << "\n";
}
if (!OpenBaseStream()) if (!OpenBaseStream())
return false; return false;
@ -84,9 +89,7 @@ bool HeaderFileReader::ReadHeaderFile(IDataRepository* repository)
const auto end = std::chrono::steady_clock::now(); const auto end = std::chrono::steady_clock::now();
if (m_args->m_verbose) if (m_args->m_verbose)
{ std::cout << std::format("Processing header took {}ms\n", std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count());
std::cout << "Processing header took " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms\n";
}
if (!result) if (!result)
return false; return false;

20
src/ZoneCodeGeneratorLib/Parsing/Header/HeaderFileReader.h
View File

@ -10,8 +10,15 @@
class HeaderFileReader class HeaderFileReader
{ {
static constexpr const char* ZONE_CODE_GENERATOR_DEFINE_NAME = "__zonecodegenerator"; public:
static constexpr const char* ZONE_CODE_GENERATOR_DEFINE_VALUE = "1"; HeaderFileReader(const ZoneCodeGeneratorArguments* args, std::string filename);
bool ReadHeaderFile(IDataRepository* repository);
private:
bool OpenBaseStream();
void SetupStreamProxies();
void SetupPostProcessors();
const ZoneCodeGeneratorArguments* m_args; const ZoneCodeGeneratorArguments* m_args;
std::string m_filename; std::string m_filename;
@ -21,13 +28,4 @@ class HeaderFileReader
IParserLineStream* m_stream; IParserLineStream* m_stream;
std::vector<std::unique_ptr<IPostProcessor>> m_post_processors; std::vector<std::unique_ptr<IPostProcessor>> m_post_processors;
bool OpenBaseStream();
void SetupStreamProxies();
void SetupPostProcessors();
public:
HeaderFileReader(const ZoneCodeGeneratorArguments* args, std::string filename);
bool ReadHeaderFile(IDataRepository* repository);
}; };

12
src/ZoneCodeGeneratorLib/Parsing/Header/Impl/HeaderLexer.h
View File

@ -3,17 +3,19 @@
#include "HeaderParserValue.h" #include "HeaderParserValue.h"
#include "Parsing/Impl/AbstractLexer.h" #include "Parsing/Impl/AbstractLexer.h"
#include <string>
#include <unordered_map> #include <unordered_map>
class HeaderLexer final : public AbstractLexer<HeaderParserValue> class HeaderLexer final : public AbstractLexer<HeaderParserValue>
{ {
std::unordered_map<std::string, HeaderParserValueType> m_keywords; public:
explicit HeaderLexer(IParserLineStream* stream);
void PrepareKeywords();
protected: protected:
HeaderParserValue GetNextToken() override; HeaderParserValue GetNextToken() override;
public: private:
explicit HeaderLexer(IParserLineStream* stream); void PrepareKeywords();
std::unordered_map<std::string, HeaderParserValueType> m_keywords;
}; };

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

@ -8,11 +8,11 @@
class HeaderParser final : public AbstractParser<HeaderParserValue, HeaderParserState> class HeaderParser final : public AbstractParser<HeaderParserValue, HeaderParserState>
{ {
protected:
const std::vector<sequence_t*>& GetTestsForState() override;
public: public:
HeaderParser(HeaderLexer* lexer, const IPackValueSupplier* packValueSupplier); HeaderParser(HeaderLexer* lexer, const IPackValueSupplier* packValueSupplier);
bool SaveToRepository(IDataRepository* repository) const; bool SaveToRepository(IDataRepository* repository) const;
protected:
const std::vector<sequence_t*>& GetTestsForState() override;
}; };

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

@ -3,6 +3,7 @@
#include "Domain/Definition/EnumDefinition.h" #include "Domain/Definition/EnumDefinition.h"
#include "Parsing/Header/Block/HeaderBlockNone.h" #include "Parsing/Header/Block/HeaderBlockNone.h"
#include <format>
#include <iostream> #include <iostream>
HeaderParserState::HeaderParserState(const IPackValueSupplier* packValueSupplier) HeaderParserState::HeaderParserState(const IPackValueSupplier* packValueSupplier)
@ -96,7 +97,7 @@ bool HeaderParserState::ResolveForwardDeclarations()
if (dataDefinition == nullptr) if (dataDefinition == nullptr)
{ {
std::cout << "Forward declaration \"" << forwardDeclaration->GetFullName() << "\" was not defined\n"; std::cerr << std::format("Forward declaration \"{}\" was not defined\n", forwardDeclaration->GetFullName());
return false; return false;
} }

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

@ -12,31 +12,15 @@
#include <memory> #include <memory>
#include <stack> #include <stack>
#include <string>
#include <unordered_map> #include <unordered_map>
#include <vector>
class IHeaderBlock; class IHeaderBlock;
class HeaderParserState 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);
bool ResolveForwardDeclarations();
static bool ReplaceForwardDeclarationsInStruct(StructDefinition* structDefinition);
static bool ReplaceForwardDeclarationsInTypedef(TypedefDefinition* typedefDefinition);
static bool ReplaceForwardDeclarationsInUnion(UnionDefinition* unionDefinition);
bool ReplaceForwardDeclarationsInDefinitions();
bool MoveDefinitionsToRepository(IDataRepository* repository);
public: public:
const IPackValueSupplier* const m_pack_value_supplier;
NamespaceBuilder m_namespace;
explicit HeaderParserState(const IPackValueSupplier* packValueSupplier); explicit HeaderParserState(const IPackValueSupplier* packValueSupplier);
_NODISCARD IHeaderBlock* GetBlock() const; _NODISCARD IHeaderBlock* GetBlock() const;
@ -50,4 +34,23 @@ public:
EnumMember* FindEnumMember(const std::string& enumMemberName); EnumMember* FindEnumMember(const std::string& enumMemberName);
bool SaveToRepository(IDataRepository* repository); bool SaveToRepository(IDataRepository* repository);
const IPackValueSupplier* const m_pack_value_supplier;
NamespaceBuilder m_namespace;
private:
void AddBaseDataType(const BaseTypeDefinition* baseType);
bool ResolveForwardDeclarations();
static bool ReplaceForwardDeclarationsInStruct(StructDefinition* structDefinition);
static bool ReplaceForwardDeclarationsInTypedef(TypedefDefinition* typedefDefinition);
static bool ReplaceForwardDeclarationsInUnion(UnionDefinition* unionDefinition);
bool ReplaceForwardDeclarationsInDefinitions();
bool MoveDefinitionsToRepository(IDataRepository* repository);
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;
}; };

29
src/ZoneCodeGeneratorLib/Parsing/Header/Impl/HeaderParserValue.h
View File

@ -61,9 +61,6 @@ enum class HeaderParserValueType
class HeaderParserValue final : public IParserValue class HeaderParserValue final : public IParserValue
{ {
public: public:
TokenPos m_pos;
HeaderParserValueType m_type;
union ValueType union ValueType
{ {
char char_value; char char_value;
@ -90,23 +87,25 @@ public:
static HeaderParserValue Keyword(TokenPos pos, HeaderParserValueType type); static HeaderParserValue Keyword(TokenPos pos, HeaderParserValueType type);
static HeaderParserValue TypeName(TokenPos pos, std::string* typeName); static HeaderParserValue TypeName(TokenPos pos, std::string* typeName);
private:
HeaderParserValue(TokenPos pos, HeaderParserValueType type);
public:
~HeaderParserValue() override; ~HeaderParserValue() override;
HeaderParserValue(const HeaderParserValue& other) = delete; HeaderParserValue(const HeaderParserValue& other) = delete;
HeaderParserValue(HeaderParserValue&& other) noexcept; HeaderParserValue(HeaderParserValue&& other) noexcept;
HeaderParserValue& operator=(const HeaderParserValue& other) = delete; HeaderParserValue& operator=(const HeaderParserValue& other) = delete;
HeaderParserValue& operator=(HeaderParserValue&& other) noexcept; HeaderParserValue& operator=(HeaderParserValue&& other) noexcept;
_NODISCARD bool IsEof() const override; [[nodiscard]] bool IsEof() const override;
_NODISCARD const TokenPos& GetPos() const override; [[nodiscard]] const TokenPos& GetPos() const override;
_NODISCARD char CharacterValue() const; [[nodiscard]] char CharacterValue() const;
_NODISCARD int IntegerValue() const; [[nodiscard]] int IntegerValue() const;
_NODISCARD double FloatingPointValue() const; [[nodiscard]] double FloatingPointValue() const;
_NODISCARD std::string& StringValue() const; [[nodiscard]] std::string& StringValue() const;
_NODISCARD std::string& IdentifierValue() const; [[nodiscard]] std::string& IdentifierValue() const;
_NODISCARD std::string& TypeNameValue() const; [[nodiscard]] std::string& TypeNameValue() const;
TokenPos m_pos;
HeaderParserValueType m_type;
private:
HeaderParserValue(TokenPos pos, HeaderParserValueType type);
}; };

7
src/ZoneCodeGeneratorLib/Parsing/Header/Matcher/HeaderMatcherCharacter.h
View File

@ -5,11 +5,12 @@
class HeaderMatcherCharacter final : public AbstractMatcher<HeaderParserValue> class HeaderMatcherCharacter final : public AbstractMatcher<HeaderParserValue>
{ {
char m_char; public:
explicit HeaderMatcherCharacter(char c);
protected: protected:
MatcherResult<HeaderParserValue> CanMatch(ILexer<HeaderParserValue>* lexer, unsigned tokenOffset) override; MatcherResult<HeaderParserValue> CanMatch(ILexer<HeaderParserValue>* lexer, unsigned tokenOffset) override;
public: private:
explicit HeaderMatcherCharacter(char c); char m_char;
}; };

10
src/ZoneCodeGeneratorLib/Parsing/Header/Matcher/HeaderMatcherFactory.h
View File

@ -8,9 +8,9 @@ class HeaderMatcherFactory final : public AbstractMatcherFactory<HeaderParserVal
public: public:
explicit HeaderMatcherFactory(const IMatcherForLabelSupplier<HeaderParserValue>* labelSupplier); explicit HeaderMatcherFactory(const IMatcherForLabelSupplier<HeaderParserValue>* labelSupplier);
_NODISCARD MatcherFactoryWrapper<HeaderParserValue> Type(HeaderParserValueType type) const; [[nodiscard]] MatcherFactoryWrapper<HeaderParserValue> Type(HeaderParserValueType type) const;
_NODISCARD MatcherFactoryWrapper<HeaderParserValue> Identifier() const; [[nodiscard]] MatcherFactoryWrapper<HeaderParserValue> Identifier() const;
_NODISCARD MatcherFactoryWrapper<HeaderParserValue> Integer() const; [[nodiscard]] MatcherFactoryWrapper<HeaderParserValue> Integer() const;
_NODISCARD MatcherFactoryWrapper<HeaderParserValue> FloatingPoint() const; [[nodiscard]] MatcherFactoryWrapper<HeaderParserValue> FloatingPoint() const;
_NODISCARD MatcherFactoryWrapper<HeaderParserValue> Char(char c) const; [[nodiscard]] MatcherFactoryWrapper<HeaderParserValue> Char(char c) const;
}; };

7
src/ZoneCodeGeneratorLib/Parsing/Header/Matcher/HeaderMatcherValueType.h
View File

@ -5,11 +5,12 @@
class HeaderMatcherValueType final : public AbstractMatcher<HeaderParserValue> class HeaderMatcherValueType final : public AbstractMatcher<HeaderParserValue>
{ {
HeaderParserValueType m_type; public:
explicit HeaderMatcherValueType(HeaderParserValueType type);
protected: protected:
MatcherResult<HeaderParserValue> CanMatch(ILexer<HeaderParserValue>* lexer, unsigned tokenOffset) override; MatcherResult<HeaderParserValue> CanMatch(ILexer<HeaderParserValue>* lexer, unsigned tokenOffset) override;
public: private:
explicit HeaderMatcherValueType(HeaderParserValueType type); HeaderParserValueType m_type;
}; };

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

@ -4,6 +4,14 @@
#include "Parsing/Header/Matcher/HeaderCommonMatchers.h" #include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h" #include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
namespace
{
static constexpr auto TAG_SEMICOLON = 1;
static constexpr auto CAPTURE_NAME = 1;
static constexpr auto CAPTURE_CLOSING_PARENTHESIS = 2;
} // namespace
SequenceCloseBlock::SequenceCloseBlock(const bool semicolonRequired) SequenceCloseBlock::SequenceCloseBlock(const bool semicolonRequired)
: m_semicolon_required(semicolonRequired) : m_semicolon_required(semicolonRequired)
{ {

10
src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceCloseBlock.h
View File

@ -7,16 +7,12 @@
class SequenceCloseBlock final : public HeaderParser::sequence_t class SequenceCloseBlock final : public HeaderParser::sequence_t
{ {
static constexpr auto TAG_SEMICOLON = 1; public:
explicit SequenceCloseBlock(bool semicolonRequired);
static constexpr auto CAPTURE_NAME = 1;
static constexpr auto CAPTURE_CLOSING_PARENTHESIS = 2;
private:
bool m_semicolon_required; bool m_semicolon_required;
protected: protected:
void ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const override; void ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const override;
public:
explicit SequenceCloseBlock(bool semicolonRequired);
}; };

Some files were not shown because too many files have changed in this diff Show More