Move localize parsing into localize root folder

src/ObjLoading/Localize/Parsing/LocalizeFileParser.cpp

@@ -0,0 +1,38 @@
+#include "LocalizeFileParser.h"
+
+#include "Sequence/SequenceLocalizeFileConfig.h"
+#include "Sequence/SequenceLocalizeFileConsumeEmptyLines.h"
+#include "Sequence/SequenceLocalizeFileEndMarker.h"
+#include "Sequence/SequenceLocalizeFileLanguageValue.h"
+#include "Sequence/SequenceLocalizeFileNotes.h"
+#include "Sequence/SequenceLocalizeFileReference.h"
+#include "Sequence/SequenceLocalizeFileVersion.h"
+
+LocalizeFileParser::LocalizeFileParser(SimpleLexer* lexer, GameLanguage language)
+    : AbstractParser(lexer, std::make_unique<LocalizeFileParserState>(language))
+{
+}
+
+const std::vector<AbstractParser<SimpleParserValue, LocalizeFileParserState>::sequence_t*>& LocalizeFileParser::GetTestsForState()
+{
+    static std::vector<sequence_t*> tests({
+        new SequenceLocalizeFileReference(),
+        new SequenceLocalizeFileConfig(),
+        new SequenceLocalizeFileNotes(),
+        new SequenceLocalizeFileVersion(),
+        new SequenceLocalizeFileEndMarker(),
+        new SequenceLocalizeFileLanguageValue(),
+        new SequenceLocalizeFileConsumeEmptyLines(),
+    });
+
+    static std::vector<sequence_t*> noTests({
+        new SequenceLocalizeFileConsumeEmptyLines(),
+    });
+
+    return !m_state->m_end ? tests : noTests;
+}
+
+std::map<std::string, std::string> LocalizeFileParser::GetParsedValues()
+{
+    return std::move(m_state->m_entries);
+}

src/ObjLoading/Localize/Parsing/LocalizeFileParser.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "Game/GameLanguage.h"
+#include "LocalizeFileParserState.h"
+#include "Parsing/Impl/AbstractParser.h"
+#include "Parsing/Simple/SimpleLexer.h"
+#include "Parsing/Simple/SimpleParserValue.h"
+
+class LocalizeFileParser final : public AbstractParser<SimpleParserValue, LocalizeFileParserState>
+{
+protected:
+    const std::vector<sequence_t*>& GetTestsForState() override;
+
+public:
+    LocalizeFileParser(SimpleLexer* lexer, GameLanguage language);
+    std::map<std::string, std::string> GetParsedValues();
+};

src/ObjLoading/Localize/Parsing/LocalizeFileParserState.cpp

@@ -0,0 +1,12 @@
+#include "LocalizeFileParserState.h"
+
+#include "Localize/LocalizeCommon.h"
+
+LocalizeFileParserState::LocalizeFileParserState(const GameLanguage language)
+    : m_end(false),
+      m_language(language)
+{
+    m_language_name_caps = LocalizeCommon::GetNameOfLanguage(m_language);
+    for (auto& c : m_language_name_caps)
+        c = static_cast<char>(toupper(c));
+}

src/ObjLoading/Localize/Parsing/LocalizeFileParserState.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "Game/GameLanguage.h"
+
+#include <map>
+#include <unordered_set>
+
+class LocalizeFileParserState
+{
+public:
+    bool m_end;
+
+    std::map<std::string, std::string> m_entries;
+
+    GameLanguage m_language;
+    std::string m_language_name_caps;
+
+    std::string m_current_reference;
+    std::unordered_set<std::string> m_current_reference_languages;
+
+    explicit LocalizeFileParserState(GameLanguage language);
+};

src/ObjLoading/Localize/Parsing/LocalizeFileReader.cpp

@@ -0,0 +1,47 @@
+#include "LocalizeFileReader.h"
+
+#include "LocalizeFileParser.h"
+#include "Parsing/Impl/CommentRemovingStreamProxy.h"
+#include "Parsing/Impl/ParserSingleInputStream.h"
+
+LocalizeFileReader::LocalizeFileReader(std::istream& stream, std::string fileName, GameLanguage language)
+    : m_file_name(std::move(fileName)),
+      m_stream(nullptr),
+      m_language(language)
+{
+    OpenBaseStream(stream);
+    SetupStreamProxies();
+    m_stream = m_open_streams.back().get();
+}
+
+bool LocalizeFileReader::OpenBaseStream(std::istream& stream)
+{
+    m_open_streams.emplace_back(std::make_unique<ParserSingleInputStream>(stream, m_file_name));
+    return true;
+}
+
+void LocalizeFileReader::SetupStreamProxies()
+{
+    m_open_streams.emplace_back(std::make_unique<CommentRemovingStreamProxy>(m_open_streams.back().get()));
+
+    m_stream = m_open_streams.back().get();
+}
+
+std::map<std::string, std::string> LocalizeFileReader::ReadLocalizeFile()
+{
+    SimpleLexer::Config lexerConfig;
+    lexerConfig.m_emit_new_line_tokens = true;
+    lexerConfig.m_read_strings = true;
+    lexerConfig.m_string_escape_sequences = true;
+    lexerConfig.m_read_integer_numbers = false;
+    lexerConfig.m_read_floating_point_numbers = false;
+    const auto lexer = std::make_unique<SimpleLexer>(m_stream, std::move(lexerConfig));
+
+    const auto parser = std::make_unique<LocalizeFileParser>(lexer.get(), m_language);
+
+    if (parser->Parse())
+        return parser->GetParsedValues();
+
+    std::cout << "Parsing localization file failed!" << std::endl;
+    return std::map<std::string, std::string>();
+}

src/ObjLoading/Localize/Parsing/LocalizeFileReader.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Game/GameLanguage.h"
+#include "Parsing/IParserLineStream.h"
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+class LocalizeFileReader
+{
+    std::string m_file_name;
+    IParserLineStream* m_stream;
+    std::vector<std::unique_ptr<IParserLineStream>> m_open_streams;
+    GameLanguage m_language;
+
+    bool OpenBaseStream(std::istream& stream);
+    void SetupStreamProxies();
+
+public:
+    LocalizeFileReader(std::istream& stream, std::string fileName, GameLanguage language);
+
+    std::map<std::string, std::string> ReadLocalizeFile();
+};

src/ObjLoading/Localize/Parsing/Sequence/SequenceLocalizeFileConfig.cpp

@@ -0,0 +1,16 @@
+#include "SequenceLocalizeFileConfig.h"
+
+#include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
+
+SequenceLocalizeFileConfig::SequenceLocalizeFileConfig()
+{
+    const SimpleMatcherFactory create(this);
+
+    AddMatchers({
+        create.Keyword("CONFIG"),
+        create.String(),
+        create.Type(SimpleParserValueType::NEW_LINE),
+    });
+}
+
+void SequenceLocalizeFileConfig::ProcessMatch(LocalizeFileParserState* state, SequenceResult<SimpleParserValue>& result) const {}

src/ObjLoading/Localize/Parsing/Sequence/SequenceLocalizeFileConfig.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "Localize/Parsing/LocalizeFileParser.h"
+
+class SequenceLocalizeFileConfig final : public LocalizeFileParser::sequence_t
+{
+protected:
+    void ProcessMatch(LocalizeFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
+
+public:
+    SequenceLocalizeFileConfig();
+};

src/ObjLoading/Localize/Parsing/Sequence/SequenceLocalizeFileConsumeEmptyLines.cpp

@@ -0,0 +1,14 @@
+#include "SequenceLocalizeFileConsumeEmptyLines.h"
+
+#include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
+
+SequenceLocalizeFileConsumeEmptyLines::SequenceLocalizeFileConsumeEmptyLines()
+{
+    const SimpleMatcherFactory create(this);
+
+    AddMatchers({
+        create.Type(SimpleParserValueType::NEW_LINE),
+    });
+}
+
+void SequenceLocalizeFileConsumeEmptyLines::ProcessMatch(LocalizeFileParserState* state, SequenceResult<SimpleParserValue>& result) const {}

src/ObjLoading/Localize/Parsing/Sequence/SequenceLocalizeFileConsumeEmptyLines.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "Localize/Parsing/LocalizeFileParser.h"
+
+class SequenceLocalizeFileConsumeEmptyLines final : public LocalizeFileParser::sequence_t
+{
+protected:
+    void ProcessMatch(LocalizeFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
+
+public:
+    SequenceLocalizeFileConsumeEmptyLines();
+};

src/ObjLoading/Localize/Parsing/Sequence/SequenceLocalizeFileEndMarker.cpp

@@ -0,0 +1,17 @@
+#include "SequenceLocalizeFileEndMarker.h"
+
+#include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
+
+SequenceLocalizeFileEndMarker::SequenceLocalizeFileEndMarker()
+{
+    const SimpleMatcherFactory create(this);
+
+    AddMatchers({
+        create.Keyword("ENDMARKER"),
+    });
+}
+
+void SequenceLocalizeFileEndMarker::ProcessMatch(LocalizeFileParserState* state, SequenceResult<SimpleParserValue>& result) const
+{
+    state->m_end = true;
+}

src/ObjLoading/Localize/Parsing/Sequence/SequenceLocalizeFileEndMarker.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "Localize/Parsing/LocalizeFileParser.h"
+
+class SequenceLocalizeFileEndMarker final : public LocalizeFileParser::sequence_t
+{
+protected:
+    void ProcessMatch(LocalizeFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
+
+public:
+    SequenceLocalizeFileEndMarker();
+};

src/ObjLoading/Localize/Parsing/Sequence/SequenceLocalizeFileLanguageValue.cpp

@@ -0,0 +1,43 @@
+#include "SequenceLocalizeFileLanguageValue.h"
+
+#include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
+
+#include <sstream>
+
+SequenceLocalizeFileLanguageValue::SequenceLocalizeFileLanguageValue()
+{
+    const SimpleMatcherFactory create(this);
+
+    AddMatchers({
+        create.KeywordPrefix("LANG_").Capture(CAPTURE_LANGUAGE_NAME),
+        create.String().Capture(CAPTURE_ENTRY_VALUE),
+        create.Type(SimpleParserValueType::NEW_LINE),
+    });
+}
+
+void SequenceLocalizeFileLanguageValue::ProcessMatch(LocalizeFileParserState* state, SequenceResult<SimpleParserValue>& result) const
+{
+    const auto& langToken = result.NextCapture(CAPTURE_LANGUAGE_NAME);
+    const auto& valueToken = result.NextCapture(CAPTURE_ENTRY_VALUE);
+
+    const auto langName = langToken.IdentifierValue().substr(std::char_traits<char>::length("LANG_"));
+    const auto alreadyDefinedLanguage = state->m_current_reference_languages.find(langName);
+    if (alreadyDefinedLanguage != state->m_current_reference_languages.end())
+    {
+        std::ostringstream str;
+        str << "Value for reference \"" << state->m_current_reference << "\" already defined for language \"" << langToken.IdentifierValue() << "\"";
+        throw ParsingException(langToken.GetPos(), str.str());
+    }
+    state->m_current_reference_languages.emplace(langName);
+
+    if (langName == state->m_language_name_caps)
+    {
+        const auto& currentReference = state->m_current_reference;
+        if (const auto i = state->m_entries.find(currentReference); i != state->m_entries.end())
+        {
+            std::cout << "Localize: a value for reference \"" << currentReference << "\" was already defined\n";
+        }
+
+        state->m_entries[currentReference] = valueToken.StringValue();
+    }
+}

src/ObjLoading/Localize/Parsing/Sequence/SequenceLocalizeFileLanguageValue.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "Localize/Parsing/LocalizeFileParser.h"
+
+class SequenceLocalizeFileLanguageValue final : public LocalizeFileParser::sequence_t
+{
+    static constexpr auto CAPTURE_LANGUAGE_NAME = 1;
+    static constexpr auto CAPTURE_ENTRY_VALUE = 2;
+
+protected:
+    void ProcessMatch(LocalizeFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
+
+public:
+    SequenceLocalizeFileLanguageValue();
+};

src/ObjLoading/Localize/Parsing/Sequence/SequenceLocalizeFileNotes.cpp

@@ -0,0 +1,16 @@
+#include "SequenceLocalizeFileNotes.h"
+
+#include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
+
+SequenceLocalizeFileNotes::SequenceLocalizeFileNotes()
+{
+    const SimpleMatcherFactory create(this);
+
+    AddMatchers({
+        create.Keyword("FILENOTES"),
+        create.String(),
+        create.Type(SimpleParserValueType::NEW_LINE),
+    });
+}
+
+void SequenceLocalizeFileNotes::ProcessMatch(LocalizeFileParserState* state, SequenceResult<SimpleParserValue>& result) const {}

src/ObjLoading/Localize/Parsing/Sequence/SequenceLocalizeFileNotes.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "Localize/Parsing/LocalizeFileParser.h"
+
+class SequenceLocalizeFileNotes final : public LocalizeFileParser::sequence_t
+{
+protected:
+    void ProcessMatch(LocalizeFileParserState* state, SequenceResult<SimpleParserValue>& result) const override;
+
+public:
+    SequenceLocalizeFileNotes();
+};

src/ObjLoading/Localize/Parsing/Sequence/SequenceLocalizeFileReference.cpp

@@ -0,0 +1,26 @@
+#include "SequenceLocalizeFileReference.h"
+
+#include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
+
+SequenceLocalizeFileReference::SequenceLocalizeFileReference()
+{
+    const SimpleMatcherFactory create(this);
+
+    AddMatchers({
+        create.Keyword("REFERENCE"),
+        create
+            .Or({
+                create.Identifier(),
+                create.String(),
+            })
+            .Capture(CAPTURE_REFERENCE_NAME),
+        create.Type(SimpleParserValueType::NEW_LINE),
+    });
+}
+
+void SequenceLocalizeFileReference::ProcessMatch(LocalizeFileParserState* state, SequenceResult<SimpleParserValue>& result) const
+{
+    const auto& nameToken = result.NextCapture(CAPTURE_REFERENCE_NAME);
+    state->m_current_reference = nameToken.m_type == SimpleParserValueType::IDENTIFIER ? nameToken.IdentifierValue() : nameToken.StringValue();
+    state->m_current_reference_languages.clear();
+}

src/ObjLoading/Localize/Parsing/Sequence/SequenceLocalizeFileReference.h

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

src/ObjLoading/Localize/Parsing/Sequence/SequenceLocalizeFileVersion.cpp

@@ -0,0 +1,23 @@
+#include "SequenceLocalizeFileVersion.h"
+
+#include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
+
+SequenceLocalizeFileVersion::SequenceLocalizeFileVersion()
+{
+    const SimpleMatcherFactory create(this);
+
+    AddMatchers({
+        create.Keyword("VERSION"),
+        create.String().Capture(CAPTURE_VERSION),
+        create.Type(SimpleParserValueType::NEW_LINE),
+    });
+}
+
+void SequenceLocalizeFileVersion::ProcessMatch(LocalizeFileParserState* state, SequenceResult<SimpleParserValue>& result) const
+{
+    const auto& versionCapture = result.NextCapture(CAPTURE_VERSION);
+    if (versionCapture.StringValue() != "1")
+    {
+        throw ParsingException(versionCapture.GetPos(), "Localize file needs to be version 1");
+    }
+}

src/ObjLoading/Localize/Parsing/Sequence/SequenceLocalizeFileVersion.h

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