Merge branch 'WerWolv:master' into new_lexer

Author: shewitt-au

lib/include/pl/core/evaluator.hpp

@@ -159,6 +159,7 @@ namespace pl::core {
         void pushSectionId(u64 id);
         void popSectionId();
         [[nodiscard]] u64 getSectionId() const;
+        [[nodiscard]] u64 getUserSectionId() const;
         [[nodiscard]] u64 createSection(const std::string &name);
         void removeSection(u64 id);
         [[nodiscard]] std::vector<u8>& getSection(u64 id);

lib/include/pl/pattern_language.hpp

@@ -116,10 +116,19 @@ namespace pl {
          * @brief Adds a virtual source file under the path
          * @param code the code of the source
          * @param source the source of the code
+         * @param mainSource whether this is the main source (the one that gets executed first)
          * @return the source that was added or that already existed
          */
         [[nodiscard]] api::Source* addVirtualSource(const std::string& code, const std::string& source, bool mainSource = false) const;
 
+        /**
+         * @brief Runs a minimal lexer and preprocess step on the code and returns key-value pairs of all pragmas that were set
+         * @param code the code of the source
+         * @param source the source of the code
+         * @return Key-value pairs of all pragmas that were set
+         */
+        [[nodiscard]] std::map<std::string, std::string> getPragmaValues(const std::string &code, const std::string &source = api::Source::DefaultSource) const;
+
         /**
          * @brief Aborts the currently running execution asynchronously
         */

lib/source/pl/core/evaluator.cpp

@@ -947,6 +947,19 @@ namespace pl::core {
         return this->m_sectionIdStack.back();
     }
 
+    u64 Evaluator::getUserSectionId() const {
+        if (this->m_sectionIdStack.empty())
+            return 0;
+
+        for (auto it = this->m_sectionIdStack.rbegin(); it != this->m_sectionIdStack.rend(); ++it) {
+            if (*it != ptrn::Pattern::MainSectionId && *it != ptrn::Pattern::HeapSectionId && *it != ptrn::Pattern::PatternLocalSectionId && *it != ptrn::Pattern::InstantiationSectionId)
+                return *it;
+        }
+
+        return 0;
+    }
+
+
     u64 Evaluator::createSection(const std::string &name) {
         auto id = this->m_sectionId;
         this->m_sectionId++;

lib/source/pl/lib/std/mem.cpp

@@ -12,7 +12,7 @@
 
 namespace pl::lib::libstd::mem {
 
-    static std::optional<i128> findSequence(::pl::core::Evaluator *ctx, u64 occurrenceIndex, u64 offsetFrom, u64 offsetTo, const std::vector<u8> &sequence) {
+    static std::optional<i128> findSequence(::pl::core::Evaluator *ctx, u64 occurrenceIndex, u64 offsetFrom, u64 offsetTo, u64 section, const std::vector<u8> &sequence) {
         u32 occurrences = 0;
         const u64 bufferSize = ctx->getDataSize();
 
@@ -25,7 +25,7 @@ namespace pl::lib::libstd::mem {
         std::vector<u8> bytes(std::max(sequence.size(), size_t(4 * 1024)) + sequence.size(), 0x00);
         for (u64 offset = offsetFrom; offset < offsetTo; offset += bytes.size() - sequence.size()) {
             const auto bytesToRead = std::min<std::size_t>(bytes.size(), offsetTo - offset);
-            ctx->readData(offset, bytes.data(), bytesToRead, ptrn::Pattern::MainSectionId);
+            ctx->readData(offset, bytes.data(), bytesToRead, section);
             ctx->handleAbort();
 
             for (u64 i = 0; i < bytes.size() - sequence.size(); i += 1) {
@@ -59,24 +59,31 @@ namespace pl::lib::libstd::mem {
         {
 
             /* base_address() */
-            runtime.addFunction(nsStdMem, "base_address", FunctionParameterCount::none(), [](Evaluator *ctx, auto params) -> std::optional<Token::Literal> {
-                wolv::util::unused(params);
+            runtime.addFunction(nsStdMem, "base_address", FunctionParameterCount::between(0, 1), [](Evaluator *ctx, auto params) -> std::optional<Token::Literal> {
+                auto section = params.size() == 1 ? params[0].toUnsigned() : ptrn::Pattern::MainSectionId;
+                if (section == 0xFFFF'FFFF'FFFF'FFFF)
+                    section = ctx->getUserSectionId();
+
+                if (section != ptrn::Pattern::MainSectionId)
+                    return 0;
 
                 return u128(ctx->getDataBaseAddress());
             });
 
             /* size() */
-            runtime.addFunction(nsStdMem, "size", FunctionParameterCount::none(), [](Evaluator *ctx, auto params) -> std::optional<Token::Literal> {
-                wolv::util::unused(params);
+            runtime.addFunction(nsStdMem, "size", FunctionParameterCount::between(0, 1), [](Evaluator *ctx, auto params) -> std::optional<Token::Literal> {
+                auto section = params.size() == 1 ? params[0].toUnsigned() : ptrn::Pattern::MainSectionId;
+                if (section == 0xFFFF'FFFF'FFFF'FFFF)
+                    section = ctx->getUserSectionId();
 
-                return u128(ctx->getDataSize());
+                return u128(ctx->getSectionSize(section));
             });
 
             /* find_sequence_in_range(occurrence_index, start_offset, end_offset, bytes...) */
             runtime.addFunction(nsStdMem, "find_sequence_in_range", FunctionParameterCount::moreThan(3), [](Evaluator *ctx, auto params) -> std::optional<Token::Literal> {
-                auto occurrenceIndex = u64(params[0].toUnsigned());
-                auto offsetFrom      = u64(params[1].toUnsigned());
-                auto offsetTo        = u64(params[2].toUnsigned());
+                const u64 occurrenceIndex = params[0].toUnsigned();
+                const u64 offsetFrom      = params[1].toUnsigned();
+                const u64 offsetTo        = params[2].toUnsigned();
 
                 std::vector<u8> sequence;
                 for (u32 i = 3; i < params.size(); i++) {
@@ -88,59 +95,68 @@ namespace pl::lib::libstd::mem {
                     sequence.push_back(u8(byte));
                 }
 
-                return findSequence(ctx, occurrenceIndex, offsetFrom, offsetTo, sequence).value_or(-1);
+                return findSequence(ctx, occurrenceIndex, offsetFrom, offsetTo, ctx->getUserSectionId(), sequence).value_or(-1);
             });
 
             /* find_string_in_range(occurrence_index, start_offset, end_offset, string) */
             runtime.addFunction(nsStdMem, "find_string_in_range", FunctionParameterCount::exactly(4), [](Evaluator *ctx, auto params) -> std::optional<Token::Literal> {
-                auto occurrenceIndex = u64(params[0].toUnsigned());
-                auto offsetFrom      = u64(params[1].toUnsigned());
-                auto offsetTo        = u64(params[2].toUnsigned());
-                auto string          = params[3].toString(false);
+                const u64 occurrenceIndex = params[0].toUnsigned();
+                const u64 offsetFrom      = params[1].toUnsigned();
+                const u64 offsetTo        = params[2].toUnsigned();
+                const auto string         = params[3].toString(false);
 
-                return findSequence(ctx, occurrenceIndex, offsetFrom, offsetTo, std::vector<u8>(string.data(), string.data() + string.size())).value_or(-1);
+                return findSequence(ctx, occurrenceIndex, offsetFrom, offsetTo, ctx->getUserSectionId(), std::vector<u8>(string.data(), string.data() + string.size())).value_or(-1);
             });
 
-            /* read_unsigned(address, size, endian) */
-            runtime.addFunction(nsStdMem, "read_unsigned", FunctionParameterCount::exactly(3), [](Evaluator *ctx, auto params) -> std::optional<Token::Literal> {
-                auto address            = u64(params[0].toUnsigned());
-                auto size               = size_t(params[1].toSigned());
-                types::Endian endian    = params[2].toUnsigned();
+            /* read_unsigned(address, size, endian, section) */
+            runtime.addFunction(nsStdMem, "read_unsigned", FunctionParameterCount::between(3, 4), [](Evaluator *ctx, auto params) -> std::optional<Token::Literal> {
+                const u64 address            = params[0].toUnsigned();
+                const size_t size            = params[1].toSigned();
+                const types::Endian endian   = params[2].toUnsigned();
+                u64 section                  = params.size() == 4 ? params[3].toUnsigned() : ptrn::Pattern::MainSectionId;
+                if (section == 0xFFFF'FFFF'FFFF'FFFF)
+                    section = ctx->getUserSectionId();
 
                 if (size < 1 || size > 16)
                     err::E0012.throwError(fmt::format("Read size {} is out of range.", size), "Try a value between 1 and 16.");
 
                 u128 result = 0;
-                ctx->readData(address, &result, size, ptrn::Pattern::MainSectionId);
+                ctx->readData(address, &result, size, section);
                 result = hlp::changeEndianess(result, size, endian);
 
                 return result;
             });
 
-            /* read_signed(address, size, endian) */
-            runtime.addFunction(nsStdMem, "read_signed", FunctionParameterCount::exactly(3), [](Evaluator *ctx, auto params) -> std::optional<Token::Literal> {
-                auto address            = u64(params[0].toUnsigned());
-                auto size               = size_t(params[1].toSigned());
-                types::Endian endian    = params[2].toUnsigned();
+            /* read_signed(address, size, endian, section) */
+            runtime.addFunction(nsStdMem, "read_signed", FunctionParameterCount::between(3, 4), [](Evaluator *ctx, auto params) -> std::optional<Token::Literal> {
+                const u64 address            = params[0].toUnsigned();
+                const size_t size            = params[1].toSigned();
+                const types::Endian endian   = params[2].toUnsigned();
+                u64 section                  = params.size() == 4 ? params[3].toUnsigned() : ptrn::Pattern::MainSectionId;
+                if (section == 0xFFFF'FFFF'FFFF'FFFF)
+                    section = ctx->getUserSectionId();
 
                 if (size < 1 || size > 16)
                     err::E0012.throwError(fmt::format("Read size {} is out of range.", size), "Try a value between 1 and 16.");
 
 
                 i128 value = 0;
-                ctx->readData(address, &value, size, ptrn::Pattern::MainSectionId);
+                ctx->readData(address, &value, size, section);
                 value = hlp::changeEndianess(value, size, endian);
 
                 return hlp::signExtend(size * 8, value);
             });
 
-            /* read_string(address, size, endian) */
-            runtime.addFunction(nsStdMem, "read_string", FunctionParameterCount::exactly(2), [](Evaluator *ctx, auto params) -> std::optional<Token::Literal> {
-                auto address = u64(params[0].toUnsigned());
-                auto size    = size_t(params[1].toUnsigned());
+            /* read_string(address, size, endian, section) */
+            runtime.addFunction(nsStdMem, "read_string", FunctionParameterCount::between(2, 3), [](Evaluator *ctx, auto params) -> std::optional<Token::Literal> {
+                const u64 address            = params[0].toUnsigned();
+                const size_t size            = params[1].toSigned();
+                u64 section                  = params.size() == 3 ? params[2].toUnsigned() : ptrn::Pattern::MainSectionId;
+                if (section == 0xFFFF'FFFF'FFFF'FFFF)
+                    section = ctx->getUserSectionId();
 
                 std::string result(size, '\x00');
-                ctx->readData(address, result.data(), size, ptrn::Pattern::MainSectionId);
+                ctx->readData(address, result.data(), size, section);
 
                 return result;
             });

lib/source/pl/pattern_language.cpp

@@ -338,6 +338,39 @@ namespace pl {
         return this->m_fileResolver.addVirtualFile(code, source, mainSource);
     }
 
+    std::map<std::string, std::string> PatternLanguage::getPragmaValues(const std::string &code, const std::string &source) const {
+        std::map<std::string, std::string> pragmaValues;
+
+        const api::Source plSource(code, source);
+        const auto result = m_internals.lexer->lex(&plSource);
+        if (result.isOk()) {
+            const auto tokens = result.unwrap();
+            for (auto it = tokens.begin(); it != tokens.end(); ++it) {
+                if (it->type == core::Token::Type::Directive && std::get<core::Token::Directive>(it->value) == core::Token::Directive::Pragma) {
+                    ++it;
+                    if (it != tokens.end() && it->type == core::Token::Type::String) {
+                        auto literal = std::get<core::Token::Literal>(it->value);
+                        auto string = std::get_if<std::string>(&literal);
+                        if (string != nullptr) {
+                            auto pragmaKey = *string;
+                            ++it;
+                            if (it != tokens.end() && it->type == core::Token::Type::String) {
+                                literal = std::get<core::Token::Literal>(it->value);
+                                string = std::get_if<std::string>(&literal);
+                                if (string != nullptr) {
+                                    pragmaValues.emplace(pragmaKey, *string);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return pragmaValues;
+    }
+
+
     void PatternLanguage::abort() {
         this->m_internals.evaluator->abort();
         this->m_aborted = true;