evaluator: Fixed placing imported types into sections

Author: WerWolv

lib/include/pl/core/evaluator.hpp

@@ -427,6 +427,10 @@ namespace pl::core {
             return *m_patternLanguage;
         }
 
+        const PatternLanguage& getRuntime() const {
+            return *m_patternLanguage;
+        }
+
         void setPatternColorPalette(std::span<const u32> palette) {
             m_patternColorPalette.clear();
             m_patternColorPalette.reserve(palette.size());
@@ -492,8 +496,6 @@ namespace pl::core {
 
         std::atomic<bool> m_aborted;
 
-        std::vector<u64> m_sectionIdStack;
-
         std::vector<std::vector<u8>> m_heap;
         std::map<u32, PatternLocalData> m_patternLocalStorage;
 

lib/include/pl/pattern_language.hpp

@@ -424,6 +424,7 @@ namespace pl {
         struct SectionData {
             std::map<u64, api::Section> sections;
             u64 nextSectionId = 0;
+            std::vector<u64> sectionIdStack;
         };
 
     private:

lib/source/pl/core/ast/ast_node_array_variable_decl.cpp

@@ -101,7 +101,7 @@ namespace pl::core::ast {
                 evaluator->setBitwiseReadOffset(startOffset);
             }
 
-            if (this->m_placementSection != nullptr && !evaluator->isGlobalScope()) {
+            if (evaluator->getSectionId() != ptrn::Pattern::MainSectionId && !evaluator->isGlobalScope()) {
                 evaluator->addPattern(std::move(pattern));
                 resultPatterns.pop_back();
             }

lib/source/pl/core/ast/ast_node_pointer_variable_decl.cpp

@@ -100,8 +100,7 @@ namespace pl::core::ast {
                 err::E0005.throwError("'auto' can only be used with parameters.", { }, this->getLocation());
         }
 
-        if (this->m_placementSection != nullptr)
-            pattern->setSection(evaluator->getSectionId());
+        pattern->setSection(evaluator->getSectionId());
 
         if (this->m_placementOffset != nullptr && !evaluator->isGlobalScope()) {
             evaluator->setBitwiseReadOffset(startOffset);
@@ -114,7 +113,7 @@ namespace pl::core::ast {
             this->execute(evaluator);
             resultPatterns.clear();
         } else {
-            if (this->m_placementSection != nullptr && !evaluator->isGlobalScope()) {
+            if (evaluator->getSectionId() != ptrn::Pattern::MainSectionId && !evaluator->isGlobalScope()) {
                 evaluator->addPattern(std::move(pattern));
                 resultPatterns.clear();
             }

lib/source/pl/core/ast/ast_node_type_operator.cpp

@@ -26,10 +26,13 @@ namespace pl::core::ast {
         if (this->m_providerOperation) {
             switch (this->getOperator()) {
                 case Token::Operator::AddressOf:
-                    result = u128(evaluator->getDataBaseAddress());
+                    if (evaluator->getSectionId() != ptrn::Pattern::MainSectionId)
+                        result = u128(0x00);
+                    else
+                        result = u128(evaluator->getDataBaseAddress());
                     break;
                 case Token::Operator::SizeOf:
-                    result = u128(evaluator->getDataSize());
+                    result = u128(evaluator->getRuntime().getSectionSize(evaluator->getSectionId()));
                     break;
                 default:
                     err::E0001.throwError("Invalid type operation.", {}, this->getLocation());

lib/source/pl/core/ast/ast_node_variable_decl.cpp

@@ -74,16 +74,15 @@ namespace pl::core::ast {
 
                     pattern->setVariableName(this->m_name);
 
-                    if (this->m_placementSection != nullptr)
-                        pattern->setSection(evaluator->getSectionId());
+                    pattern->setSection(evaluator->getSectionId());
 
                     applyVariableAttributes(evaluator, this, pattern);
 
                     if (this->m_placementOffset != nullptr && !evaluator->isGlobalScope()) {
                         evaluator->setBitwiseReadOffset(startOffset);
                     }
 
-                    if (this->m_placementSection != nullptr && !evaluator->isGlobalScope()) {
+                    if (evaluator->getSectionId() != ptrn::Pattern::MainSectionId && !evaluator->isGlobalScope()) {
                         evaluator->addPattern(std::move(pattern));
                     } else {
                         resultPatterns = hlp::moveToVector<std::shared_ptr<ptrn::Pattern>>(std::move(pattern));

lib/source/pl/core/evaluator.cpp

@@ -929,25 +929,27 @@ namespace pl::core {
     }
 
     void Evaluator::pushSectionId(u64 id) {
-        this->m_sectionIdStack.push_back(id);
+        this->getRuntime().m_sectionData->sectionIdStack.push_back(id);
     }
 
     void Evaluator::popSectionId() {
-        this->m_sectionIdStack.pop_back();
+        this->getRuntime().m_sectionData->sectionIdStack.pop_back();
     }
 
     [[nodiscard]] u64 Evaluator::getSectionId() const {
-        if (this->m_sectionIdStack.empty())
+        const auto &sectionIdStack = this->getRuntime().m_sectionData->sectionIdStack;
+        if (sectionIdStack.empty())
             return 0;
 
-        return this->m_sectionIdStack.back();
+        return sectionIdStack.back();
     }
 
     u64 Evaluator::getUserSectionId() const {
-        if (this->m_sectionIdStack.empty())
+        const auto &sectionIdStack = this->getRuntime().m_sectionData->sectionIdStack;
+        if (sectionIdStack.empty())
             return 0;
 
-        for (auto it = this->m_sectionIdStack.rbegin(); it != this->m_sectionIdStack.rend(); ++it) {
+        for (auto it = sectionIdStack.rbegin(); it != sectionIdStack.rend(); ++it) {
             if (*it != ptrn::Pattern::MainSectionId && *it != ptrn::Pattern::HeapSectionId && *it != ptrn::Pattern::PatternLocalSectionId && *it != ptrn::Pattern::InstantiationSectionId)
                 return *it;
         }
@@ -959,7 +961,6 @@ namespace pl::core {
         this->m_readOrderReversed = false;
         this->m_currBitOffset = 0;
 
-        this->m_sectionIdStack.clear();
         this->m_outVariables.clear();
         this->m_outVariableValues.clear();
 
@@ -978,6 +979,8 @@ namespace pl::core {
         this->m_evaluated = false;
         this->m_attributedPatterns.clear();
 
+        this->m_subRuntimes.clear();
+
         this->setPatternColorPalette(DefaultPatternColorPalette);
 
         if (this->m_allowDangerousFunctions == DangerousFunctionPermission::Deny)

lib/source/pl/pattern_language.cpp

@@ -555,6 +555,7 @@ namespace pl {
         if (!this->m_subRuntime) {
             this->m_sectionData->nextSectionId = 1;
             this->m_sectionData->sections.clear();
+            this->m_sectionData->sectionIdStack.clear();
         }
 
         this->m_resolvers.setDefaultResolver([this](const std::string& path) {