Add Menu Parsing Result

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

@@ -37,10 +37,25 @@ bool AssetLoaderMenuList::LoadFromRaw(const std::string& assetName, ISearchPath*
         return std::move(foundFileToInclude.m_stream);
     });
 
-    if(!reader.ReadMenuFile())
+    const auto menuFileResult = reader.ReadMenuFile();
+    if(menuFileResult)
     {
-        std::cout << "Could not read menu list \"" << assetName << "\"\n";
+        std::cout << "Successfully read menu list \"" << assetName << "\":\n";
+
+        std::cout << "  " << menuFileResult->m_menus_to_load.size() << " menus to load:\n";
+        for (const auto& menuToLoad : menuFileResult->m_menus_to_load)
+            std::cout << "    " << menuToLoad << "\n";
+
+        std::cout << "  " << menuFileResult->m_menus.size() << " menus:\n";
+        for (const auto& menu : menuFileResult->m_menus)
+            std::cout << "    " << menu->m_name << "\n";
+
+        std::cout << "  " << menuFileResult->m_functions.size() << " functions:\n";
+        for (const auto& function : menuFileResult->m_functions)
+            std::cout << "    " << function->m_name << "\n";
     }
+    else
+        std::cout << "Could not read menu list \"" << assetName << "\"\n";
 
     return true;
 }

src/ObjLoading/Parsing/Menu/Domain/MenuParsingResult.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "CommonFunctionDef.h"
+#include "CommonMenuDef.h"
+
+class MenuParsingResult
+{
+public:
+    std::vector<std::unique_ptr<CommonMenuDef>> m_menus;
+    std::vector<std::unique_ptr<CommonFunctionDef>> m_functions;
+    std::vector<std::string> m_menus_to_load;
+};

src/ObjLoading/Parsing/Menu/MenuFileParser.cpp

@@ -80,3 +80,8 @@ const std::vector<MenuFileParser::sequence_t*>& MenuFileParser::GetTestsForState
 
     return m_global_scope_tests;
 }
+
+MenuFileParserState* MenuFileParser::GetState() const
+{
+    return m_state.get();
+}

src/ObjLoading/Parsing/Menu/MenuFileParser.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "Utils/ClassUtils.h"
 #include "MenuFileParserState.h"
 #include "Parsing/Simple/SimpleLexer.h"
 #include "Parsing/Simple/SimpleParserValue.h"
@@ -27,4 +28,5 @@ protected:
 
 public:
     MenuFileParser(SimpleLexer* lexer, MenuFeatureLevel featureLevel);
+    _NODISCARD MenuFileParserState* GetState() const;
 };

src/ObjLoading/Parsing/Menu/MenuFileReader.cpp

@@ -68,14 +68,59 @@ void MenuFileReader::SetupStreamProxies()
     m_stream = m_open_streams.back().get();
 }
 
-bool MenuFileReader::ReadMenuFile()
+bool MenuFileReader::IsValidEndState(const MenuFileParserState* state) const
+{
+    if(state->m_current_item)
+    {
+        std::cout << "In \"" << m_file_name << "\": Unclosed item at end of file!\n";
+        return false;
+    }
+
+    if(state->m_current_menu)
+    {
+        std::cout << "In \"" << m_file_name << "\": Unclosed menu at end of file!\n";
+        return false;
+    }
+
+    if(state->m_current_function)
+    {
+        std::cout << "In \"" << m_file_name << "\": Unclosed function at end of file!\n";
+        return false;
+    }
+
+    if(state->m_in_global_scope)
+    {
+        std::cout << "In \"" << m_file_name << "\": Did not close global scope!\n";
+        return false;
+    }
+
+    return true;
+}
+
+std::unique_ptr<MenuParsingResult> MenuFileReader::CreateParsingResult(MenuFileParserState* state) const
+{
+    auto result = std::make_unique<MenuParsingResult>();
+    result->m_menus = std::move(state->m_menus);
+    result->m_functions = std::move(state->m_functions);
+    result->m_menus_to_load = std::move(state->m_menus_to_load);
+
+    return result;
+}
+
+std::unique_ptr<MenuParsingResult> MenuFileReader::ReadMenuFile()
 {
     const auto lexer = std::make_unique<SimpleLexer>(m_stream, SimpleLexer::Config{false, true, false});
     const auto parser = std::make_unique<MenuFileParser>(lexer.get(), m_feature_level);
 
-    if (parser->Parse())
+    if (!parser->Parse())
-        return true;
+    {
-
         std::cout << "Parsing menu file failed!" << std::endl;
-    return false;
+        return nullptr;
+    }
+
+    auto* parserEndState = parser->GetState();
+    if (!IsValidEndState(parserEndState))
+        return nullptr;
+
+    return CreateParsingResult(parserEndState);
 }

src/ObjLoading/Parsing/Menu/MenuFileReader.h

@@ -4,7 +4,9 @@
 #include <string>
 #include <vector>
 
+#include "MenuFileParserState.h"
 #include "Domain/MenuFeatureLevel.h"
+#include "Domain/MenuParsingResult.h"
 #include "Parsing/IParserLineStream.h"
 
 class MenuFileReader
@@ -23,9 +25,12 @@ private:
     void SetupDefinesProxy();
     void SetupStreamProxies();
 
+    bool IsValidEndState(const MenuFileParserState* state) const;
+    std::unique_ptr<MenuParsingResult> CreateParsingResult(MenuFileParserState* state) const;
+
 public:
     MenuFileReader(std::istream& stream, std::string fileName, MenuFeatureLevel featureLevel);
     MenuFileReader(std::istream& stream, std::string fileName, MenuFeatureLevel featureLevel, include_callback_t includeCallback);
 
-    bool ReadMenuFile();
+    std::unique_ptr<MenuParsingResult> ReadMenuFile();
 };