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

Merge pull request #408 from Laupetin/refactor/zcg-code-style

Browse Source 
refactor: zcg code style
This commit is contained in:
Jan 2025-04-20 13:51:43 +02:00 committed by GitHub
commit 38d948ebdd
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
141 changed files with 4483 additions and 4404 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/ZoneCodeGenerator/main.cpp
View File

@ -2,6 +2,6 @@
int main(const int argc, const char** argv)
{
const ZoneCodeGenerator zoneCodeGenerator;
return zoneCodeGenerator.Run(argc, argv);
auto zoneCodeGenerator = ZoneCodeGenerator::Create();
return zoneCodeGenerator->Run(argc, argv);
}

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

@ -2,32 +2,35 @@
#include "Domain/Information/MemberInformation.h"
#include <vector>
class MemberComputations
{
const MemberInformation* const m_info;
public:
explicit MemberComputations(const MemberInformation* member);
_NODISCARD bool ShouldIgnore() const;
_NODISCARD bool ContainsNonEmbeddedReference() const;
_NODISCARD bool ContainsSinglePointerReference() const;
_NODISCARD bool ContainsArrayPointerReference() const;
_NODISCARD bool ContainsPointerArrayReference() const;
_NODISCARD bool ContainsArrayReference() const;
_NODISCARD const IEvaluation* GetArrayPointerCountEvaluation() const;
_NODISCARD bool IsArray() const;
_NODISCARD std::vector<int> GetArraySizes() const;
_NODISCARD int GetArrayDimension() const;
_NODISCARD bool IsPointerToArray() const;
_NODISCARD std::vector<int> GetPointerToArraySizes() const;
_NODISCARD int GetPointerDepth() const;
_NODISCARD bool IsNotInDefaultNormalBlock() const;
_NODISCARD bool IsInTempBlock() const;
_NODISCARD bool IsInRuntimeBlock() const;
_NODISCARD bool IsFirstMember() const;
_NODISCARD bool IsLastMember() const;
_NODISCARD bool HasDynamicArraySize() const;
_NODISCARD bool IsDynamicMember() const;
_NODISCARD bool IsAfterPartialLoad() const;
[[nodiscard]] bool ShouldIgnore() const;
[[nodiscard]] bool ContainsNonEmbeddedReference() const;
[[nodiscard]] bool ContainsSinglePointerReference() const;
[[nodiscard]] bool ContainsArrayPointerReference() const;
[[nodiscard]] bool ContainsPointerArrayReference() const;
[[nodiscard]] bool ContainsArrayReference() const;
[[nodiscard]] const IEvaluation* GetArrayPointerCountEvaluation() const;
[[nodiscard]] bool IsArray() const;
[[nodiscard]] std::vector<int> GetArraySizes() const;
[[nodiscard]] int GetArrayDimension() const;
[[nodiscard]] bool IsPointerToArray() const;
[[nodiscard]] std::vector<int> GetPointerToArraySizes() const;
[[nodiscard]] int GetPointerDepth() const;
[[nodiscard]] bool IsNotInDefaultNormalBlock() const;
[[nodiscard]] bool IsInTempBlock() const;
[[nodiscard]] bool IsInRuntimeBlock() const;
[[nodiscard]] bool IsFirstMember() const;
[[nodiscard]] bool IsLastMember() const;
[[nodiscard]] bool HasDynamicArraySize() const;
[[nodiscard]] bool IsDynamicMember() 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/Information/MemberInformation.h"
#include "Utils/ClassUtils.h"
#include <vector>
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:
explicit DeclarationModifierComputations(const MemberInformation* member);
_NODISCARD DeclarationModifier* GetDeclarationModifier() const;
_NODISCARD DeclarationModifier* GetNextDeclarationModifier() const;
_NODISCARD std::vector<DeclarationModifier*> GetFollowingDeclarationModifiers() const;
_NODISCARD std::vector<int> GetArrayIndices() const;
_NODISCARD bool IsArray() const;
_NODISCARD int GetArraySize() const;
_NODISCARD bool HasDynamicArrayCount() const;
_NODISCARD const IEvaluation* GetDynamicArrayCountEvaluation() const;
_NODISCARD std::vector<DeclarationModifierComputations> GetArrayEntries() const;
_NODISCARD bool IsSinglePointer() const;
_NODISCARD bool IsArrayPointer() const;
_NODISCARD const IEvaluation* GetArrayPointerCountEvaluation() const;
_NODISCARD bool IsPointerArray() const;
_NODISCARD const IEvaluation* GetPointerArrayCountEvaluation() const;
_NODISCARD bool IsDynamicArray() const;
_NODISCARD const IEvaluation* GetDynamicArraySizeEvaluation() const;
_NODISCARD unsigned GetAlignment() const;
[[nodiscard]] DeclarationModifier* GetDeclarationModifier() const;
[[nodiscard]] DeclarationModifier* GetNextDeclarationModifier() const;
[[nodiscard]] std::vector<DeclarationModifier*> GetFollowingDeclarationModifiers() const;
[[nodiscard]] std::vector<int> GetArrayIndices() const;
[[nodiscard]] bool IsArray() const;
[[nodiscard]] int GetArraySize() const;
[[nodiscard]] bool HasDynamicArrayCount() const;
[[nodiscard]] const IEvaluation* GetDynamicArrayCountEvaluation() const;
[[nodiscard]] std::vector<DeclarationModifierComputations> GetArrayEntries() const;
[[nodiscard]] bool IsSinglePointer() const;
[[nodiscard]] bool IsArrayPointer() const;
[[nodiscard]] const IEvaluation* GetArrayPointerCountEvaluation() const;
[[nodiscard]] bool IsPointerArray() const;
[[nodiscard]] const IEvaluation* GetPointerArrayCountEvaluation() const;
[[nodiscard]] bool IsDynamicArray() const;
[[nodiscard]] const IEvaluation* GetDynamicArraySizeEvaluation() 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
{
const StructureInformation* const m_info;
public:
explicit StructureComputations(const StructureInformation* structure);
_NODISCARD bool IsAsset() const;
_NODISCARD MemberInformation* GetDynamicMember() const;
_NODISCARD std::vector<MemberInformation*> GetUsedMembers() const;
[[nodiscard]] bool IsAsset() const;
[[nodiscard]] MemberInformation* GetDynamicMember() 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 "Domain/Evaluation/IEvaluation.h"
#include "Utils/ClassUtils.h"
#include <memory>
class ArrayDeclarationModifier final : public DeclarationModifier
{
public:
explicit ArrayDeclarationModifier(int size);
[[nodiscard]] DeclarationModifierType GetType() const override;
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.
*/
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
{
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 DOUBLE;
static const BaseTypeDefinition* const BOOL;
@ -32,4 +21,14 @@ public:
static const BaseTypeDefinition* const ALL_BASE_TYPES[];
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=(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_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=(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
{
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_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_size;
unsigned m_alignment;
@ -24,10 +30,4 @@ public:
unsigned m_alignment_override;
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
{
public:
const BaseTypeDefinition* m_parent_type;
std::vector<std::unique_ptr<EnumMember>> m_members;
EnumDefinition(std::string _namespace, std::string name, const BaseTypeDefinition* parentType);
_NODISCARD DataDefinitionType GetType() const override;
_NODISCARD unsigned GetAlignment() const override;
_NODISCARD bool GetForceAlignment() const override;
_NODISCARD unsigned GetSize() const override;
[[nodiscard]] DataDefinitionType GetType() const override;
[[nodiscard]] unsigned GetAlignment() const override;
[[nodiscard]] bool GetForceAlignment() const override;
[[nodiscard]] unsigned GetSize() const override;
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
{
public:
std::string m_name;
int m_value;
EnumMember();
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
{
public:
const DataDefinitionType m_forwarded_type;
const DataDefinition* m_definition;
ForwardDeclaration(std::string _namespace, std::string name, DataDefinitionType type);
_NODISCARD DataDefinitionType GetType() const override;
_NODISCARD unsigned GetAlignment() const override;
_NODISCARD bool GetForceAlignment() const override;
_NODISCARD unsigned GetSize() const override;
[[nodiscard]] DataDefinitionType GetType() const override;
[[nodiscard]] unsigned GetAlignment() const override;
[[nodiscard]] bool GetForceAlignment() 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
{
static const IEvaluation* const DEFAULT_COUNT;
static bool EvaluationIsArray(const IEvaluation* evaluation);
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::vector<std::unique_ptr<IEvaluation>> m_count_evaluation_by_array_index;
_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;
private:
static const IEvaluation* const DEFAULT_COUNT;
static bool EvaluationIsArray(const IEvaluation* evaluation);
};

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

@ -7,5 +7,5 @@ class StructDefinition final : public DefinitionWithMembers
public:
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_ALIGNMENT_FORCED = 1 << 1;
unsigned m_flags;
unsigned m_size;
unsigned m_alignment;
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_has_custom_bit_size;
const DataDefinition* m_type;
unsigned m_custom_bit_size;
std::vector<std::unique_ptr<DeclarationModifier>> m_declaration_modifiers;
_NODISCARD unsigned GetSize() const;
_NODISCARD unsigned GetAlignment() const;
_NODISCARD bool GetForceAlignment() const;
unsigned m_flags;
unsigned m_size;
unsigned m_alignment;
};

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

@ -6,14 +6,14 @@
class TypedefDefinition final : public DataDefinition
{
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;
unsigned m_alignment_override;
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
{
// protected:
// void CalculateSize() override;
public:
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
{
public:
Variable(std::string name, std::unique_ptr<TypeDeclaration> typeDeclaration);
[[nodiscard]] unsigned GetAlignment() const;
[[nodiscard]] bool GetForceAlignment() const;
std::string m_name;
bool m_has_alignment_override;
unsigned m_alignment_override;
unsigned m_offset;
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
#include "Utils/ClassUtils.h"
enum class EvaluationType
{
OPERAND_DYNAMIC,
@ -20,7 +18,7 @@ public:
IEvaluation& operator=(const IEvaluation& other) = default;
IEvaluation& operator=(IEvaluation&& other) noexcept = default;
_NODISCARD virtual EvaluationType GetType() const = 0;
_NODISCARD virtual bool IsStatic() const = 0;
_NODISCARD virtual int EvaluateNumeric() const = 0;
[[nodiscard]] virtual EvaluationType GetType() const = 0;
[[nodiscard]] virtual bool IsStatic() 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
{
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);
OperandDynamic(StructureInformation* structure,
std::vector<MemberInformation*> referencedMemberChain,
std::vector<std::unique_ptr<IEvaluation>> arrayIndices);
_NODISCARD EvaluationType GetType() const override;
_NODISCARD bool IsStatic() const override;
_NODISCARD int EvaluateNumeric() const override;
[[nodiscard]] EvaluationType GetType() const override;
[[nodiscard]] bool IsStatic() 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
{
public:
const int m_value;
EnumMember* const m_enum_member;
explicit OperandStatic(int value);
explicit OperandStatic(EnumMember* enumMember);
_NODISCARD EvaluationType GetType() const override;
_NODISCARD bool IsStatic() const override;
_NODISCARD int EvaluateNumeric() const override;
[[nodiscard]] EvaluationType GetType() const override;
[[nodiscard]] bool IsStatic() 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
{
public:
const OperationType* const m_operation_type;
std::unique_ptr<IEvaluation> m_operand1;
std::unique_ptr<IEvaluation> m_operand2;
explicit Operation(const OperationType* type);
Operation(const OperationType* type, std::unique_ptr<IEvaluation> operand1, std::unique_ptr<IEvaluation> operand2);
_NODISCARD EvaluationType GetType() const override;
_NODISCARD bool IsStatic() const override;
_NODISCARD int EvaluateNumeric() const override;
[[nodiscard]] EvaluationType GetType() const override;
[[nodiscard]] bool IsStatic() const override;
[[nodiscard]] int EvaluateNumeric() const override;
_NODISCARD bool Operand1NeedsParenthesis() const;
_NODISCARD bool Operand2NeedsParenthesis() const;
[[nodiscard]] bool Operand1NeedsParenthesis() 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
{
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:
static const OperationType* const OPERATION_ADD;
static const OperationType* const OPERATION_SUBTRACT;
@ -49,4 +41,11 @@ public:
static const OperationType* const OPERATION_OR;
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
{
public:
CustomAction(std::string actionName, std::vector<DataDefinition*> parameterTypes);
std::string m_action_name;
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
{
public:
FastFileBlock(std::string name, unsigned index, FastFileBlockType type, bool isDefault);
std::string m_name;
unsigned m_index;
FastFileBlockType m_type;
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
{
public:
MemberInformation(StructureInformation* parent, StructureInformation* type, Variable* member);
StructureInformation* m_parent;
StructureInformation* m_type;
Variable* m_member;
@ -24,6 +26,4 @@ public:
std::unique_ptr<CustomAction> m_post_load_action;
const FastFileBlock* m_fast_file_block;
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/FastFile/FastFileBlock.h"
#include "MemberInformation.h"
#include "Utils/ClassUtils.h"
#include <memory>
#include <vector>
class MemberInformation;
class StructureInformation
{
public:
explicit StructureInformation(DefinitionWithMembers* definition);
DefinitionWithMembers* const m_definition;
EnumMember* m_asset_enum_entry;
@ -31,6 +35,4 @@ public:
std::unique_ptr<CustomAction> m_post_load_action;
const FastFileBlock* m_block;
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 "ZoneCodeGeneratorArguments.h"
#include <memory>
#include <string>
#include <unordered_map>
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();
bool GenerateCodeForTemplate(RenderingContext* context, ICodeTemplate* codeTemplate) const;
static bool GetAssetWithName(IDataRepository* repository, const std::string& name, StructureInformation*& asset);
public:
explicit CodeGenerator(const ZoneCodeGeneratorArguments* args);
const ZoneCodeGeneratorArguments* m_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
{
public:
RenderingUsedType(const DataDefinition* type, StructureInformation* info);
bool m_members_loaded;
const DataDefinition* m_type;
StructureInformation* m_info;
@ -20,25 +22,13 @@ public:
bool m_array_reference_exists;
bool m_pointer_array_reference_exists;
bool m_pointer_array_reference_is_reusable;
RenderingUsedType(const DataDefinition* type, StructureInformation* info);
};
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:
static std::unique_ptr<RenderingContext> BuildContext(const IDataRepository* repository, StructureInformation* asset);
std::string m_game;
std::vector<const FastFileBlock*> m_blocks;
@ -52,5 +42,16 @@ public:
const FastFileBlock* m_default_normal_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 <sstream>
class AssetStructTestsTemplate::Internal final : BaseTemplate
namespace
{
void TestMethod(StructureInformation* structure)
{
LINE("TEST_CASE(\"" << m_env.m_game << "::" << m_env.m_asset->m_definition->GetFullName() << ": Tests for " << structure->m_definition->GetFullName()
<< "\", \"[assetstruct]\")")
LINE("{")
m_intendation++;
static constexpr int TAG_SOURCE = 1;
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("")
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)
private:
void TestMethod(StructureInformation* structure)
{
StructureComputations computations(structure->m_info);
if (!structure->m_info->m_definition->m_anonymous && !computations.IsAsset())
TestMethod(structure->m_info);
}
LINE("TEST_CASE(\"" << m_env.m_game << "::" << m_env.m_asset->m_definition->GetFullName() << ": Tests for "
<< structure->m_definition->GetFullName() << "\", \"[assetstruct]\")")
LINE("{")
m_intendation++;
m_intendation--;
LINE("}")
}
};
for (const auto& member : structure->m_ordered_members)
{
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)
{
@ -89,10 +95,10 @@ std::vector<CodeTemplateFile> AssetStructTestsTemplate::GetFilesToRender(Renderi
void AssetStructTestsTemplate::RenderFile(std::ostream& stream, const int fileTag, RenderingContext* context)
{
Internal internal(stream, context);
Template t(stream, context);
if (fileTag == TAG_SOURCE)
internal.Source();
t.Source();
else
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
{
static constexpr int TAG_SOURCE = 1;
class Internal;
public:
std::vector<CodeTemplateFile> GetFilesToRender(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:
static constexpr const char* INTENDATION = " ";
std::ostream& m_out;
RenderingContext& m_env;
unsigned m_intendation;
BaseTemplate(std::ostream& stream, RenderingContext* context);
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 Lower(std::string str);
static std::string MakeTypeVarName(const DataDefinition* def);
@ -55,6 +38,22 @@ protected:
static std::string MakeCustomActionCall(CustomAction* action);
static std::string MakeArrayCount(const ArrayDeclarationModifier* arrayModifier);
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) \

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
{
static constexpr int TAG_HEADER = 1;
static constexpr int TAG_SOURCE = 2;
class Internal;
public:
std::vector<CodeTemplateFile> GetFilesToRender(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
{
static constexpr int TAG_HEADER = 1;
static constexpr int TAG_SOURCE = 2;
class Internal;
public:
std::vector<CodeTemplateFile> GetFilesToRender(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
{
static constexpr int TAG_HEADER = 1;
static constexpr int TAG_SOURCE = 2;
class Internal;
public:
std::vector<CodeTemplateFile> GetFilesToRender(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 <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)
: m_args(args),
m_filename(std::move(filename)),
@ -30,7 +36,7 @@ bool CommandsFileReader::OpenBaseStream()
auto stream = std::make_unique<ParserFilesystemStream>(m_filename);
if (!stream->IsOpen())
{
std::cout << "Could not open commands file\n";
std::cerr << "Could not open commands file\n";
return false;
}
@ -68,7 +74,7 @@ bool CommandsFileReader::ReadCommandsFile(IDataRepository* repository)
{
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())
@ -84,9 +90,7 @@ bool CommandsFileReader::ReadCommandsFile(IDataRepository* repository)
const auto end = std::chrono::steady_clock::now();
if (m_args->m_verbose)
{
std::cout << "Processing commands took " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms\n";
}
std::cout << std::format("Processing commands took {}ms\n", std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count());
if (!result)
return false;

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

@ -9,8 +9,15 @@
class CommandsFileReader
{
static constexpr const char* ZONE_CODE_GENERATOR_DEFINE_NAME = "__zonecodegenerator";
static constexpr const char* ZONE_CODE_GENERATOR_DEFINE_VALUE = "1";
public:
CommandsFileReader(const ZoneCodeGeneratorArguments* args, std::string filename);
bool ReadCommandsFile(IDataRepository* repository);
private:
bool OpenBaseStream();
void SetupStreamProxies();
void SetupPostProcessors();
const ZoneCodeGeneratorArguments* m_args;
std::string m_filename;
@ -19,13 +26,4 @@ class CommandsFileReader
IParserLineStream* m_stream;
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>
{
protected:
CommandsParserValue GetNextToken() override;
public:
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>
{
IDataRepository* m_repository;
public:
CommandsParser(CommandsLexer* lexer, IDataRepository* targetRepository);
protected:
const std::vector<sequence_t*>& GetTestsForState() override;
public:
CommandsParser(CommandsLexer* lexer, IDataRepository* targetRepository);
private:
IDataRepository* m_repository;
};

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

@ -1,16 +1,28 @@
#pragma once
#include "Persistence/IDataRepository.h"
#include "Utils/ClassUtils.h"
#include <memory>
#include <string>
class CommandsParserState
{
IDataRepository* m_repository;
StructureInformation* m_in_use;
public:
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 bool GetNextTypenameSeparatorPos(const std::string& typeNameValue, unsigned startPos, unsigned& separatorPos);
static bool ExtractMembersFromTypenameInternal(const std::string& typeNameValue,
@ -18,18 +30,6 @@ class CommandsParserState
StructureInformation* type,
std::vector<MemberInformation*>& members);
public:
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;
IDataRepository* m_repository;
StructureInformation* m_in_use;
};

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

@ -52,10 +52,6 @@ enum class CommandsParserValueType
class CommandsParserValue final : public IParserValue
{
public:
TokenPos m_pos;
CommandsParserValueType m_type;
size_t m_hash;
union ValueType
{
char char_value;
@ -83,25 +79,28 @@ public:
static CommandsParserValue TypeName(TokenPos pos, std::string* typeName);
static CommandsParserValue OpType(TokenPos pos, const OperationType* operationType);
private:
CommandsParserValue(TokenPos pos, CommandsParserValueType type);
public:
~CommandsParserValue() override;
CommandsParserValue(const CommandsParserValue& other) = delete;
~CommandsParserValue() override;
CommandsParserValue(CommandsParserValue&& other) noexcept;
CommandsParserValue& operator=(const CommandsParserValue& other) = delete;
CommandsParserValue& operator=(CommandsParserValue&& other) noexcept;
_NODISCARD bool IsEof() const override;
_NODISCARD const TokenPos& GetPos() const override;
[[nodiscard]] bool IsEof() const override;
[[nodiscard]] const TokenPos& GetPos() const override;
_NODISCARD char CharacterValue() const;
_NODISCARD int IntegerValue() const;
_NODISCARD double FloatingPointValue() const;
_NODISCARD std::string& StringValue() const;
_NODISCARD std::string& IdentifierValue() const;
_NODISCARD size_t IdentifierHash() const;
_NODISCARD std::string& TypeNameValue() const;
_NODISCARD const OperationType* OpTypeValue() const;
[[nodiscard]] char CharacterValue() const;
[[nodiscard]] int IntegerValue() const;
[[nodiscard]] double FloatingPointValue() const;
[[nodiscard]] std::string& StringValue() const;
[[nodiscard]] std::string& IdentifierValue() const;
[[nodiscard]] size_t IdentifierHash() const;
[[nodiscard]] std::string& TypeNameValue() 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>
{
char m_char;
public:
explicit CommandsMatcherCharacter(char c);
protected:
MatcherResult<CommandsParserValue> CanMatch(ILexer<CommandsParserValue>* lexer, unsigned tokenOffset) override;
public:
explicit CommandsMatcherCharacter(char c);
private:
char m_char;
};

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

@ -10,10 +10,10 @@ class CommandsMatcherFactory final : public AbstractMatcherFactory<CommandsParse
public:
explicit CommandsMatcherFactory(const IMatcherForLabelSupplier<CommandsParserValue>* labelSupplier);
_NODISCARD MatcherFactoryWrapper<CommandsParserValue> Type(CommandsParserValueType type) const;
_NODISCARD MatcherFactoryWrapper<CommandsParserValue> Keyword(std::string value) const;
_NODISCARD MatcherFactoryWrapper<CommandsParserValue> Identifier() const;
_NODISCARD MatcherFactoryWrapper<CommandsParserValue> Integer() const;
_NODISCARD MatcherFactoryWrapper<CommandsParserValue> FloatingPoint() const;
_NODISCARD MatcherFactoryWrapper<CommandsParserValue> Char(char c) const;
[[nodiscard]] MatcherFactoryWrapper<CommandsParserValue> Type(CommandsParserValueType type) const;
[[nodiscard]] MatcherFactoryWrapper<CommandsParserValue> Keyword(std::string value) const;
[[nodiscard]] MatcherFactoryWrapper<CommandsParserValue> Identifier() const;
[[nodiscard]] MatcherFactoryWrapper<CommandsParserValue> Integer() const;
[[nodiscard]] MatcherFactoryWrapper<CommandsParserValue> FloatingPoint() 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>
{
size_t m_hash;
std::string m_value;
public:
explicit CommandsMatcherKeyword(std::string value);
protected:
MatcherResult<CommandsParserValue> CanMatch(ILexer<CommandsParserValue>* lexer, unsigned tokenOffset) override;
public:
explicit CommandsMatcherKeyword(std::string value);
private:
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>
{
CommandsParserValueType m_type;
public:
explicit CommandsMatcherValueType(CommandsParserValueType type);
protected:
MatcherResult<CommandsParserValue> CanMatch(ILexer<CommandsParserValue>* lexer, unsigned tokenOffset) override;
public:
explicit CommandsMatcherValueType(CommandsParserValueType type);
private:
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/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()
{
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
{
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;
public:
SequenceAction();
protected:
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/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_TYPE = 1;
}
SequenceAllocAlign::SequenceAllocAlign()
{
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
{
static constexpr auto CAPTURE_TYPE = 1;
public:
SequenceAllocAlign();
protected:
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/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_ARCHITECTURE = 1;
}
SequenceArchitecture::SequenceArchitecture()
{
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 <unordered_map>
class SequenceArchitecture final : public CommandsParser::sequence_t
{
static constexpr auto CAPTURE_ARCHITECTURE = 1;
std::unordered_map<std::string, Architecture> m_architecture_mapping;
public:
SequenceArchitecture();
protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public:
SequenceArchitecture();
private:
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/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_TYPE = 1;
}
SequenceArrayCount::SequenceArrayCount()
{
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
{
static constexpr auto CAPTURE_TYPE = 1;
public:
SequenceArrayCount();
protected:
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/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_TYPE = 1;
static constexpr auto CAPTURE_EVALUATION = 2;
} // namespace
SequenceArraySize::SequenceArraySize()
{
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
{
static constexpr auto CAPTURE_TYPE = 1;
static constexpr auto CAPTURE_EVALUATION = 2;
public:
SequenceArraySize();
protected:
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/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_TYPE = 1;
static constexpr auto CAPTURE_ENUM_ENTRY = 2;
} // namespace
SequenceAsset::SequenceAsset()
{
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
{
static constexpr auto CAPTURE_TYPE = 1;
static constexpr auto CAPTURE_ENUM_ENTRY = 2;
public:
SequenceAsset();
protected:
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>
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()
{
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
{
static constexpr auto TAG_DEFAULT = 1;
static constexpr auto CAPTURE_TYPE = 1;
static constexpr auto CAPTURE_ASSET_TYPE_ENUM_ENTRY = 2;
public:
SequenceAssetRef();
protected:
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/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()
{
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
{
static constexpr auto TAG_DEFAULT = 1;
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;
public:
SequenceBlock();
protected:
void ProcessMatch(CommandsParserState* state, SequenceResult<CommandsParserValue>& result) const override;
public:
SequenceBlock();
private:
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/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()
{
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
{
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;
public:
SequenceCondition();
protected:
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/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()
{
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
{
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
{
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;
static void SetCountByArrayIndex(CommandsParserState* state,
SequenceResult<CommandsParserValue>& result,
MemberInformation* member,
PointerDeclarationModifier* pointer,
std::unique_ptr<IEvaluation> evaluation);
public:
SequenceCount();
protected:
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/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_GAME = 1;
}
SequenceGame::SequenceGame()
{
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
{
static constexpr auto CAPTURE_GAME = 1;
public:
SequenceGame();
protected:
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/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_TYPE = 1;
}
SequenceName::SequenceName()
{
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
{
static constexpr auto CAPTURE_TYPE = 1;
public:
SequenceName();
protected:
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>
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()
{
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
{
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
{
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;
static StructureInformation* GetType(CommandsParserState* state, SequenceResult<CommandsParserValue>& result);
public:
SequenceReorder();
protected:
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/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_TYPE = 1;
}
SequenceReusable::SequenceReusable()
{
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
{
static constexpr auto CAPTURE_TYPE = 1;
public:
SequenceReusable();
protected:
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/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_TYPE = 1;
}
SequenceScriptString::SequenceScriptString()
{
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
{
static constexpr auto CAPTURE_TYPE = 1;
public:
SequenceScriptString();
protected:
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/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()
{
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
{
static constexpr auto CAPTURE_START = 1;
static constexpr auto CAPTURE_TYPE = 2;
static constexpr auto CAPTURE_BLOCK_ENUM_ENTRY = 3;
public:
SequenceSetBlock();
protected:
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>
namespace
{
static constexpr auto CAPTURE_TYPE = 1;
}
SequenceString::SequenceString()
{
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
{
static constexpr auto CAPTURE_TYPE = 1;
public:
SequenceString();
protected:
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/CommandsMatcherFactory.h"
namespace
{
static constexpr auto CAPTURE_TYPE = 1;
}
SequenceUse::SequenceUse()
{
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
{
static constexpr auto CAPTURE_TYPE = 1;
public:
SequenceUse();
protected:
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 "Utils/ClassUtils.h"
#include <memory>
#include <string>
#include <vector>
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:
HeaderBlockEnum(std::string typeName, const BaseTypeDefinition* parentType, bool isTypeDef);
@ -29,11 +23,22 @@ public:
void OnChildBlockClose(HeaderParserState* state, IHeaderBlock* block) override;
void AddEnumMember(std::unique_ptr<EnumMember> enumMember);
_NODISCARD EnumMember* GetEnumMember(const std::string& name) const;
_NODISCARD int GetNextEnumMemberValue() const;
[[nodiscard]] EnumMember* GetEnumMember(const std::string& name) const;
[[nodiscard]] int GetNextEnumMemberValue() const;
void SetBlockName(const TokenPos& nameTokenPos, std::string name) override;
bool IsDefiningVariable() override;
DataDefinition* GetVariableType() 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 <string>
#include <vector>
class HeaderBlockNamespace final : public IHeaderBlock
{
std::string m_namespace_name;
public:
explicit HeaderBlockNamespace(std::string namespaceName);
@ -14,4 +15,6 @@ public:
void OnOpen(HeaderParserState* state) override;
void OnClose(HeaderParserState* state) 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 "IHeaderBlockVariableHolder.h"
#include <memory>
#include <string>
#include <vector>
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:
HeaderBlockStruct(std::string name, bool isTypedef);
@ -41,4 +30,18 @@ public:
bool IsDefiningVariable() override;
DataDefinition* GetVariableType() 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 "IHeaderBlockVariableHolder.h"
#include <memory>
#include <string>
#include <vector>
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:
HeaderBlockUnion(std::string name, bool isTypedef);
@ -37,4 +28,18 @@ public:
bool IsDefiningVariable() override;
DataDefinition* GetVariableType() 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 <chrono>
#include <format>
#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)
: m_args(args),
m_filename(std::move(filename)),
@ -29,7 +36,7 @@ bool HeaderFileReader::OpenBaseStream()
auto stream = std::make_unique<ParserFilesystemStream>(m_filename);
if (!stream->IsOpen())
{
std::cout << "Could not open header file\n";
std::cerr << "Could not open header file\n";
return false;
}
@ -65,9 +72,7 @@ void HeaderFileReader::SetupPostProcessors()
bool HeaderFileReader::ReadHeaderFile(IDataRepository* repository)
{
if (m_args->m_verbose)
{
std::cout << "Reading header file: " << m_filename << "\n";
}
std::cout << std::format("Reading header file: {}\n", m_filename);
if (!OpenBaseStream())
return false;
@ -84,9 +89,7 @@ bool HeaderFileReader::ReadHeaderFile(IDataRepository* repository)
const auto end = std::chrono::steady_clock::now();
if (m_args->m_verbose)
{
std::cout << "Processing header took " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms\n";
}
std::cout << std::format("Processing header took {}ms\n", std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count());
if (!result)
return false;

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

@ -10,8 +10,15 @@
class HeaderFileReader
{
static constexpr const char* ZONE_CODE_GENERATOR_DEFINE_NAME = "__zonecodegenerator";
static constexpr const char* ZONE_CODE_GENERATOR_DEFINE_VALUE = "1";
public:
HeaderFileReader(const ZoneCodeGeneratorArguments* args, std::string filename);
bool ReadHeaderFile(IDataRepository* repository);
private:
bool OpenBaseStream();
void SetupStreamProxies();
void SetupPostProcessors();
const ZoneCodeGeneratorArguments* m_args;
std::string m_filename;
@ -21,13 +28,4 @@ class HeaderFileReader
IParserLineStream* m_stream;
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 "Parsing/Impl/AbstractLexer.h"
#include <string>
#include <unordered_map>
class HeaderLexer final : public AbstractLexer<HeaderParserValue>
{
std::unordered_map<std::string, HeaderParserValueType> m_keywords;
void PrepareKeywords();
public:
explicit HeaderLexer(IParserLineStream* stream);
protected:
HeaderParserValue GetNextToken() override;
public:
explicit HeaderLexer(IParserLineStream* stream);
private:
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>
{
protected:
const std::vector<sequence_t*>& GetTestsForState() override;
public:
HeaderParser(HeaderLexer* lexer, const IPackValueSupplier* packValueSupplier);
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 "Parsing/Header/Block/HeaderBlockNone.h"
#include <format>
#include <iostream>
HeaderParserState::HeaderParserState(const IPackValueSupplier* packValueSupplier)
@ -96,7 +97,7 @@ bool HeaderParserState::ResolveForwardDeclarations()
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;
}

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

@ -12,31 +12,15 @@
#include <memory>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
class IHeaderBlock;
class HeaderParserState
{
std::vector<std::unique_ptr<DataDefinition>> m_header_definitions;
std::stack<std::unique_ptr<IHeaderBlock>> m_blocks;
std::unordered_map<std::string, const DataDefinition*> m_definitions;
std::unordered_map<std::string, EnumMember*> m_enum_members;
std::unordered_map<std::string, std::unique_ptr<ForwardDeclaration>> m_forward_declarations;
void AddBaseDataType(const BaseTypeDefinition* baseType);
bool ResolveForwardDeclarations();
static bool ReplaceForwardDeclarationsInStruct(StructDefinition* structDefinition);
static bool ReplaceForwardDeclarationsInTypedef(TypedefDefinition* typedefDefinition);
static bool ReplaceForwardDeclarationsInUnion(UnionDefinition* unionDefinition);
bool ReplaceForwardDeclarationsInDefinitions();
bool MoveDefinitionsToRepository(IDataRepository* repository);
public:
const IPackValueSupplier* const m_pack_value_supplier;
NamespaceBuilder m_namespace;
explicit HeaderParserState(const IPackValueSupplier* packValueSupplier);
_NODISCARD IHeaderBlock* GetBlock() const;
@ -50,4 +34,23 @@ public:
EnumMember* FindEnumMember(const std::string& enumMemberName);
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
{
public:
TokenPos m_pos;
HeaderParserValueType m_type;
union ValueType
{
char char_value;
@ -90,23 +87,25 @@ public:
static HeaderParserValue Keyword(TokenPos pos, HeaderParserValueType type);
static HeaderParserValue TypeName(TokenPos pos, std::string* typeName);
private:
HeaderParserValue(TokenPos pos, HeaderParserValueType type);
public:
~HeaderParserValue() override;
HeaderParserValue(const HeaderParserValue& other) = delete;
HeaderParserValue(HeaderParserValue&& other) noexcept;
HeaderParserValue& operator=(const HeaderParserValue& other) = delete;
HeaderParserValue& operator=(HeaderParserValue&& other) noexcept;
_NODISCARD bool IsEof() const override;
_NODISCARD const TokenPos& GetPos() const override;
[[nodiscard]] bool IsEof() const override;
[[nodiscard]] const TokenPos& GetPos() const override;
_NODISCARD char CharacterValue() const;
_NODISCARD int IntegerValue() const;
_NODISCARD double FloatingPointValue() const;
_NODISCARD std::string& StringValue() const;
_NODISCARD std::string& IdentifierValue() const;
_NODISCARD std::string& TypeNameValue() const;
[[nodiscard]] char CharacterValue() const;
[[nodiscard]] int IntegerValue() const;
[[nodiscard]] double FloatingPointValue() const;
[[nodiscard]] std::string& StringValue() const;
[[nodiscard]] std::string& IdentifierValue() 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>
{
char m_char;
public:
explicit HeaderMatcherCharacter(char c);
protected:
MatcherResult<HeaderParserValue> CanMatch(ILexer<HeaderParserValue>* lexer, unsigned tokenOffset) override;
public:
explicit HeaderMatcherCharacter(char c);
private:
char m_char;
};

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

@ -8,9 +8,9 @@ class HeaderMatcherFactory final : public AbstractMatcherFactory<HeaderParserVal
public:
explicit HeaderMatcherFactory(const IMatcherForLabelSupplier<HeaderParserValue>* labelSupplier);
_NODISCARD MatcherFactoryWrapper<HeaderParserValue> Type(HeaderParserValueType type) const;
_NODISCARD MatcherFactoryWrapper<HeaderParserValue> Identifier() const;
_NODISCARD MatcherFactoryWrapper<HeaderParserValue> Integer() const;
_NODISCARD MatcherFactoryWrapper<HeaderParserValue> FloatingPoint() const;
_NODISCARD MatcherFactoryWrapper<HeaderParserValue> Char(char c) const;
[[nodiscard]] MatcherFactoryWrapper<HeaderParserValue> Type(HeaderParserValueType type) const;
[[nodiscard]] MatcherFactoryWrapper<HeaderParserValue> Identifier() const;
[[nodiscard]] MatcherFactoryWrapper<HeaderParserValue> Integer() const;
[[nodiscard]] MatcherFactoryWrapper<HeaderParserValue> FloatingPoint() 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>
{
HeaderParserValueType m_type;
public:
explicit HeaderMatcherValueType(HeaderParserValueType type);
protected:
MatcherResult<HeaderParserValue> CanMatch(ILexer<HeaderParserValue>* lexer, unsigned tokenOffset) override;
public:
explicit HeaderMatcherValueType(HeaderParserValueType type);
private:
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/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)
: m_semicolon_required(semicolonRequired)
{

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