INSANEMODE/OpenAssetTools
1
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2025-06-18 10:47:57 -05:00
Code Issues Packages Projects Releases Wiki 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

864
src/ObjLoading/Parsing/Menu/Sequence/EventHandlerSetScopeSequences.cpp
View File

File diff suppressed because it is too large Load Diff

5
src/ObjLoading/Parsing/Menu/Sequence/EventHandlerSetScopeSequences.h
View File

@ -8,8 +8,9 @@ namespace menu
class EventHandlerSetScopeSequences final : AbstractScopeSequenceHolder<MenuFileParser>
{
public:
EventHandlerSetScopeSequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences);
EventHandlerSetScopeSequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences,
std::vector<MenuFileParser::sequence_t*>& scopeSequences);
void AddSequences(FeatureLevel featureLevel, bool permissive) const;
};
}
} // namespace menu

127
src/ObjLoading/Parsing/Menu/Sequence/FunctionScopeSequences.cpp
View File

@ -1,86 +1,89 @@
#include "FunctionScopeSequences.h"
#include <sstream>
#include "Generic/GenericExpressionPropertySequence.h"
#include "Generic/GenericStringPropertySequence.h"
#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
#include <sstream>
using namespace menu;
namespace menu::function_scope_sequences
{
class SequenceCloseBlock final : public MenuFileParser::sequence_t
{
static constexpr auto CAPTURE_TOKEN = 1;
class SequenceCloseBlock final : public MenuFileParser::sequence_t
{
static constexpr auto CAPTURE_TOKEN = 1;
public:
SequenceCloseBlock()
{
const MenuMatcherFactory create(this);
public:
SequenceCloseBlock()
{
const MenuMatcherFactory create(this);
AddMatchers({
create.Char('}').Capture(CAPTURE_TOKEN)
});
}
AddMatchers({create.Char('}').Capture(CAPTURE_TOKEN)});
}
protected:
void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override
{
if (!state->m_current_function->m_value)
{
std::ostringstream ss;
ss << "Cannot define function name \"" << state->m_current_function->m_name << "\" without a value";
throw ParsingException(result.NextCapture(CAPTURE_TOKEN).GetPos(), ss.str());
}
protected:
void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override
{
if (!state->m_current_function->m_value)
{
std::ostringstream ss;
ss << "Cannot define function name \"" << state->m_current_function->m_name << "\" without a value";
throw ParsingException(result.NextCapture(CAPTURE_TOKEN).GetPos(), ss.str());
}
const auto existingFunction = state->m_functions_by_name.find(state->m_current_function->m_name);
if (existingFunction == state->m_functions_by_name.end())
{
state->m_functions_by_name.emplace(std::make_pair(state->m_current_function->m_name, state->m_current_function));
state->m_current_function = nullptr;
}
else if (!state->m_current_function->m_value->Equals(existingFunction->second->m_value.get()))
{
std::ostringstream ss;
ss << "Function with name \"" << state->m_current_function->m_name << "\" already exists";
throw ParsingException(result.NextCapture(CAPTURE_TOKEN).GetPos(), ss.str());
}
else
{
// Remove definition of function to not re-add it
const auto foundFunction = std::find_if(state->m_functions.rbegin(), state->m_functions.rend(), [state](const auto& element)
{
return element.get() == state->m_current_function;
});
assert(foundFunction != state->m_functions.rend());
assert((foundFunction + 1).base()->get() == state->m_current_function);
if (foundFunction != state->m_functions.rend())
state->m_functions.erase((foundFunction + 1).base());
const auto existingFunction = state->m_functions_by_name.find(state->m_current_function->m_name);
if (existingFunction == state->m_functions_by_name.end())
{
state->m_functions_by_name.emplace(std::make_pair(state->m_current_function->m_name, state->m_current_function));
state->m_current_function = nullptr;
}
else if (!state->m_current_function->m_value->Equals(existingFunction->second->m_value.get()))
{
std::ostringstream ss;
ss << "Function with name \"" << state->m_current_function->m_name << "\" already exists";
throw ParsingException(result.NextCapture(CAPTURE_TOKEN).GetPos(), ss.str());
}
else
{
// Remove definition of function to not re-add it
const auto foundFunction = std::find_if(state->m_functions.rbegin(),
state->m_functions.rend(),
[state](const auto& element)
{
return element.get() == state->m_current_function;
});
state->m_current_function = nullptr;
}
}
};
}
assert(foundFunction != state->m_functions.rend());
assert((foundFunction + 1).base()->get() == state->m_current_function);
if (foundFunction != state->m_functions.rend())
state->m_functions.erase((foundFunction + 1).base());
state->m_current_function = nullptr;
}
}
};
} // namespace menu::function_scope_sequences
using namespace function_scope_sequences;
FunctionScopeSequences::FunctionScopeSequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences)
: AbstractScopeSequenceHolder(allSequences, scopeSequences)
FunctionScopeSequences::FunctionScopeSequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences,
std::vector<MenuFileParser::sequence_t*>& scopeSequences)
: AbstractScopeSequenceHolder(allSequences, scopeSequences)
{
}
void FunctionScopeSequences::AddSequences(FeatureLevel featureLevel, bool permissive) const
{
AddSequence(std::make_unique<SequenceCloseBlock>());
AddSequence(std::make_unique<GenericStringPropertySequence>("name", [](const MenuFileParserState* state, const TokenPos&, const std::string& value)
{
state->m_current_function->m_name = value;
}));
AddSequence(GenericExpressionPropertySequence::WithKeyword("value", [](const MenuFileParserState* state, const TokenPos&, std::unique_ptr<ISimpleExpression> value)
{
state->m_current_function->m_value = std::move(value);
}));
AddSequence(std::make_unique<SequenceCloseBlock>());
AddSequence(std::make_unique<GenericStringPropertySequence>("name",
[](const MenuFileParserState* state, const TokenPos&, const std::string& value)
{
state->m_current_function->m_name = value;
}));
AddSequence(GenericExpressionPropertySequence::WithKeyword("value",
[](const MenuFileParserState* state, const TokenPos&, std::unique_ptr<ISimpleExpression> value)
{
state->m_current_function->m_value = std::move(value);
}));
}

5
src/ObjLoading/Parsing/Menu/Sequence/FunctionScopeSequences.h
View File

@ -8,8 +8,9 @@ namespace menu
class FunctionScopeSequences final : AbstractScopeSequenceHolder<MenuFileParser>
{
public:
FunctionScopeSequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences);
FunctionScopeSequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences,
std::vector<MenuFileParser::sequence_t*>& scopeSequences);
void AddSequences(FeatureLevel featureLevel, bool permissive) const;
};
}
} // namespace menu

9
src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericBoolPropertySequence.cpp
View File

@ -1,9 +1,9 @@
#include "GenericBoolPropertySequence.h"
#include <utility>
#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
#include <utility>
using namespace menu;
GenericBoolPropertySequence::GenericBoolPropertySequence(std::string keywordName, callback_t setCallback)
@ -11,10 +11,7 @@ GenericBoolPropertySequence::GenericBoolPropertySequence(std::string keywordName
{
const MenuMatcherFactory create(this);
AddMatchers({
create.KeywordIgnoreCase(std::move(keywordName)).Capture(CAPTURE_FIRST_TOKEN),
create.Integer().Capture(CAPTURE_VALUE)
});
AddMatchers({create.KeywordIgnoreCase(std::move(keywordName)).Capture(CAPTURE_FIRST_TOKEN), create.Integer().Capture(CAPTURE_VALUE)});
}
void GenericBoolPropertySequence::ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const

8
src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericBoolPropertySequence.h
View File

@ -1,10 +1,10 @@
#pragma once
#include <string>
#include <functional>
#include "Parsing/Menu/MenuFileParser.h"
#include <functional>
#include <string>
namespace menu
{
class GenericBoolPropertySequence final : public MenuFileParser::sequence_t
@ -24,4 +24,4 @@ namespace menu
public:
GenericBoolPropertySequence(std::string keywordName, callback_t setCallback);
};
}
} // namespace menu

8
src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericColorPropertySequence.cpp
View File

@ -1,10 +1,10 @@
#include "GenericColorPropertySequence.h"
#include <utility>
#include "Parsing/Menu/Matcher/MenuExpressionMatchers.h"
#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
#include <utility>
using namespace menu;
GenericColorPropertySequence::GenericColorPropertySequence(std::string keywordName, callback_t setCallback)
@ -15,10 +15,10 @@ GenericColorPropertySequence::GenericColorPropertySequence(std::string keywordNa
AddLabeledMatchers(MenuExpressionMatchers().Expression(this), MenuExpressionMatchers::LABEL_EXPRESSION);
AddMatchers({
create.KeywordIgnoreCase(std::move(keywordName)).Capture(CAPTURE_FIRST_TOKEN),
create.NumericExpression().Tag(TAG_COLOR), // r
create.NumericExpression().Tag(TAG_COLOR), // r
create.Optional(create.NumericExpression().Tag(TAG_COLOR)), // g
create.Optional(create.NumericExpression().Tag(TAG_COLOR)), // b
create.Optional(create.NumericExpression().Tag(TAG_COLOR)) // a
create.Optional(create.NumericExpression().Tag(TAG_COLOR)) // a
});
}

10
src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericColorPropertySequence.h
View File

@ -1,10 +1,10 @@
#pragma once
#include <string>
#include <functional>
#include "Parsing/Menu/MenuFileParser.h"
#include "Parsing/Menu/Domain/CommonMenuTypes.h"
#include "Parsing/Menu/MenuFileParser.h"
#include <functional>
#include <string>
namespace menu
{
@ -28,4 +28,4 @@ namespace menu
public:
GenericColorPropertySequence(std::string keywordName, callback_t setCallback);
};
}
} // namespace menu

33
src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericExpressionPropertySequence.cpp
View File

@ -1,10 +1,10 @@
#include "GenericExpressionPropertySequence.h"
#include <utility>
#include "Parsing/Menu/Matcher/MenuExpressionMatchers.h"
#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
#include <utility>
using namespace menu;
GenericExpressionPropertySequence::GenericExpressionPropertySequence(callback_t setCallback)
@ -19,16 +19,15 @@ std::unique_ptr<GenericExpressionPropertySequence> GenericExpressionPropertySequ
auto result = std::unique_ptr<GenericExpressionPropertySequence>(new GenericExpressionPropertySequence(std::move(setCallback)));
const MenuMatcherFactory create(result.get());
result->AddMatchers({
create.KeywordIgnoreCase(std::move(keyword)).Capture(CAPTURE_FIRST_TOKEN),
create.Label(MenuExpressionMatchers::LABEL_EXPRESSION),
create.Optional(create.Char(';'))
});
result->AddMatchers({create.KeywordIgnoreCase(std::move(keyword)).Capture(CAPTURE_FIRST_TOKEN),
create.Label(MenuExpressionMatchers::LABEL_EXPRESSION),
create.Optional(create.Char(';'))});
return std::move(result);
}
std::unique_ptr<GenericExpressionPropertySequence> GenericExpressionPropertySequence::WithKeywords(const std::initializer_list<std::string> keywords, callback_t setCallback)
std::unique_ptr<GenericExpressionPropertySequence> GenericExpressionPropertySequence::WithKeywords(const std::initializer_list<std::string> keywords,
callback_t setCallback)
{
auto result = std::unique_ptr<GenericExpressionPropertySequence>(new GenericExpressionPropertySequence(std::move(setCallback)));
@ -37,11 +36,9 @@ std::unique_ptr<GenericExpressionPropertySequence> GenericExpressionPropertySequ
for (auto keyword : keywords)
keywordMatchers.emplace_back(create.KeywordIgnoreCase(std::move(keyword)));
result->AddMatchers({
create.And(std::move(keywordMatchers)).Capture(CAPTURE_FIRST_TOKEN),
create.Label(MenuExpressionMatchers::LABEL_EXPRESSION),
create.Optional(create.Char(';'))
});
result->AddMatchers({create.And(std::move(keywordMatchers)).Capture(CAPTURE_FIRST_TOKEN),
create.Label(MenuExpressionMatchers::LABEL_EXPRESSION),
create.Optional(create.Char(';'))});
return std::move(result);
}
@ -51,12 +48,10 @@ std::unique_ptr<GenericExpressionPropertySequence> GenericExpressionPropertySequ
auto result = std::unique_ptr<GenericExpressionPropertySequence>(new GenericExpressionPropertySequence(std::move(setCallback)));
const MenuMatcherFactory create(result.get());
result->AddMatchers({
create.KeywordIgnoreCase(std::move(keyword)).Capture(CAPTURE_FIRST_TOKEN),
create.Optional(create.KeywordIgnoreCase("when")),
create.Label(MenuExpressionMatchers::LABEL_EXPRESSION),
create.Optional(create.Char(';'))
});
result->AddMatchers({create.KeywordIgnoreCase(std::move(keyword)).Capture(CAPTURE_FIRST_TOKEN),
create.Optional(create.KeywordIgnoreCase("when")),
create.Label(MenuExpressionMatchers::LABEL_EXPRESSION),
create.Optional(create.Char(';'))});
return std::move(result);
}

8
src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericExpressionPropertySequence.h
View File

@ -1,11 +1,11 @@
#pragma once
#include <string>
#include <functional>
#include "Parsing/Menu/MenuFileParser.h"
#include "Parsing/Simple/Expression/ISimpleExpression.h"
#include <functional>
#include <string>
namespace menu
{
class GenericExpressionPropertySequence final : public MenuFileParser::sequence_t
@ -29,4 +29,4 @@ namespace menu
static std::unique_ptr<GenericExpressionPropertySequence> WithKeywords(std::initializer_list<std::string> keywords, callback_t setCallback);
static std::unique_ptr<GenericExpressionPropertySequence> WithKeywordAndBool(std::string keyword, callback_t setCallback);
};
}
} // namespace menu

9
src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericFloatingPointPropertySequence.cpp
View File

@ -1,10 +1,10 @@
#include "GenericFloatingPointPropertySequence.h"
#include <utility>
#include "Parsing/Menu/Matcher/MenuExpressionMatchers.h"
#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
#include <utility>
using namespace menu;
GenericFloatingPointPropertySequence::GenericFloatingPointPropertySequence(std::string keywordName, callback_t setCallback)
@ -13,10 +13,7 @@ GenericFloatingPointPropertySequence::GenericFloatingPointPropertySequence(std::
const MenuMatcherFactory create(this);
AddLabeledMatchers(MenuExpressionMatchers().Expression(this), MenuExpressionMatchers::LABEL_EXPRESSION);
AddMatchers({
create.KeywordIgnoreCase(std::move(keywordName)).Capture(CAPTURE_FIRST_TOKEN),
create.NumericExpression()
});
AddMatchers({create.KeywordIgnoreCase(std::move(keywordName)).Capture(CAPTURE_FIRST_TOKEN), create.NumericExpression()});
}
void GenericFloatingPointPropertySequence::ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const

8
src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericFloatingPointPropertySequence.h
View File

@ -1,10 +1,10 @@
#pragma once
#include <string>
#include <functional>
#include "Parsing/Menu/MenuFileParser.h"
#include <functional>
#include <string>
namespace menu
{
class GenericFloatingPointPropertySequence final : public MenuFileParser::sequence_t
@ -23,4 +23,4 @@ namespace menu
public:
GenericFloatingPointPropertySequence(std::string keywordName, callback_t setCallback);
};
}
} // namespace menu

4
src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericIntPropertySequence.cpp
View File

@ -1,10 +1,10 @@
#include "GenericIntPropertySequence.h"
#include <utility>
#include "Parsing/Menu/Matcher/MenuExpressionMatchers.h"
#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
#include <utility>
using namespace menu;
GenericIntPropertySequence::GenericIntPropertySequence(std::string keywordName, callback_t setCallback)

8
src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericIntPropertySequence.h
View File

@ -1,10 +1,10 @@
#pragma once
#include <string>
#include <functional>
#include "Parsing/Menu/MenuFileParser.h"
#include <functional>
#include <string>
namespace menu
{
class GenericIntPropertySequence final : public MenuFileParser::sequence_t
@ -23,4 +23,4 @@ namespace menu
public:
GenericIntPropertySequence(std::string keywordName, callback_t setCallback);
};
}
} // namespace menu

4
src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericKeywordPropertySequence.cpp
View File

@ -1,9 +1,9 @@
#include "GenericKeywordPropertySequence.h"
#include <utility>
#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
#include <utility>
using namespace menu;
GenericKeywordPropertySequence::GenericKeywordPropertySequence(std::string keywordName, callback_t setCallback)

8
src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericKeywordPropertySequence.h
View File

@ -1,10 +1,10 @@
#pragma once
#include <string>
#include <functional>
#include "Parsing/Menu/MenuFileParser.h"
#include <functional>
#include <string>
namespace menu
{
class GenericKeywordPropertySequence final : public MenuFileParser::sequence_t
@ -23,4 +23,4 @@ namespace menu
public:
GenericKeywordPropertySequence(std::string keywordName, callback_t setCallback);
};
}
} // namespace menu

11
src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericMenuEventHandlerSetPropertySequence.cpp
View File

@ -1,9 +1,9 @@
#include "GenericMenuEventHandlerSetPropertySequence.h"
#include <utility>
#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
#include <utility>
using namespace menu;
GenericMenuEventHandlerSetPropertySequence::GenericMenuEventHandlerSetPropertySequence(std::string keywordName, callback_t setCallback)
@ -11,10 +11,7 @@ GenericMenuEventHandlerSetPropertySequence::GenericMenuEventHandlerSetPropertySe
{
const MenuMatcherFactory create(this);
AddMatchers({
create.KeywordIgnoreCase(std::move(keywordName)).Capture(CAPTURE_FIRST_TOKEN),
create.Char('{')
});
AddMatchers({create.KeywordIgnoreCase(std::move(keywordName)).Capture(CAPTURE_FIRST_TOKEN), create.Char('{')});
}
void GenericMenuEventHandlerSetPropertySequence::ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const
@ -22,7 +19,7 @@ void GenericMenuEventHandlerSetPropertySequence::ProcessMatch(MenuFileParserStat
if (m_set_callback)
{
auto& eventHandlerPtr = m_set_callback(state, result.NextCapture(CAPTURE_FIRST_TOKEN).GetPos());
if(!eventHandlerPtr)
if (!eventHandlerPtr)
eventHandlerPtr = std::make_unique<CommonEventHandlerSet>();
state->m_current_event_handler_set = eventHandlerPtr.get();

12
src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericMenuEventHandlerSetPropertySequence.h
View File

@ -1,17 +1,17 @@
#pragma once
#include <string>
#include <functional>
#include "Parsing/Menu/MenuFileParser.h"
#include "Parsing/Menu/Domain/EventHandler/CommonEventHandlerSet.h"
#include "Parsing/Menu/MenuFileParser.h"
#include <functional>
#include <string>
namespace menu
{
class GenericMenuEventHandlerSetPropertySequence final : public MenuFileParser::sequence_t
{
public:
using callback_t = std::function<std::unique_ptr<CommonEventHandlerSet>& (MenuFileParserState* state, const TokenPos& pos)>;
using callback_t = std::function<std::unique_ptr<CommonEventHandlerSet>&(MenuFileParserState* state, const TokenPos& pos)>;
private:
static constexpr auto CAPTURE_FIRST_TOKEN = 1;
@ -24,4 +24,4 @@ namespace menu
public:
GenericMenuEventHandlerSetPropertySequence(std::string keywordName, callback_t setCallback);
};
}
} // namespace menu

9
src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericStringPropertySequence.cpp
View File

@ -1,9 +1,9 @@
#include "GenericStringPropertySequence.h"
#include <utility>
#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
#include <utility>
using namespace menu;
GenericStringPropertySequence::GenericStringPropertySequence(std::string keywordName, callback_t setCallback)
@ -11,10 +11,7 @@ GenericStringPropertySequence::GenericStringPropertySequence(std::string keyword
{
const MenuMatcherFactory create(this);
AddMatchers({
create.KeywordIgnoreCase(std::move(keywordName)).Capture(CAPTURE_FIRST_TOKEN),
create.Text().Capture(CAPTURE_VALUE)
});
AddMatchers({create.KeywordIgnoreCase(std::move(keywordName)).Capture(CAPTURE_FIRST_TOKEN), create.Text().Capture(CAPTURE_VALUE)});
}
void GenericStringPropertySequence::ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const

8
src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericStringPropertySequence.h
View File

@ -1,10 +1,10 @@
#pragma once
#include <string>
#include <functional>
#include "Parsing/Menu/MenuFileParser.h"
#include <functional>
#include <string>
namespace menu
{
class GenericStringPropertySequence final : public MenuFileParser::sequence_t
@ -24,4 +24,4 @@ namespace menu
public:
GenericStringPropertySequence(std::string keywordName, callback_t setCallback);
};
}
} // namespace menu

9
src/ObjLoading/Parsing/Menu/Sequence/GlobalScopeSequences.cpp
View File

@ -14,9 +14,7 @@ namespace menu::global_scope_sequences
{
const MenuMatcherFactory create(this);
AddMatchers({
create.Char('}')
});
AddMatchers({create.Char('}')});
}
protected:
@ -98,11 +96,12 @@ namespace menu::global_scope_sequences
state->m_menus_to_load.emplace_back(menuNameToken.StringValue());
}
};
}
} // namespace menu::global_scope_sequences
using namespace global_scope_sequences;
GlobalScopeSequences::GlobalScopeSequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences)
GlobalScopeSequences::GlobalScopeSequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences,
std::vector<MenuFileParser::sequence_t*>& scopeSequences)
: AbstractScopeSequenceHolder(allSequences, scopeSequences)
{
}

2
src/ObjLoading/Parsing/Menu/Sequence/GlobalScopeSequences.h
View File

@ -12,4 +12,4 @@ namespace menu
void AddSequences(FeatureLevel featureLevel, bool permissive) const;
};
}
} // namespace menu

1158
src/ObjLoading/Parsing/Menu/Sequence/ItemScopeSequences.cpp
View File

File diff suppressed because it is too large Load Diff

2
src/ObjLoading/Parsing/Menu/Sequence/ItemScopeSequences.h
View File

@ -12,4 +12,4 @@ namespace menu
void AddSequences(FeatureLevel featureLevel, bool permissive) const;
};
}
} // namespace menu

472
src/ObjLoading/Parsing/Menu/Sequence/MenuScopeSequences.cpp
View File

@ -1,7 +1,5 @@
#include "MenuScopeSequences.h"
#include <sstream>
#include "Generic/GenericBoolPropertySequence.h"
#include "Generic/GenericColorPropertySequence.h"
#include "Generic/GenericExpressionPropertySequence.h"
@ -10,10 +8,12 @@
#include "Generic/GenericKeywordPropertySequence.h"
#include "Generic/GenericMenuEventHandlerSetPropertySequence.h"
#include "Generic/GenericStringPropertySequence.h"
#include "Parsing/Menu/MenuFileCommonOperations.h"
#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
#include "Parsing/Menu/Domain/CommonMenuTypes.h"
#include "Parsing/Menu/Matcher/MenuExpressionMatchers.h"
#include "Parsing/Menu/Matcher/MenuMatcherFactory.h"
#include "Parsing/Menu/MenuFileCommonOperations.h"
#include <sstream>
using namespace menu;
@ -28,9 +28,7 @@ namespace menu::menu_scope_sequences
{
const MenuMatcherFactory create(this);
AddMatchers({
create.Char('}').Capture(CAPTURE_TOKEN)
});
AddMatchers({create.Char('}').Capture(CAPTURE_TOKEN)});
}
protected:
@ -61,15 +59,11 @@ namespace menu::menu_scope_sequences
{
const MenuMatcherFactory create(this);
AddMatchers({
create.Char(';')
});
AddMatchers({create.Char(';')});
}
protected:
void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override
{
}
void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override {}
};
class SequenceItemDef final : public MenuFileParser::sequence_t
@ -81,10 +75,7 @@ namespace menu::menu_scope_sequences
{
const MenuMatcherFactory create(this);
AddMatchers({
create.Keyword("itemDef"),
create.Char('{')
});
AddMatchers({create.Keyword("itemDef"), create.Char('{')});
}
protected:
@ -107,17 +98,12 @@ namespace menu::menu_scope_sequences
const MenuMatcherFactory create(this);
AddLabeledMatchers(MenuExpressionMatchers().Expression(this), MenuExpressionMatchers::LABEL_EXPRESSION);
AddMatchers({
create.KeywordIgnoreCase("rect"),
create.NumericExpression(), // x
create.NumericExpression(), // y
create.NumericExpression(), // w
create.NumericExpression(), // h
create.Optional(create.And({
create.Integer().Capture(CAPTURE_ALIGN_HORIZONTAL),
create.Integer().Capture(CAPTURE_ALIGN_VERTICAL)
}))
});
AddMatchers({create.KeywordIgnoreCase("rect"),
create.NumericExpression(), // x
create.NumericExpression(), // y
create.NumericExpression(), // w
create.NumericExpression(), // h
create.Optional(create.And({create.Integer().Capture(CAPTURE_ALIGN_HORIZONTAL), create.Integer().Capture(CAPTURE_ALIGN_VERTICAL)}))});
}
protected:
@ -129,14 +115,7 @@ namespace menu::menu_scope_sequences
const auto y = MenuMatcherFactory::TokenNumericExpressionValue(state, result);
const auto w = MenuMatcherFactory::TokenNumericExpressionValue(state, result);
const auto h = MenuMatcherFactory::TokenNumericExpressionValue(state, result);
CommonRect rect
{
x,
y,
w,
h,
0, 0
};
CommonRect rect{x, y, w, h, 0, 0};
if (result.HasNextCapture(CAPTURE_ALIGN_HORIZONTAL) && result.HasNextCapture(CAPTURE_ALIGN_VERTICAL))
{
@ -157,11 +136,7 @@ namespace menu::menu_scope_sequences
{
const MenuMatcherFactory create(this);
AddMatchers({
create.KeywordIgnoreCase("execKey"),
create.StringChain().Capture(CAPTURE_KEY),
create.Char('{')
});
AddMatchers({create.KeywordIgnoreCase("execKey"), create.StringChain().Capture(CAPTURE_KEY), create.Char('{')});
}
protected:
@ -193,11 +168,7 @@ namespace menu::menu_scope_sequences
{
const MenuMatcherFactory create(this);
AddMatchers({
create.KeywordIgnoreCase("execKeyInt"),
create.Integer().Capture(CAPTURE_KEY),
create.Char('{')
});
AddMatchers({create.KeywordIgnoreCase("execKeyInt"), create.Integer().Capture(CAPTURE_KEY), create.Char('{')});
}
protected:
@ -217,11 +188,12 @@ namespace menu::menu_scope_sequences
state->m_current_menu->m_key_handlers.emplace(std::make_pair(keyValue, std::move(newEventHandlerSet)));
}
};
}
} // namespace menu::menu_scope_sequences
using namespace menu_scope_sequences;
MenuScopeSequences::MenuScopeSequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences)
MenuScopeSequences::MenuScopeSequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences,
std::vector<MenuFileParser::sequence_t*>& scopeSequences)
: AbstractScopeSequenceHolder(allSequences, scopeSequences)
{
}
@ -230,190 +202,248 @@ void MenuScopeSequences::AddSequences(FeatureLevel featureLevel, bool permissive
{
AddSequence(std::make_unique<SequenceCloseBlock>());
AddSequence(std::make_unique<SequenceItemDef>());
AddSequence(std::make_unique<GenericStringPropertySequence>("name", [](const MenuFileParserState* state, const TokenPos&, const std::string& value)
{
state->m_current_menu->m_name = value;
}));
AddSequence(std::make_unique<GenericBoolPropertySequence>("fullScreen", [](const MenuFileParserState* state, const TokenPos&, const bool value)
{
state->m_current_menu->m_full_screen = value;
}));
AddSequence(std::make_unique<GenericKeywordPropertySequence>("screenSpace", [](const MenuFileParserState* state, const TokenPos&)
{
state->m_current_menu->m_screen_space = true;
}));
AddSequence(std::make_unique<GenericKeywordPropertySequence>("decoration", [](const MenuFileParserState* state, const TokenPos&)
{
state->m_current_menu->m_decoration = true;
}));
AddSequence(std::make_unique<GenericStringPropertySequence>("name",
[](const MenuFileParserState* state, const TokenPos&, const std::string& value)
{
state->m_current_menu->m_name = value;
}));
AddSequence(std::make_unique<GenericBoolPropertySequence>("fullScreen",
[](const MenuFileParserState* state, const TokenPos&, const bool value)
{
state->m_current_menu->m_full_screen = value;
}));
AddSequence(std::make_unique<GenericKeywordPropertySequence>("screenSpace",
[](const MenuFileParserState* state, const TokenPos&)
{
state->m_current_menu->m_screen_space = true;
}));
AddSequence(std::make_unique<GenericKeywordPropertySequence>("decoration",
[](const MenuFileParserState* state, const TokenPos&)
{
state->m_current_menu->m_decoration = true;
}));
AddSequence(std::make_unique<SequenceRect>());
// rect480
// rect720
// pos480
// pos720
AddSequence(std::make_unique<GenericIntPropertySequence>("style", [](const MenuFileParserState* state, const TokenPos&, const int value)
{
state->m_current_menu->m_style = value;
}));
AddSequence(GenericExpressionPropertySequence::WithKeywordAndBool("visible", [](const MenuFileParserState* state, const TokenPos& pos, std::unique_ptr<ISimpleExpression> value)
{
MenuFileCommonOperations::EnsureIsNumericExpression(state, pos, *value);
state->m_current_menu->m_visible_expression = std::move(value);
}));
AddSequence(std::make_unique<GenericMenuEventHandlerSetPropertySequence>("onOpen", [](const MenuFileParserState* state, const TokenPos&) -> std::unique_ptr<CommonEventHandlerSet>& {
return state->m_current_menu->m_on_open;
}));
AddSequence(std::make_unique<GenericMenuEventHandlerSetPropertySequence>("onClose", [](const MenuFileParserState* state, const TokenPos&) -> std::unique_ptr<CommonEventHandlerSet>& {
return state->m_current_menu->m_on_close;
}));
AddSequence(std::make_unique<GenericMenuEventHandlerSetPropertySequence>("onRequestClose", [](const MenuFileParserState* state, const TokenPos&) -> std::unique_ptr<CommonEventHandlerSet>& {
return state->m_current_menu->m_on_request_close;
}));
AddSequence(std::make_unique<GenericMenuEventHandlerSetPropertySequence>("onESC", [](const MenuFileParserState* state, const TokenPos&) -> std::unique_ptr<CommonEventHandlerSet>& {
return state->m_current_menu->m_on_esc;
}));
AddSequence(std::make_unique<GenericIntPropertySequence>("border", [](const MenuFileParserState* state, const TokenPos&, const int value)
{
state->m_current_menu->m_border = value;
}));
AddSequence(std::make_unique<GenericFloatingPointPropertySequence>("borderSize", [](const MenuFileParserState* state, const TokenPos&, const double value)
{
state->m_current_menu->m_border_size = value;
}));
AddSequence(std::make_unique<GenericColorPropertySequence>("backcolor", [](const MenuFileParserState* state, const TokenPos&, const CommonColor value)
{
state->m_current_menu->m_back_color = value;
}));
AddSequence(std::make_unique<GenericColorPropertySequence>("forecolor", [](const MenuFileParserState* state, const TokenPos&, const CommonColor value)
{
state->m_current_menu->m_fore_color = value;
}));
AddSequence(std::make_unique<GenericColorPropertySequence>("bordercolor", [](const MenuFileParserState* state, const TokenPos&, const CommonColor value)
{
state->m_current_menu->m_border_color = value;
}));
AddSequence(std::make_unique<GenericColorPropertySequence>("focuscolor", [](const MenuFileParserState* state, const TokenPos&, const CommonColor value)
{
state->m_current_menu->m_focus_color = value;
}));
AddSequence(std::make_unique<GenericColorPropertySequence>("outlinecolor", [](const MenuFileParserState* state, const TokenPos&, const CommonColor value)
{
state->m_current_menu->m_outline_color = value;
}));
AddSequence(std::make_unique<GenericStringPropertySequence>("background", [](const MenuFileParserState* state, const TokenPos&, const std::string& value)
{
state->m_current_menu->m_background = value;
}));
AddSequence(std::make_unique<GenericIntPropertySequence>("ownerdraw", [](const MenuFileParserState* state, const TokenPos&, const int value)
{
state->m_current_menu->m_owner_draw = value;
}));
AddSequence(std::make_unique<GenericIntPropertySequence>("ownerdrawFlag", [](const MenuFileParserState* state, const TokenPos&, const int value)
{
state->m_current_menu->m_owner_draw_flags |= value;
}));
AddSequence(std::make_unique<GenericKeywordPropertySequence>("outOfBoundsClick", [](const MenuFileParserState* state, const TokenPos&)
{
state->m_current_menu->m_out_of_bounds_click = true;
}));
AddSequence(std::make_unique<GenericStringPropertySequence>("soundLoop", [](const MenuFileParserState* state, const TokenPos&, const std::string& value)
{
state->m_current_menu->m_sound_loop = value;
}));
AddSequence(GenericExpressionPropertySequence::WithKeywords({"exp", "rect", "X"}, [](const MenuFileParserState* state, const TokenPos& pos, std::unique_ptr<ISimpleExpression> value)
{
MenuFileCommonOperations::EnsureIsNumericExpression(state, pos, *value);
state->m_current_menu->m_rect_x_exp = std::move(value);
}));
AddSequence(GenericExpressionPropertySequence::WithKeywords({"exp", "rect", "Y"}, [](const MenuFileParserState* state, const TokenPos& pos, std::unique_ptr<ISimpleExpression> value)
{
MenuFileCommonOperations::EnsureIsNumericExpression(state, pos, *value);
state->m_current_menu->m_rect_y_exp = std::move(value);
}));
AddSequence(GenericExpressionPropertySequence::WithKeywords({"exp", "rect", "W"}, [](const MenuFileParserState* state, const TokenPos& pos, std::unique_ptr<ISimpleExpression> value)
{
MenuFileCommonOperations::EnsureIsNumericExpression(state, pos, *value);
state->m_current_menu->m_rect_w_exp = std::move(value);
}));
AddSequence(GenericExpressionPropertySequence::WithKeywords({"exp", "rect", "H"}, [](const MenuFileParserState* state, const TokenPos& pos, std::unique_ptr<ISimpleExpression> value)
{
MenuFileCommonOperations::EnsureIsNumericExpression(state, pos, *value);
state->m_current_menu->m_rect_h_exp = std::move(value);
}));
AddSequence(GenericExpressionPropertySequence::WithKeywords({"exp", "openSound"}, [](const MenuFileParserState* state, const TokenPos& pos, std::unique_ptr<ISimpleExpression> value)
{
MenuFileCommonOperations::EnsureIsStringExpression(state, pos, *value);
state->m_current_menu->m_open_sound_exp = std::move(value);
}));
AddSequence(GenericExpressionPropertySequence::WithKeywords({"exp", "closeSound"}, [](const MenuFileParserState* state, const TokenPos& pos, std::unique_ptr<ISimpleExpression> value)
{
MenuFileCommonOperations::EnsureIsStringExpression(state, pos, *value);
state->m_current_menu->m_close_sound_exp = std::move(value);
}));
AddSequence(std::make_unique<GenericKeywordPropertySequence>("popup", [](const MenuFileParserState* state, const TokenPos&)
{
state->m_current_menu->m_popup = true;
}));
AddSequence(std::make_unique<GenericFloatingPointPropertySequence>("fadeClamp", [](const MenuFileParserState* state, const TokenPos&, const double value)
{
state->m_current_menu->m_fade_clamp = value;
}));
AddSequence(std::make_unique<GenericIntPropertySequence>("fadeCycle", [](const MenuFileParserState* state, const TokenPos&, const int value)
{
state->m_current_menu->m_fade_cycle = value;
}));
AddSequence(std::make_unique<GenericFloatingPointPropertySequence>("fadeAmount", [](const MenuFileParserState* state, const TokenPos&, const double value)
{
state->m_current_menu->m_fade_amount = value;
}));
AddSequence(std::make_unique<GenericFloatingPointPropertySequence>("fadeInAmount", [](const MenuFileParserState* state, const TokenPos&, const double value)
{
state->m_current_menu->m_fade_in_amount = value;
}));
AddSequence(std::make_unique<GenericIntPropertySequence>("style",
[](const MenuFileParserState* state, const TokenPos&, const int value)
{
state->m_current_menu->m_style = value;
}));
AddSequence(GenericExpressionPropertySequence::WithKeywordAndBool(
"visible",
[](const MenuFileParserState* state, const TokenPos& pos, std::unique_ptr<ISimpleExpression> value)
{
MenuFileCommonOperations::EnsureIsNumericExpression(state, pos, *value);
state->m_current_menu->m_visible_expression = std::move(value);
}));
AddSequence(std::make_unique<GenericMenuEventHandlerSetPropertySequence>(
"onOpen",
[](const MenuFileParserState* state, const TokenPos&) -> std::unique_ptr<CommonEventHandlerSet>&
{
return state->m_current_menu->m_on_open;
}));
AddSequence(std::make_unique<GenericMenuEventHandlerSetPropertySequence>(
"onClose",
[](const MenuFileParserState* state, const TokenPos&) -> std::unique_ptr<CommonEventHandlerSet>&
{
return state->m_current_menu->m_on_close;
}));
AddSequence(std::make_unique<GenericMenuEventHandlerSetPropertySequence>(
"onRequestClose",
[](const MenuFileParserState* state, const TokenPos&) -> std::unique_ptr<CommonEventHandlerSet>&
{
return state->m_current_menu->m_on_request_close;
}));
AddSequence(std::make_unique<GenericMenuEventHandlerSetPropertySequence>(
"onESC",
[](const MenuFileParserState* state, const TokenPos&) -> std::unique_ptr<CommonEventHandlerSet>&
{
return state->m_current_menu->m_on_esc;
}));
AddSequence(std::make_unique<GenericIntPropertySequence>("border",
[](const MenuFileParserState* state, const TokenPos&, const int value)
{
state->m_current_menu->m_border = value;
}));
AddSequence(std::make_unique<GenericFloatingPointPropertySequence>("borderSize",
[](const MenuFileParserState* state, const TokenPos&, const double value)
{
state->m_current_menu->m_border_size = value;
}));
AddSequence(std::make_unique<GenericColorPropertySequence>("backcolor",
[](const MenuFileParserState* state, const TokenPos&, const CommonColor value)
{
state->m_current_menu->m_back_color = value;
}));
AddSequence(std::make_unique<GenericColorPropertySequence>("forecolor",
[](const MenuFileParserState* state, const TokenPos&, const CommonColor value)
{
state->m_current_menu->m_fore_color = value;
}));
AddSequence(std::make_unique<GenericColorPropertySequence>("bordercolor",
[](const MenuFileParserState* state, const TokenPos&, const CommonColor value)
{
state->m_current_menu->m_border_color = value;
}));
AddSequence(std::make_unique<GenericColorPropertySequence>("focuscolor",
[](const MenuFileParserState* state, const TokenPos&, const CommonColor value)
{
state->m_current_menu->m_focus_color = value;
}));
AddSequence(std::make_unique<GenericColorPropertySequence>("outlinecolor",
[](const MenuFileParserState* state, const TokenPos&, const CommonColor value)
{
state->m_current_menu->m_outline_color = value;
}));
AddSequence(std::make_unique<GenericStringPropertySequence>("background",
[](const MenuFileParserState* state, const TokenPos&, const std::string& value)
{
state->m_current_menu->m_background = value;
}));
AddSequence(std::make_unique<GenericIntPropertySequence>("ownerdraw",
[](const MenuFileParserState* state, const TokenPos&, const int value)
{
state->m_current_menu->m_owner_draw = value;
}));
AddSequence(std::make_unique<GenericIntPropertySequence>("ownerdrawFlag",
[](const MenuFileParserState* state, const TokenPos&, const int value)
{
state->m_current_menu->m_owner_draw_flags |= value;
}));
AddSequence(std::make_unique<GenericKeywordPropertySequence>("outOfBoundsClick",
[](const MenuFileParserState* state, const TokenPos&)
{
state->m_current_menu->m_out_of_bounds_click = true;
}));
AddSequence(std::make_unique<GenericStringPropertySequence>("soundLoop",
[](const MenuFileParserState* state, const TokenPos&, const std::string& value)
{
state->m_current_menu->m_sound_loop = value;
}));
AddSequence(
GenericExpressionPropertySequence::WithKeywords({"exp", "rect", "X"},
[](const MenuFileParserState* state, const TokenPos& pos, std::unique_ptr<ISimpleExpression> value)
{
MenuFileCommonOperations::EnsureIsNumericExpression(state, pos, *value);
state->m_current_menu->m_rect_x_exp = std::move(value);
}));
AddSequence(
GenericExpressionPropertySequence::WithKeywords({"exp", "rect", "Y"},
[](const MenuFileParserState* state, const TokenPos& pos, std::unique_ptr<ISimpleExpression> value)
{
MenuFileCommonOperations::EnsureIsNumericExpression(state, pos, *value);
state->m_current_menu->m_rect_y_exp = std::move(value);
}));
AddSequence(
GenericExpressionPropertySequence::WithKeywords({"exp", "rect", "W"},
[](const MenuFileParserState* state, const TokenPos& pos, std::unique_ptr<ISimpleExpression> value)
{
MenuFileCommonOperations::EnsureIsNumericExpression(state, pos, *value);
state->m_current_menu->m_rect_w_exp = std::move(value);
}));
AddSequence(
GenericExpressionPropertySequence::WithKeywords({"exp", "rect", "H"},
[](const MenuFileParserState* state, const TokenPos& pos, std::unique_ptr<ISimpleExpression> value)
{
MenuFileCommonOperations::EnsureIsNumericExpression(state, pos, *value);
state->m_current_menu->m_rect_h_exp = std::move(value);
}));
AddSequence(
GenericExpressionPropertySequence::WithKeywords({"exp", "openSound"},
[](const MenuFileParserState* state, const TokenPos& pos, std::unique_ptr<ISimpleExpression> value)
{
MenuFileCommonOperations::EnsureIsStringExpression(state, pos, *value);
state->m_current_menu->m_open_sound_exp = std::move(value);
}));
AddSequence(
GenericExpressionPropertySequence::WithKeywords({"exp", "closeSound"},
[](const MenuFileParserState* state, const TokenPos& pos, std::unique_ptr<ISimpleExpression> value)
{
MenuFileCommonOperations::EnsureIsStringExpression(state, pos, *value);
state->m_current_menu->m_close_sound_exp = std::move(value);
}));
AddSequence(std::make_unique<GenericKeywordPropertySequence>("popup",
[](const MenuFileParserState* state, const TokenPos&)
{
state->m_current_menu->m_popup = true;
}));
AddSequence(std::make_unique<GenericFloatingPointPropertySequence>("fadeClamp",
[](const MenuFileParserState* state, const TokenPos&, const double value)
{
state->m_current_menu->m_fade_clamp = value;
}));
AddSequence(std::make_unique<GenericIntPropertySequence>("fadeCycle",
[](const MenuFileParserState* state, const TokenPos&, const int value)
{
state->m_current_menu->m_fade_cycle = value;
}));
AddSequence(std::make_unique<GenericFloatingPointPropertySequence>("fadeAmount",
[](const MenuFileParserState* state, const TokenPos&, const double value)
{
state->m_current_menu->m_fade_amount = value;
}));
AddSequence(std::make_unique<GenericFloatingPointPropertySequence>("fadeInAmount",
[](const MenuFileParserState* state, const TokenPos&, const double value)
{
state->m_current_menu->m_fade_in_amount = value;
}));
AddSequence(std::make_unique<SequenceExecKey>());
AddSequence(std::make_unique<SequenceExecKeyInt>());
AddSequence(std::make_unique<GenericFloatingPointPropertySequence>("blurWorld", [](const MenuFileParserState* state, const TokenPos&, const double value)
{
state->m_current_menu->m_blur_radius = value;
}));
AddSequence(std::make_unique<GenericKeywordPropertySequence>("legacySplitScreenScale", [](const MenuFileParserState* state, const TokenPos&)
{
state->m_current_menu->m_legacy_split_screen_scale = true;
}));
AddSequence(std::make_unique<GenericKeywordPropertySequence>("hiddenDuringScope", [](const MenuFileParserState* state, const TokenPos&)
{
state->m_current_menu->m_hidden_during_scope = true;
}));
AddSequence(std::make_unique<GenericKeywordPropertySequence>("hiddenDuringFlashbang", [](const MenuFileParserState* state, const TokenPos&)
{
state->m_current_menu->m_hidden_during_flashbang = true;
}));
AddSequence(std::make_unique<GenericKeywordPropertySequence>("hiddenDuringUI", [](const MenuFileParserState* state, const TokenPos&)
{
state->m_current_menu->m_hidden_during_ui = true;
}));
AddSequence(std::make_unique<GenericStringPropertySequence>("allowedBinding", [](const MenuFileParserState* state, const TokenPos&, const std::string& value)
{
state->m_current_menu->m_allowed_binding = value;
}));
AddSequence(std::make_unique<GenericKeywordPropertySequence>("textOnlyFocus", [](const MenuFileParserState* state, const TokenPos&)
{
state->m_current_menu->m_text_only_focus = true;
}));
AddSequence(std::make_unique<GenericFloatingPointPropertySequence>("blurWorld",
[](const MenuFileParserState* state, const TokenPos&, const double value)
{
state->m_current_menu->m_blur_radius = value;
}));
AddSequence(std::make_unique<GenericKeywordPropertySequence>("legacySplitScreenScale",
[](const MenuFileParserState* state, const TokenPos&)
{
state->m_current_menu->m_legacy_split_screen_scale = true;
}));
AddSequence(std::make_unique<GenericKeywordPropertySequence>("hiddenDuringScope",
[](const MenuFileParserState* state, const TokenPos&)
{
state->m_current_menu->m_hidden_during_scope = true;
}));
AddSequence(std::make_unique<GenericKeywordPropertySequence>("hiddenDuringFlashbang",
[](const MenuFileParserState* state, const TokenPos&)
{
state->m_current_menu->m_hidden_during_flashbang = true;
}));
AddSequence(std::make_unique<GenericKeywordPropertySequence>("hiddenDuringUI",
[](const MenuFileParserState* state, const TokenPos&)
{
state->m_current_menu->m_hidden_during_ui = true;
}));
AddSequence(std::make_unique<GenericStringPropertySequence>("allowedBinding",
[](const MenuFileParserState* state, const TokenPos&, const std::string& value)
{
state->m_current_menu->m_allowed_binding = value;
}));
AddSequence(std::make_unique<GenericKeywordPropertySequence>("textOnlyFocus",
[](const MenuFileParserState* state, const TokenPos&)
{
state->m_current_menu->m_text_only_focus = true;
}));
if (featureLevel == FeatureLevel::IW5)
{
AddSequence(GenericExpressionPropertySequence::WithKeywords({"exp", "soundLoop"}, [](const MenuFileParserState* state, const TokenPos& pos, std::unique_ptr<ISimpleExpression> value)
{
MenuFileCommonOperations::EnsureIsStringExpression(state, pos, *value);
state->m_current_menu->m_sound_loop_exp = std::move(value);
}));
AddSequence(std::make_unique<GenericMenuEventHandlerSetPropertySequence>("onFocusDueToClose", [](const MenuFileParserState* state, const TokenPos&) -> std::unique_ptr<CommonEventHandlerSet>& {
return state->m_current_menu->m_on_focus_due_to_close;
}));
AddSequence(
GenericExpressionPropertySequence::WithKeywords({"exp", "soundLoop"},
[](const MenuFileParserState* state, const TokenPos& pos, std::unique_ptr<ISimpleExpression> value)
{
MenuFileCommonOperations::EnsureIsStringExpression(state, pos, *value);
state->m_current_menu->m_sound_loop_exp = std::move(value);
}));
AddSequence(std::make_unique<GenericMenuEventHandlerSetPropertySequence>(
"onFocusDueToClose",
[](const MenuFileParserState* state, const TokenPos&) -> std::unique_ptr<CommonEventHandlerSet>&
{
return state->m_current_menu->m_on_focus_due_to_close;
}));
}
AddSequence(std::make_unique<SequenceConsumeSemicolons>());
}

2
src/ObjLoading/Parsing/Menu/Sequence/MenuScopeSequences.h
View File

@ -12,4 +12,4 @@ namespace menu
void AddSequences(FeatureLevel featureLevel, bool permissive) const;
};
}
} // namespace menu

9
src/ObjLoading/Parsing/Menu/Sequence/NoScopeSequences.cpp
View File

@ -14,9 +14,7 @@ namespace menu::no_scope_sequences
{
const MenuMatcherFactory create(this);
AddMatchers({
create.Char('{')
});
AddMatchers({create.Char('{')});
}
protected:
@ -25,11 +23,12 @@ namespace menu::no_scope_sequences
state->m_in_global_scope = true;
}
};
}
} // namespace menu::no_scope_sequences
using namespace no_scope_sequences;
NoScopeSequences::NoScopeSequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences, std::vector<MenuFileParser::sequence_t*>& scopeSequences)
NoScopeSequences::NoScopeSequences(std::vector<std::unique_ptr<MenuFileParser::sequence_t>>& allSequences,
std::vector<MenuFileParser::sequence_t*>& scopeSequences)
: AbstractScopeSequenceHolder(allSequences, scopeSequences)
{
}

2
src/ObjLoading/Parsing/Menu/Sequence/NoScopeSequences.h
View File

@ -12,4 +12,4 @@ namespace menu
void AddSequences(FeatureLevel featureLevel, bool permissive) const;
};
}
} // namespace menu