Add asset loader for localize files

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

@@ -0,0 +1,18 @@
+#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/Parsing/LocalizeFile/Sequence/SequenceLocalizeFileConfig.h

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

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

@@ -0,0 +1,16 @@
+#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/Parsing/LocalizeFile/Sequence/SequenceLocalizeFileConsumeEmptyLines.h

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

src/ObjLoading/Parsing/LocalizeFile/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/Parsing/LocalizeFile/Sequence/SequenceLocalizeFileEndMarker.h

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

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

@@ -0,0 +1,72 @@
+#include "SequenceLocalizeFileLanguageValue.h"
+
+#include <sstream>
+
+#include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
+
+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)
+    });
+}
+
+std::string SequenceLocalizeFileLanguageValue::UnescapeValue(const std::string& value)
+{
+    std::ostringstream str;
+
+    auto isEscaped = false;
+    for(auto c : value)
+    {
+        if(isEscaped)
+        {
+            switch(c)
+            {
+            case 'n':
+                str << '\n';
+                break;
+
+            case 'r':
+                str << '\r';
+                break;
+
+            default:
+                str << c;
+                break;
+            }
+        }
+        else if(c == '\\')
+        {
+            isEscaped = true;
+        }
+        else
+        {
+            str << c;
+        }
+    }
+
+    return str.str();
+}
+
+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)
+        state->m_entries.emplace_back(state->m_current_reference, UnescapeValue(valueToken.StringValue()));
+}

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

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

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

@@ -0,0 +1,18 @@
+#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/Parsing/LocalizeFile/Sequence/SequenceLocalizeFileNotes.h

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

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

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

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Parsing/LocalizeFile/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/Parsing/LocalizeFile/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/Parsing/LocalizeFile/Sequence/SequenceLocalizeFileVersion.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Parsing/LocalizeFile/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();
+};