Add menu sequence for name properties

src/ObjLoading/Game/IW4/AssetLoaders/AssetLoaderMenuList.cpp

@@ -48,7 +48,7 @@ bool AssetLoaderMenuList::LoadFromRaw(const std::string& assetName, ISearchPath*
 
         std::cout << "  " << menuFileResult->m_menus.size() << " menus:\n";
         for (const auto& menu : menuFileResult->m_menus)
-            std::cout << "    " << menu->m_name << "\n";
+            std::cout << "    " << menu->m_name << " (" << menu->m_items.size() << " items)\n";
 
         std::cout << "  " << menuFileResult->m_functions.size() << " functions:\n";
         for (const auto& function : menuFileResult->m_functions)

src/ObjLoading/Parsing/Menu/MenuFileParser.cpp

@@ -6,6 +6,7 @@
 #include "Sequence/SequenceLoadMenu.h"
 #include "Sequence/SequenceMenuDef.h"
 #include "Sequence/SequenceOpenGlobalScopeBlock.h"
+#include "Sequence/Properties/SequenceName.h"
 
 MenuFileParser::MenuFileParser(SimpleLexer* lexer, const MenuFeatureLevel featureLevel)
     : AbstractParser(lexer, std::make_unique<MenuFileParserState>(featureLevel))
@@ -34,17 +35,20 @@ void MenuFileParser::CreateGlobalScopeTests()
 
 void MenuFileParser::CreateFunctionScopeTests()
 {
+    AddTest(m_function_scope_tests, std::make_unique<SequenceName>());
     AddTest(m_function_scope_tests, std::make_unique<SequenceCloseBlock>());
 }
 
 void MenuFileParser::CreateMenuScopeTests()
 {
+    AddTest(m_menu_scope_tests, std::make_unique<SequenceName>());
     AddTest(m_menu_scope_tests, std::make_unique<SequenceCloseBlock>());
     AddTest(m_menu_scope_tests, std::make_unique<SequenceItemDef>());
 }
 
 void MenuFileParser::CreateItemScopeTests()
 {
+    AddTest(m_item_scope_tests, std::make_unique<SequenceName>());
     AddTest(m_item_scope_tests, std::make_unique<SequenceCloseBlock>());
 }
 

src/ObjLoading/Parsing/Menu/Sequence/Properties/SequenceName.cpp

@@ -0,0 +1,28 @@
+#include "SequenceName.h"
+
+#include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
+
+SequenceName::SequenceName()
+{
+    const SimpleMatcherFactory create(this);
+
+    AddMatchers({
+        create.KeywordIgnoreCase("name"),
+        create.Or({create.String(), create.Identifier()}).Capture(CAPTURE_NAME)
+    });
+}
+
+void SequenceName::ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const
+{
+    assert(state->m_current_item || state->m_current_menu || state->m_current_function);
+
+    const auto& nameToken = result.NextCapture(CAPTURE_NAME);
+    const auto nameValue = nameToken.m_type == SimpleParserValueType::IDENTIFIER ? nameToken.IdentifierValue() : nameToken.StringValue();
+
+    if (state->m_current_item)
+        state->m_current_item->m_name = nameValue;
+    else if (state->m_current_menu)
+        state->m_current_menu->m_name = nameValue;
+    else if (state->m_current_function)
+        state->m_current_function->m_name = nameValue;
+}

src/ObjLoading/Parsing/Menu/Sequence/Properties/SequenceName.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Parsing/Menu/MenuFileParser.h"
+
+class SequenceName final : public MenuFileParser::sequence_t
+{
+    static constexpr auto CAPTURE_NAME = 1;
+
+protected:
+    void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
+
+public:
+    SequenceName();
+};

src/ObjLoading/Parsing/Menu/Sequence/SequenceItemDef.cpp

@@ -14,7 +14,7 @@ SequenceItemDef::SequenceItemDef()
 
 void SequenceItemDef::ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const
 {
-    assert(!state->m_current_menu);
+    assert(state->m_current_menu);
 
     state->m_current_item = std::make_unique<CommonItemDef>();
 }