evaluator: Fixed accessing of section variables in imported types

WerWolv · WerWolv · commit 25a7cb9ebba1 · 2025-08-31T12:17:39.000+02:00
diff --git a/lib/source/pl/core/ast/ast_node_array_variable_decl.cpp b/lib/source/pl/core/ast/ast_node_array_variable_decl.cpp
@@ -199,8 +199,8 @@ namespace pl::core::ast {
                     if ((evaluator->getReadOffset() - evaluator->getDataBaseAddress()) > (evaluator->getDataSize() + 1))
                         err::E0004.throwError("Array expanded past end of the data before a null-entry was found.", "Try using a while-sized array instead to limit the size of the array.", this->getLocation());
 
-                evaluator->readData(evaluator->getReadOffset(), buffer.data(), buffer.size(), templatePattern->getSection());
-                evaluator->getReadOffsetAndIncrement(buffer.size());
+                templatePattern->getEvaluator()->readData(evaluator->getReadOffset(), buffer.data(), buffer.size(), templatePattern->getSection());
+                templatePattern->getEvaluator()->getReadOffsetAndIncrement(buffer.size());
 
                 entryCount++;
 
@@ -213,7 +213,7 @@ namespace pl::core::ast {
                 }
 
                 if (reachedEnd) break;
-                evaluator->handleAbort();
+                templatePattern->getEvaluator()->handleAbort();
             }
         }
 
@@ -394,7 +394,7 @@ namespace pl::core::ast {
                             err::E0004.throwError("Array expanded past end of the data before a null-entry was found.", "Try using a while-sized array instead to limit the size of the array.", this->getLocation());
 
                     const auto patternSize = pattern->getSize();
-                    evaluator->readData(evaluator->getReadOffset() - patternSize, buffer.data(), buffer.size(), pattern->getSection());
+                    pattern->getEvaluator()->readData(evaluator->getReadOffset() - patternSize, buffer.data(), buffer.size(), pattern->getSection());
 
                     addEntries(hlp::moveToVector(std::move(pattern)));
 
diff --git a/lib/source/pl/core/ast/ast_node_cast.cpp b/lib/source/pl/core/ast/ast_node_cast.cpp
@@ -142,10 +142,10 @@ namespace pl::core::ast {
             auto type = dynamic_cast<ASTNodeBuiltinType *>(evaluatedType.get())->getType();
 
             value = std::visit(wolv::util::overloaded {
-                [&evaluator, &type](const std::shared_ptr<ptrn::Pattern> &value) -> Token::Literal {
+                [&type](const std::shared_ptr<ptrn::Pattern> &value) -> Token::Literal {
                     if (Token::isInteger(type) && value->getSize() <= Token::getTypeSize(type)) {
                         u128 result = 0;
-                        evaluator->readData(value->getOffset(), &result, value->getSize(), value->getSection());
+                        value->getEvaluator()->readData(value->getOffset(), &result, value->getSize(), value->getSection());
 
                         return result;
                     } else {
diff --git a/lib/source/pl/core/ast/ast_node_mathematical_expression.cpp b/lib/source/pl/core/ast/ast_node_mathematical_expression.cpp
@@ -117,8 +117,8 @@ namespace pl::core::ast {
             [&, this](const std::shared_ptr<ptrn::Pattern> &left, const std::shared_ptr<ptrn::Pattern> &right) -> ASTNode * {
                 std::vector<u8> leftBytes(left->getSize()), rightBytes(right->getSize());
 
-                evaluator->readData(left->getOffset(), leftBytes.data(), leftBytes.size(), left->getSection());
-                evaluator->readData(right->getOffset(), rightBytes.data(), rightBytes.size(), right->getSection());
+                left->getEvaluator()->readData(left->getOffset(), leftBytes.data(), leftBytes.size(), left->getSection());
+                right->getEvaluator()->readData(right->getOffset(), rightBytes.data(), rightBytes.size(), right->getSection());
                 switch (this->getOperator()) {
                    case Token::Operator::BoolEqual:
                        return new ASTNodeLiteral(leftBytes == rightBytes);
diff --git a/lib/source/pl/core/ast/ast_node_rvalue.cpp b/lib/source/pl/core/ast/ast_node_rvalue.cpp
@@ -35,14 +35,14 @@ namespace pl::core::ast {
         }
     }
 
-    static void readVariable(Evaluator *evaluator, auto &value, ptrn::Pattern *variablePattern) {
+    static void readVariable(auto &value, ptrn::Pattern *variablePattern) {
         constexpr bool isString = std::same_as<std::remove_cvref_t<decltype(value)>, std::string>;
 
         if constexpr (isString) {
             value.resize(variablePattern->getSize());
-            evaluator->readData(variablePattern->getOffset(), value.data(), value.size(), variablePattern->getSection());
+            variablePattern->getEvaluator()->readData(variablePattern->getOffset(), value.data(), value.size(), variablePattern->getSection());
         } else {
-            evaluator->readData(variablePattern->getOffset(), &value, variablePattern->getSize(), variablePattern->getSection());
+            variablePattern->getEvaluator()->readData(variablePattern->getOffset(), &value, variablePattern->getSize(), variablePattern->getSection());
         }
 
         if constexpr (!isString)
@@ -91,39 +91,39 @@ namespace pl::core::ast {
         Token::Literal literal;
         if (dynamic_cast<ptrn::PatternUnsigned *>(pattern.get()) != nullptr) {
             u128 value = 0;
-            readVariable(evaluator, value, pattern.get());
+            readVariable(value, pattern.get());
             literal = value;
         } else if (dynamic_cast<ptrn::PatternSigned *>(pattern.get()) != nullptr) {
             i128 value = 0;
-            readVariable(evaluator, value, pattern.get());
+            readVariable(value, pattern.get());
             value   = hlp::signExtend(pattern->getSize() * 8, value);
             literal = value;
         } else if (dynamic_cast<ptrn::PatternFloat *>(pattern.get()) != nullptr) {
             if (pattern->getSize() == sizeof(u16)) {
                 u16 value = 0;
-                readVariable(evaluator, value, pattern.get());
+                readVariable(value, pattern.get());
                 literal = double(hlp::float16ToFloat32(value));
             } else if (pattern->getSize() == sizeof(float)) {
                 float value = 0;
-                readVariable(evaluator, value, pattern.get());
+                readVariable(value, pattern.get());
                 literal = double(value);
             } else if (pattern->getSize() == sizeof(double)) {
                 double value = 0;
-                readVariable(evaluator, value, pattern.get());
+                readVariable(value, pattern.get());
                 literal = value;
             } else
                 err::E0001.throwError("Invalid floating point type.");
         } else if (dynamic_cast<ptrn::PatternCharacter *>(pattern.get()) != nullptr) {
             char value = 0;
-            readVariable(evaluator, value, pattern.get());
+            readVariable(value, pattern.get());
             literal = value;
         } else if (dynamic_cast<ptrn::PatternBoolean *>(pattern.get()) != nullptr) {
             bool value = false;
-            readVariable(evaluator, value, pattern.get());
+            readVariable(value, pattern.get());
             literal = value;
         } else if (dynamic_cast<ptrn::PatternString *>(pattern.get()) != nullptr) {
             std::string value;
-            readVariable(evaluator, value, pattern.get());
+            readVariable(value, pattern.get());
             literal = value;
         } else if (auto bitfieldFieldPatternBoolean = dynamic_cast<ptrn::PatternBitfieldFieldBoolean *>(pattern.get()); bitfieldFieldPatternBoolean != nullptr) {
             literal = bool(bitfieldFieldPatternBoolean->readValue());
diff --git a/lib/source/pl/lib/std/mem.cpp b/lib/source/pl/lib/std/mem.cpp
@@ -265,11 +265,11 @@ namespace pl::lib::libstd::mem {
                         if (auto iterable = dynamic_cast<ptrn::IIterable*>(pattern.get())) {
                             iterable->forEachEntry(0, iterable->getEntryCount(), [&](u64, ptrn::Pattern *entry) {
                                 auto entrySize = entry->getSize();
-                                ctx->readData(entry->getOffset(), section.data() + toAddr, entrySize, entry->getSection());
+                                pattern->getEvaluator()->readData(entry->getOffset(), section.data() + toAddr, entrySize, entry->getSection());
                                 toAddr += entrySize;
                             });
                         } else {
-                            ctx->readData(pattern->getOffset(), section.data() + toAddr, pattern->getSize(), pattern->getSection());
+                            pattern->getEvaluator()->readData(pattern->getOffset(), section.data() + toAddr, pattern->getSize(), pattern->getSection());
                         }
                         break;
                     }

Original file line number	Diff line number	Diff line change
`@@ -199,8 +199,8 @@ namespace pl::core::ast {`
`199`	`199`	`if ((evaluator->getReadOffset() - evaluator->getDataBaseAddress()) > (evaluator->getDataSize() + 1))`
`200`	`200`	`err::E0004.throwError("Array expanded past end of the data before a null-entry was found.", "Try using a while-sized array instead to limit the size of the array.", this->getLocation());`
`201`	`201`
`202`		`- evaluator->readData(evaluator->getReadOffset(), buffer.data(), buffer.size(), templatePattern->getSection());`
`203`		`- evaluator->getReadOffsetAndIncrement(buffer.size());`
	`202`	`+ templatePattern->getEvaluator()->readData(evaluator->getReadOffset(), buffer.data(), buffer.size(), templatePattern->getSection());`
	`203`	`+ templatePattern->getEvaluator()->getReadOffsetAndIncrement(buffer.size());`
`204`	`204`
`205`	`205`	`entryCount++;`
`206`	`206`
`@@ -213,7 +213,7 @@ namespace pl::core::ast {`
`213`	`213`	`}`
`214`	`214`
`215`	`215`	`if (reachedEnd) break;`
`216`		`- evaluator->handleAbort();`
	`216`	`+ templatePattern->getEvaluator()->handleAbort();`
`217`	`217`	`}`
`218`	`218`	`}`
`219`	`219`
`@@ -394,7 +394,7 @@ namespace pl::core::ast {`
`394`	`394`	`err::E0004.throwError("Array expanded past end of the data before a null-entry was found.", "Try using a while-sized array instead to limit the size of the array.", this->getLocation());`
`395`	`395`
`396`	`396`	`const auto patternSize = pattern->getSize();`
`397`		`- evaluator->readData(evaluator->getReadOffset() - patternSize, buffer.data(), buffer.size(), pattern->getSection());`
	`397`	`+ pattern->getEvaluator()->readData(evaluator->getReadOffset() - patternSize, buffer.data(), buffer.size(), pattern->getSection());`
`398`	`398`
`399`	`399`	`addEntries(hlp::moveToVector(std::move(pattern)));`
`400`	`400`
Original file line number	Diff line number	Diff line change
`@@ -265,11 +265,11 @@ namespace pl::lib::libstd::mem {`
`265`	`265`	`if (auto iterable = dynamic_cast<ptrn::IIterable*>(pattern.get())) {`
`266`	`266`	`iterable->forEachEntry(0, iterable->getEntryCount(), [&](u64, ptrn::Pattern *entry) {`
`267`	`267`	`auto entrySize = entry->getSize();`
`268`		`- ctx->readData(entry->getOffset(), section.data() + toAddr, entrySize, entry->getSection());`
	`268`	`+ pattern->getEvaluator()->readData(entry->getOffset(), section.data() + toAddr, entrySize, entry->getSection());`
`269`	`269`	`toAddr += entrySize;`
`270`	`270`	`});`
`271`	`271`	`} else {`
`272`		`- ctx->readData(pattern->getOffset(), section.data() + toAddr, pattern->getSize(), pattern->getSection());`
	`272`	`+ pattern->getEvaluator()->readData(pattern->getOffset(), section.data() + toAddr, pattern->getSize(), pattern->getSection());`
`273`	`273`	`}`
`274`	`274`	`break;`
`275`	`275`	`}`