zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2025-07-01 08:41:52 +00:00
Code Activity

Reformat code with clang format

Browse Source
This commit is contained in:
Clang Format
2023-11-19 15:28:38 +01:00
committed by Jan
parent 22e17272fd
commit 6b4f5d94a8
1099 changed files with 16763 additions and 18076 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,21 +1,16 @@
#include "SequenceCloseBlock.h"
#include "Parsing/Header/Block/IHeaderBlockNameHolder.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
#include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
SequenceCloseBlock::SequenceCloseBlock(const bool semicolonRequired)
: m_semicolon_required(semicolonRequired)
{
const HeaderMatcherFactory create(this);
AddMatchers({
create.Char('}').Capture(CAPTURE_CLOSING_PARENTHESIS),
create.Optional(create.And({
create.Optional(create.Identifier().Capture(CAPTURE_NAME)),
create.Char(';').Tag(TAG_SEMICOLON)
}))
});
AddMatchers({create.Char('}').Capture(CAPTURE_CLOSING_PARENTHESIS),
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

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

@ -1,9 +1,9 @@
#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"
#include "Parsing/Sequence/AbstractSequence.h"
class SequenceCloseBlock final : public HeaderParser::sequence_t
{

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

@ -1,24 +1,19 @@
#include "SequenceEnum.h"
#include "Parsing/Header/Block/HeaderBlockEnum.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
#include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.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('{')
});
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
@ -30,7 +25,7 @@ void SequenceEnum::ProcessMatch(HeaderParserState* state, SequenceResult<HeaderP
if (result.HasNextCapture(CAPTURE_NAME))
name = result.NextCapture(CAPTURE_NAME).IdentifierValue();
if(result.HasNextCapture(CAPTURE_PARENT_TYPE))
if (result.HasNextCapture(CAPTURE_PARENT_TYPE))
{
const auto& typeNameToken = result.NextCapture(CAPTURE_PARENT_TYPE);
const auto* foundTypeDefinition = state->FindType(typeNameToken.TypeNameValue());

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

@ -1,9 +1,9 @@
#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"
#include "Parsing/Sequence/AbstractSequence.h"
class SequenceEnum final : public HeaderParser::sequence_t
{

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

@ -1,27 +1,17 @@
#include "SequenceEnumMember.h"
#include "Parsing/Header/Block/HeaderBlockEnum.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
#include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.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()
})
});
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

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

@ -1,9 +1,9 @@
#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"
#include "Parsing/Sequence/AbstractSequence.h"
class SequenceEnumMember final : public HeaderParser::sequence_t
{

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

@ -1,21 +1,19 @@
#include "SequenceForwardDecl.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
#include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
SequenceForwardDecl::SequenceForwardDecl()
{
const HeaderMatcherFactory create(this);
AddMatchers({
create.Or({
create.Type(HeaderParserValueType::ENUM).Tag(TAG_ENUM),
create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT),
create.Type(HeaderParserValueType::UNION).Tag(TAG_UNION)
}).Capture(CAPTURE_TYPE),
create.Identifier().Capture(CAPTURE_NAME),
create.Char(';')
});
AddMatchers({create
.Or({create.Type(HeaderParserValueType::ENUM).Tag(TAG_ENUM),
create.Type(HeaderParserValueType::STRUCT).Tag(TAG_STRUCT),
create.Type(HeaderParserValueType::UNION).Tag(TAG_UNION)})
.Capture(CAPTURE_TYPE),
create.Identifier().Capture(CAPTURE_NAME),
create.Char(';')});
}
void SequenceForwardDecl::ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const
@ -23,7 +21,7 @@ void SequenceForwardDecl::ProcessMatch(HeaderParserState* state, SequenceResult<
const auto typeTag = result.NextTag();
DataDefinitionType type;
switch(typeTag)
switch (typeTag)
{
case TAG_ENUM:
type = DataDefinitionType::ENUM;

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

@ -1,9 +1,9 @@
#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"
#include "Parsing/Sequence/AbstractSequence.h"
class SequenceForwardDecl final : public HeaderParser::sequence_t
{

7
src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceNamespace.cpp
View File

@ -1,6 +1,5 @@
#include "SequenceNamespace.h"
#include "Parsing/Header/Block/HeaderBlockNamespace.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
@ -8,11 +7,7 @@ SequenceNamespace::SequenceNamespace()
{
const HeaderMatcherFactory create(this);
AddMatchers({
create.Type(HeaderParserValueType::NAMESPACE),
create.Type(HeaderParserValueType::IDENTIFIER).Capture(CAPTURE_NAME),
create.Char('{')
});
AddMatchers({create.Type(HeaderParserValueType::NAMESPACE), create.Type(HeaderParserValueType::IDENTIFIER).Capture(CAPTURE_NAME), create.Char('{')});
}
void SequenceNamespace::ProcessMatch(HeaderParserState* state, SequenceResult<HeaderParserValue>& result) const

2
src/ZoneCodeGeneratorLib/Parsing/Header/Sequence/SequenceNamespace.h
View File

@ -1,9 +1,9 @@
#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"
#include "Parsing/Sequence/AbstractSequence.h"
class SequenceNamespace final : public HeaderParser::sequence_t
{

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

@ -1,8 +1,8 @@
#include "SequenceStruct.h"
#include "Parsing/Header/Block/HeaderBlockStruct.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
#include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
SequenceStruct::SequenceStruct()
{
@ -10,18 +10,13 @@ SequenceStruct::SequenceStruct()
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('{')
});
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
@ -37,12 +32,12 @@ void SequenceStruct::ProcessMatch(HeaderParserState* state, SequenceResult<Heade
if (result.HasNextCapture(CAPTURE_ALIGN))
structBlock->SetCustomAlignment(result.NextCapture(CAPTURE_ALIGN).IntegerValue());
if(result.HasNextCapture(CAPTURE_PARENT_TYPE))
if (result.HasNextCapture(CAPTURE_PARENT_TYPE))
{
const auto& parentTypeToken = result.NextCapture(CAPTURE_PARENT_TYPE);
const auto* parentDefinition = state->FindType(parentTypeToken.TypeNameValue());
if(parentDefinition == nullptr && !state->m_namespace.IsEmpty())
if (parentDefinition == nullptr && !state->m_namespace.IsEmpty())
{
const auto fullTypeName = NamespaceBuilder::Combine(state->m_namespace.ToString(), parentTypeToken.TypeNameValue());
parentDefinition = state->FindType(fullTypeName);
@ -51,7 +46,7 @@ void SequenceStruct::ProcessMatch(HeaderParserState* state, SequenceResult<Heade
if (parentDefinition == nullptr)
throw ParsingException(parentTypeToken.GetPos(), "Cannot find specified parent type");
if(parentDefinition->GetType() != DataDefinitionType::STRUCT)
if (parentDefinition->GetType() != DataDefinitionType::STRUCT)
throw ParsingException(parentTypeToken.GetPos(), "Parent type must be a struct");
structBlock->Inherit(dynamic_cast<const StructDefinition*>(parentDefinition));

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

@ -1,9 +1,9 @@
#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"
#include "Parsing/Sequence/AbstractSequence.h"
class SequenceStruct final : public HeaderParser::sequence_t
{

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

@ -2,8 +2,8 @@
#include "Domain/Definition/ArrayDeclarationModifier.h"
#include "Domain/Definition/PointerDeclarationModifier.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
#include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
SequenceTypedef::SequenceTypedef()
{
@ -13,36 +13,28 @@ SequenceTypedef::SequenceTypedef()
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.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);
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)
})
});
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::AddPointerDeclarationModifiers(SequenceResult<HeaderParserValue>& result, TypeDeclaration* typeDeclaration) const
@ -93,7 +85,7 @@ void SequenceTypedef::ProcessMatch(HeaderParserState* state, SequenceResult<Head
auto typedefDefinition = std::make_unique<TypedefDefinition>(state->m_namespace.ToString(), name, std::make_unique<TypeDeclaration>(type));
typedefDefinition->m_type_declaration->m_is_const = result.PeekAndRemoveIfTag(TAG_CONST) == TAG_CONST;
if(result.HasNextCapture(CAPTURE_ALIGN))
if (result.HasNextCapture(CAPTURE_ALIGN))
{
const auto& alignToken = result.NextCapture(CAPTURE_ALIGN);
typedefDefinition->m_alignment_override = static_cast<unsigned>(alignToken.IntegerValue());

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

@ -1,9 +1,9 @@
#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"
#include "Parsing/Sequence/AbstractSequence.h"
class SequenceTypedef final : public HeaderParser::sequence_t
{

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

@ -1,8 +1,8 @@
#include "SequenceUnion.h"
#include "Parsing/Header/Block/HeaderBlockUnion.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
#include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
SequenceUnion::SequenceUnion()
{
@ -10,18 +10,13 @@ SequenceUnion::SequenceUnion()
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('{')
});
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

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

@ -1,9 +1,9 @@
#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"
#include "Parsing/Sequence/AbstractSequence.h"
class SequenceUnion final : public HeaderParser::sequence_t
{

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

@ -3,8 +3,8 @@
#include "Domain/Definition/ArrayDeclarationModifier.h"
#include "Domain/Definition/PointerDeclarationModifier.h"
#include "Parsing/Header/Block/IHeaderBlockVariableHolder.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
#include "Parsing/Header/Matcher/HeaderCommonMatchers.h"
#include "Parsing/Header/Matcher/HeaderMatcherFactory.h"
SequenceVariable::SequenceVariable()
{
@ -14,36 +14,26 @@ SequenceVariable::SequenceVariable()
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.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);
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).Tag(TAG_ARRAY_OF_POINTERS),
create.Label(LABEL_POINTER_TO_ARRAY).Tag(TAG_POINTER_TO_ARRAY)
}));
AddMatchers(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 SequenceVariable::AddPointerDeclarationModifiers(SequenceResult<HeaderParserValue>& result, TypeDeclaration* typeDeclaration) const
@ -105,7 +95,7 @@ void SequenceVariable::ProcessMatch(HeaderParserState* state, SequenceResult<Hea
variable->m_has_alignment_override = true;
}
if(result.HasNextCapture(CAPTURE_BIT_SIZE))
if (result.HasNextCapture(CAPTURE_BIT_SIZE))
{
const auto& bitSizeToken = result.NextCapture(CAPTURE_BIT_SIZE);
variable->m_type_declaration->m_custom_bit_size = bitSizeToken.IntegerValue();

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

@ -1,9 +1,9 @@
#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"
#include "Parsing/Sequence/AbstractSequence.h"
class SequenceVariable final : public HeaderParser::sequence_t
{