zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2025-09-03 23:37:26 +00:00
Code Activity

Add header sequences for zcg cpp

Browse Source
This commit is contained in:
Jan
2021-02-13 18:18:47 +01:00
parent f14357537e
commit 40fedc905d
21 changed files with 539 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -0,0 +1,21 @@
#include "SequenceCloseBlock.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
#include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
SequenceCloseBlock::SequenceCloseBlock()
{
const HeaderMatcherFactory create(this);
AddMatchers({
create.Char('}'),
create.Optional(create.And({
create.Optional(create.Identifier().Capture(CAPTURE_NAME)),
create.Char(';').Tag(TAG_SEMICOLON)
}))
});
}
void SequenceCloseBlock::ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const
{
}

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

@@ -0,0 +1,19 @@
#pragma once
#include "Parsing/Header/Impl/HeaderParser.h"
#include "Parsing/Sequence/AbstractSequence.h"
#include "Parsing/Header/Impl/HeaderParserState.h"
#include "Parsing/Header/Impl/HeaderParserValue.h"
class SequenceCloseBlock final : public HeaderParser::sequence_t
{
static constexpr auto TAG_SEMICOLON = 1;
static constexpr auto CAPTURE_NAME = 1;
protected:
void ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const override;
public:
SequenceCloseBlock();
};

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

@@ -0,0 +1,25 @@
#include "SequenceEnum.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
#include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
SequenceEnum::SequenceEnum()
{
const HeaderMatcherFactory create(this);
AddLabeledMatchers(HeaderCommonMatchers::Typename(this), HeaderCommonMatchers::LABEL_TYPENAME);
AddMatchers({
create.Optional(create.Type(HeaderParserValueType::TYPEDEF).Tag(TAG_TYPEDEF)),
create.Type(HeaderParserValueType::ENUM),
create.Optional(create.Identifier().Capture(CAPTURE_NAME)),
create.Optional(create.And({
create.Char(':'),
create.Label(HeaderCommonMatchers::LABEL_TYPENAME).Capture(CAPTURE_PARENT_TYPE)
})),
create.Char('{')
});
}
void SequenceEnum::ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const
{
}

20
src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceEnum.h
View File

@@ -0,0 +1,20 @@
#pragma once
#include "Parsing/Header/Impl/HeaderParser.h"
#include "Parsing/Sequence/AbstractSequence.h"
#include "Parsing/Header/Impl/HeaderParserState.h"
#include "Parsing/Header/Impl/HeaderParserValue.h"
class SequenceEnum final : public HeaderParser::sequence_t
{
static constexpr auto TAG_TYPEDEF = 1;
static constexpr auto CAPTURE_NAME = 1;
static constexpr auto CAPTURE_PARENT_TYPE = 2;
protected:
void ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const override;
public:
SequenceEnum();
};

28
src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceEnumMember.cpp
View File

@@ -0,0 +1,28 @@
#include "SequenceEnumMember.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
#include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
SequenceEnumMember::SequenceEnumMember()
{
const HeaderMatcherFactory create(this);
AddMatchers({
create.Identifier().Capture(CAPTURE_NAME),
create.Optional(create.And({
create.Char('='),
create.Or({
create.Identifier().Capture(CAPTURE_VALUE),
create.Integer().Capture(CAPTURE_VALUE)
})
})),
create.Or({
create.Char(','),
create.Char('}').NoConsume()
})
});
}
void SequenceEnumMember::ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const
{
}

18
src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceEnumMember.h
View File

@@ -0,0 +1,18 @@
#pragma once
#include "Parsing/Header/Impl/HeaderParser.h"
#include "Parsing/Sequence/AbstractSequence.h"
#include "Parsing/Header/Impl/HeaderParserState.h"
#include "Parsing/Header/Impl/HeaderParserValue.h"
class SequenceEnumMember final : public HeaderParser::sequence_t
{
static constexpr auto CAPTURE_NAME = 1;
static constexpr auto CAPTURE_VALUE = 2;
protected:
void ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const override;
public:
SequenceEnumMember();
};

23
src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceForwardDecl.cpp
View File

@@ -0,0 +1,23 @@
#include "SequenceForwardDecl.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
#include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
SequenceForwardDecl::SequenceForwardDecl()
{
const HeaderMatcherFactory create(this);
AddMatchers({
create.Or({
create.Type(HeaderParserValueType::ENUM),
create.Type(HeaderParserValueType::STRUCT),
create.Type(HeaderParserValueType::UNION)
}),
create.Identifier().Capture(CAPTURE_NAME),
create.Char(';')
});
}
void SequenceForwardDecl::ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const
{
}

21
src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceForwardDecl.h
View File

@@ -0,0 +1,21 @@
#pragma once
#include "Parsing/Header/Impl/HeaderParser.h"
#include "Parsing/Sequence/AbstractSequence.h"
#include "Parsing/Header/Impl/HeaderParserState.h"
#include "Parsing/Header/Impl/HeaderParserValue.h"
class SequenceForwardDecl final : public HeaderParser::sequence_t
{
static constexpr auto TAG_ENUM = 1;
static constexpr auto TAG_STRUCT = 2;
static constexpr auto TAG_UNION = 3;
static constexpr auto CAPTURE_NAME = 1;
protected:
void ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const override;
public:
SequenceForwardDecl();
};

28
src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceStruct.cpp
View File

@@ -0,0 +1,28 @@
#include "SequenceStruct.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
#include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
SequenceStruct::SequenceStruct()
{
const HeaderMatcherFactory create(this);
AddLabeledMatchers(HeaderCommonMatchers::Align(this), HeaderCommonMatchers::LABEL_ALIGN);
AddLabeledMatchers(HeaderCommonMatchers::Typename(this), HeaderCommonMatchers::LABEL_TYPENAME);
AddMatchers({
create.Optional(create.Type(HeaderParserValueType::TYPEDEF).Tag(TAG_TYPEDEF)),
create.Optional(create.Type(HeaderParserValueType::CONST)),
create.Type(HeaderParserValueType::STRUCT),
create.Optional(create.Label(HeaderCommonMatchers::LABEL_ALIGN).Capture(CAPTURE_ALIGN)),
create.Optional(create.Identifier().Capture(CAPTURE_NAME)),
create.Optional(create.And({
create.Char(':'),
create.Label(HeaderCommonMatchers::LABEL_TYPENAME).Capture(CAPTURE_PARENT_TYPE)
})),
create.Char('{')
});
}
void SequenceStruct::ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const
{
}

21
src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceStruct.h
View File

@@ -0,0 +1,21 @@
#pragma once
#include "Parsing/Header/Impl/HeaderParser.h"
#include "Parsing/Sequence/AbstractSequence.h"
#include "Parsing/Header/Impl/HeaderParserState.h"
#include "Parsing/Header/Impl/HeaderParserValue.h"
class SequenceStruct final : public HeaderParser::sequence_t
{
static constexpr int TAG_TYPEDEF = 1;
static constexpr int CAPTURE_NAME = 1;
static constexpr int CAPTURE_ALIGN = 2;
static constexpr int CAPTURE_PARENT_TYPE = 3;
protected:
void ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const override;
public:
SequenceStruct();
};

48
src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceTypedef.cpp
View File

@@ -0,0 +1,48 @@
#include "SequenceTypedef.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
#include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
SequenceTypedef::SequenceTypedef()
{
const HeaderMatcherFactory create(this);
AddLabeledMatchers(HeaderCommonMatchers::Align(this), HeaderCommonMatchers::LABEL_ALIGN);
AddLabeledMatchers(HeaderCommonMatchers::ArrayDef(this), HeaderCommonMatchers::LABEL_ARRAY_DEF);
AddLabeledMatchers(HeaderCommonMatchers::Typename(this), HeaderCommonMatchers::LABEL_TYPENAME);
AddLabeledMatchers(
{
create.Optional(create.Type(HeaderParserValueType::CONST).Tag(TAG_CONST)),
create.Label(HeaderCommonMatchers::LABEL_TYPENAME).Capture(CAPTURE_TYPE),
create.OptionalLoop(create.Char('*').Tag(TAG_POINTER)),
create.Identifier().Capture(CAPTURE_NAME),
create.OptionalLoop(create.Label(HeaderCommonMatchers::LABEL_ARRAY_DEF).Capture(CAPTURE_ARRAY)),
create.Char(';')
}, LABEL_ARRAY_OF_POINTERS);
AddLabeledMatchers(
{
create.Optional(create.Type(HeaderParserValueType::CONST).Tag(TAG_CONST)),
create.Label(HeaderCommonMatchers::LABEL_TYPENAME).Capture(CAPTURE_TYPE),
create.Char('('),
create.Loop(create.Char('*').Tag(TAG_POINTER)),
create.Identifier().Capture(CAPTURE_NAME),
create.Char(')'),
create.Loop(create.Label(HeaderCommonMatchers::LABEL_ARRAY_DEF).Capture(CAPTURE_ARRAY)),
create.Char(';')
}, LABEL_POINTER_TO_ARRAY);
AddMatchers({
create.Type(HeaderParserValueType::TYPEDEF),
create.Optional(create.Label(HeaderCommonMatchers::LABEL_ALIGN).Capture(CAPTURE_ALIGN)),
create.Or({
create.Label(LABEL_ARRAY_OF_POINTERS).Tag(TAG_ARRAY_OF_POINTERS),
create.Label(LABEL_POINTER_TO_ARRAY).Tag(TAG_POINTER_TO_ARRAY)
})
});
}
void SequenceTypedef::ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const
{
}

28
src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceTypedef.h
View File

@@ -0,0 +1,28 @@
#pragma once
#include "Parsing/Header/Impl/HeaderParser.h"
#include "Parsing/Sequence/AbstractSequence.h"
#include "Parsing/Header/Impl/HeaderParserState.h"
#include "Parsing/Header/Impl/HeaderParserValue.h"
class SequenceTypedef final : public HeaderParser::sequence_t
{
static constexpr auto TAG_ARRAY_OF_POINTERS = 1;
static constexpr auto TAG_POINTER_TO_ARRAY = 2;
static constexpr auto TAG_CONST = 3;
static constexpr auto TAG_POINTER = 4;
static constexpr auto CAPTURE_NAME = 1;
static constexpr auto CAPTURE_ALIGN = 2;
static constexpr auto CAPTURE_TYPE = 3;
static constexpr auto CAPTURE_ARRAY = 4;
static constexpr auto LABEL_ARRAY_OF_POINTERS = 1;
static constexpr auto LABEL_POINTER_TO_ARRAY = 2;
protected:
void ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const override;
public:
SequenceTypedef();
};

28
src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceUnion.cpp
View File

@@ -0,0 +1,28 @@
#include "SequenceUnion.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
#include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
SequenceUnion::SequenceUnion()
{
const HeaderMatcherFactory create(this);
AddLabeledMatchers(HeaderCommonMatchers::Align(this), HeaderCommonMatchers::LABEL_ALIGN);
AddLabeledMatchers(HeaderCommonMatchers::Typename(this), HeaderCommonMatchers::LABEL_TYPENAME);
AddMatchers({
create.Optional(create.Type(HeaderParserValueType::TYPEDEF).Tag(TAG_TYPEDEF)),
create.Optional(create.Type(HeaderParserValueType::CONST)),
create.Type(HeaderParserValueType::UNION),
create.Optional(create.Label(HeaderCommonMatchers::LABEL_ALIGN).Capture(CAPTURE_ALIGN)),
create.Optional(create.Identifier().Capture(CAPTURE_NAME)),
create.Optional(create.And({
create.Char(':'),
create.Label(HeaderCommonMatchers::LABEL_TYPENAME).Capture(CAPTURE_PARENT_TYPE)
})),
create.Char('{')
});
}
void SequenceUnion::ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const
{
}

21
src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceUnion.h
View File

@@ -0,0 +1,21 @@
#pragma once
#include "Parsing/Header/Impl/HeaderParser.h"
#include "Parsing/Sequence/AbstractSequence.h"
#include "Parsing/Header/Impl/HeaderParserState.h"
#include "Parsing/Header/Impl/HeaderParserValue.h"
class SequenceUnion final : public HeaderParser::sequence_t
{
static constexpr int TAG_TYPEDEF = 1;
static constexpr int CAPTURE_NAME = 1;
static constexpr int CAPTURE_ALIGN = 2;
static constexpr int CAPTURE_PARENT_TYPE = 3;
protected:
void ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const override;
public:
SequenceUnion();
};

48
src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceVariable.cpp
View File

@@ -0,0 +1,48 @@
#include "SequenceVariable.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
#include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
SequenceVariable::SequenceVariable()
{
const HeaderMatcherFactory create(this);
AddLabeledMatchers(HeaderCommonMatchers::Align(this), HeaderCommonMatchers::LABEL_ALIGN);
AddLabeledMatchers(HeaderCommonMatchers::ArrayDef(this), HeaderCommonMatchers::LABEL_ARRAY_DEF);
AddLabeledMatchers(HeaderCommonMatchers::Typename(this), HeaderCommonMatchers::LABEL_TYPENAME);
AddLabeledMatchers(
{
create.Optional(create.Type(HeaderParserValueType::CONST).Tag(TAG_CONST)),
create.Label(HeaderCommonMatchers::LABEL_TYPENAME).Capture(CAPTURE_TYPE),
create.OptionalLoop(create.Char('*').Tag(TAG_POINTER)),
create.Identifier().Capture(CAPTURE_NAME),
create.OptionalLoop(create.Label(HeaderCommonMatchers::LABEL_ARRAY_DEF).Capture(CAPTURE_ARRAY)),
create.Optional(create.And({
create.Char(':'),
create.Integer().Capture(CAPTURE_BIT_SIZE)
})),
create.Char(';')
}, LABEL_ARRAY_OF_POINTERS);
AddLabeledMatchers(
{
create.Optional(create.Type(HeaderParserValueType::CONST).Tag(TAG_CONST)),
create.Label(HeaderCommonMatchers::LABEL_TYPENAME).Capture(CAPTURE_TYPE),
create.Char('('),
create.Loop(create.Char('*').Tag(TAG_POINTER)),
create.Identifier().Capture(CAPTURE_NAME),
create.Char(')'),
create.Loop(create.Label(HeaderCommonMatchers::LABEL_ARRAY_DEF).Capture(CAPTURE_ARRAY)),
create.Char(';')
}, LABEL_POINTER_TO_ARRAY);
AddMatchers(create.Or({
create.Label(LABEL_ARRAY_OF_POINTERS),
create.Label(LABEL_POINTER_TO_ARRAY)
}));
}
void SequenceVariable::ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const
{
}

29
src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceVariable.h
View File

@@ -0,0 +1,29 @@
#pragma once
#include "Parsing/Header/Impl/HeaderParser.h"
#include "Parsing/Sequence/AbstractSequence.h"
#include "Parsing/Header/Impl/HeaderParserState.h"
#include "Parsing/Header/Impl/HeaderParserValue.h"
class SequenceVariable final : public HeaderParser::sequence_t
{
static constexpr auto TAG_ARRAY_OF_POINTERS = 1;
static constexpr auto TAG_POINTER_TO_ARRAY = 2;
static constexpr auto TAG_CONST = 3;
static constexpr auto TAG_POINTER = 4;
static constexpr auto CAPTURE_NAME = 1;
static constexpr auto CAPTURE_ALIGN = 2;
static constexpr auto CAPTURE_TYPE = 3;
static constexpr auto CAPTURE_ARRAY = 4;
static constexpr auto CAPTURE_BIT_SIZE = 5;
static constexpr auto LABEL_ARRAY_OF_POINTERS = 1;
static constexpr auto LABEL_POINTER_TO_ARRAY = 2;
protected:
void ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const override;
public:
SequenceVariable();
};