Needed to set m_parent to weak_ptr in order to fix problems with dynamic cast. Also json types needed to be set to shared_ptrs instead of unique.

paxcut · paxcut · commit 5923f2b6a34e · 2025-06-14T22:34:46.000-07:00
diff --git a/lib/include/pl/api.hpp b/lib/include/pl/api.hpp
@@ -126,7 +126,7 @@ namespace pl::api {
     /**
      * @brief A function callback called when a custom built-in type is being instantiated
      */
-    using TypeCallback = std::function<std::unique_ptr<ptrn::Pattern>(core::Evaluator *, const std::vector<core::Token::Literal> &)>;
+    using TypeCallback = std::function<std::shared_ptr<ptrn::Pattern>(core::Evaluator *, const std::vector<core::Token::Literal> &)>;
 
     /**
      * @brief A type representing a function.
diff --git a/lib/include/pl/patterns/pattern.hpp b/lib/include/pl/patterns/pattern.hpp
@@ -68,6 +68,8 @@ namespace pl::ptrn {
         constexpr static u64 PatternLocalSectionId  = 0xFFFF'FFFF'FFFF'FFFE;
         constexpr static u64 InstantiationSectionId = 0xFFFF'FFFF'FFFF'FFFD;
 
+        Pattern() = default;
+
         Pattern(core::Evaluator *evaluator, u64 offset, size_t size, u32 line)
             : m_evaluator(evaluator), m_line(line), m_offset(offset), m_size(size) {
 
@@ -543,15 +545,15 @@ namespace pl::ptrn {
             this->m_initialized = initialized;
         }
 
-        [[nodiscard]] const Pattern* getParent() const {
-            return m_parent;
+        [[nodiscard]] const Pattern *getParent() const {
+            return m_parent.lock().get();
         }
 
-        [[nodiscard]] Pattern* getParent() {
-            return m_parent;
+        [[nodiscard]] Pattern *getParent() {
+            return m_parent.lock().get();
         }
 
-        void setParent(Pattern *parent) {
+        void setParent(std::shared_ptr<Pattern> parent) {
             m_parent = parent;
         }
 
@@ -626,10 +628,10 @@ namespace pl::ptrn {
     private:
         friend pl::core::Evaluator;
 
-        core::Evaluator *m_evaluator;
+        core::Evaluator *m_evaluator = nullptr;
 
         std::unique_ptr<std::map<std::string, std::vector<core::Token::Literal>>> m_attributes;
-        Pattern *m_parent = nullptr;
+        std::weak_ptr<Pattern> m_parent;
         u32 m_line = 0;
 
         std::set<std::string>::const_iterator m_variableName;
diff --git a/lib/include/pl/patterns/pattern_array_dynamic.hpp b/lib/include/pl/patterns/pattern_array_dynamic.hpp
@@ -22,7 +22,7 @@ namespace pl::ptrn {
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
             auto other = std::make_shared<PatternArrayDynamic>(*this);
             for (const auto &entry : other->m_entries)
-                entry->setParent(other->reference().get());
+                entry->setParent(other->reference());
 
             return other;
         }
diff --git a/lib/include/pl/patterns/pattern_array_static.hpp b/lib/include/pl/patterns/pattern_array_static.hpp
@@ -17,7 +17,7 @@ namespace pl::ptrn {
 
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
             auto other = std::make_shared<PatternArrayStatic>(*this);
-            other->m_template->setParent(other->reference().get());
+            other->m_template->setParent(other->reference());
             return other;
         }
 
diff --git a/lib/include/pl/patterns/pattern_bitfield.hpp b/lib/include/pl/patterns/pattern_bitfield.hpp
@@ -11,16 +11,12 @@ namespace pl::ptrn {
 
         [[nodiscard]] const PatternBitfieldMember& getTopmostBitfield() const {
             const PatternBitfieldMember* topBitfield = this;
-            while (auto *parent = topBitfield->getParent()) {
-                if ( parent == nullptr || parent->getParent() ==nullptr )
-                    break;
-                else if (auto weakPtr = parent->weak_from_this(); !weakPtr.expired()) {
-                    const auto *parentBitfield = dynamic_cast<const PatternBitfieldMember *>(parent);
-                    if (parentBitfield == nullptr)
-                        break;
-                    topBitfield = parentBitfield;
-                } else
+            while (auto parent = topBitfield->getParent()) {
+                auto parentBitfield = dynamic_cast<const PatternBitfieldMember*>(parent);
+                if (parentBitfield == nullptr)
                     break;
+
+                topBitfield = parentBitfield;
             }
 
             return *topBitfield;
@@ -60,7 +56,7 @@ namespace pl::ptrn {
         PatternBitfieldField(core::Evaluator *evaluator, u64 offset, u8 bitOffset, u8 bitSize, u32 line, PatternBitfieldMember *parentBitfield = nullptr)
                 : PatternBitfieldMember(evaluator, offset, (bitOffset + bitSize + 7) / 8, line), m_bitOffset(bitOffset % 8), m_bitSize(bitSize) {
             if (parentBitfield != nullptr)
-                this->setParent(parentBitfield->reference().get());
+                this->setParent(parentBitfield->reference());
         }
 
         PatternBitfieldField(const PatternBitfieldField &other) : PatternBitfieldMember(other) {
@@ -289,7 +285,7 @@ namespace pl::ptrn {
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
             auto other =  std::make_shared<PatternBitfieldArray>(*this);
             for (const auto &entry : other->m_entries)
-                entry->setParent(other->reference().get());
+                entry->setParent(other->reference());
             return other;
         }
 
@@ -649,7 +645,7 @@ namespace pl::ptrn {
                 this->setBaseColor(this->m_fields.front()->getColor());
 
             for (const auto &field : this->m_fields) {
-                field->setParent(this);
+                field->setParent(this->reference());
                 this->m_sortedFields.push_back(field.get());
             }
         }
diff --git a/lib/include/pl/patterns/pattern_struct.hpp b/lib/include/pl/patterns/pattern_struct.hpp
@@ -23,7 +23,7 @@ namespace pl::ptrn {
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
             auto other = std::make_shared<PatternStruct>(*this);
             for (const auto &member : other->m_members)
-                member->setParent(other->reference().get());
+                member->setParent(other->reference());
 
             return other;
         }
@@ -39,7 +39,7 @@ namespace pl::ptrn {
         void addEntry(const std::shared_ptr<Pattern> &entry) override {
             if (entry == nullptr) return;
 
-            entry->setParent(this);
+            entry->setParent(this->reference());
             this->m_sortedMembers.push_back(entry.get());
             this->m_members.push_back(entry);
         }
diff --git a/lib/include/pl/patterns/pattern_union.hpp b/lib/include/pl/patterns/pattern_union.hpp
@@ -23,7 +23,7 @@ namespace pl::ptrn {
         [[nodiscard]] std::shared_ptr<Pattern> clone() const override {
             auto other = std::make_shared<PatternUnion>(*this);
             for (const auto &member : other->m_members)
-                member->setParent(other->reference().get());
+                member->setParent(other->reference());
 
             return other;
         }
diff --git a/lib/source/pl/core/ast/ast_node_bitfield.cpp b/lib/source/pl/core/ast/ast_node_bitfield.cpp
@@ -139,7 +139,7 @@ namespace pl::core::ast {
 
         for (auto &pattern : potentialPatterns) {
             if (auto bitfieldMember = dynamic_cast<ptrn::PatternBitfieldMember*>(pattern.get()); bitfieldMember != nullptr) {
-                bitfieldMember->setParent(bitfieldPattern.get());
+                bitfieldMember->setParent(bitfieldPattern->reference());
                 if (!bitfieldMember->isPadding())
                     fields.push_back(pattern);
             } else {
diff --git a/lib/source/pl/core/ast/ast_node_bitfield_array_variable_decl.cpp b/lib/source/pl/core/ast/ast_node_bitfield_array_variable_decl.cpp
@@ -133,7 +133,7 @@ namespace pl::core::ast {
 
             for (auto &pattern : entries) {
                 if (auto bitfieldMember = dynamic_cast<ptrn::PatternBitfieldMember*>(pattern.get()); bitfieldMember != nullptr)
-                    bitfieldMember->setParent(arrayPattern.get());
+                    bitfieldMember->setParent(arrayPattern->reference());
             }
 
             arrayPattern->setEntries(entries);
diff --git a/lib/source/pl/core/ast/ast_node_builtin_type.cpp b/lib/source/pl/core/ast/ast_node_builtin_type.cpp
@@ -23,23 +23,23 @@ namespace pl::core::ast {
         auto size   = Token::getTypeSize(this->m_type);
         auto offset = evaluator->getReadOffsetAndIncrement(size);
 
-        std::unique_ptr<ptrn::Pattern> pattern;
+        std::shared_ptr<ptrn::Pattern> pattern;
         if (Token::isUnsigned(this->m_type))
-            pattern = std::make_unique<ptrn::PatternUnsigned>(evaluator, offset, size, getLocation().line);
+            pattern = std::make_shared<ptrn::PatternUnsigned>(evaluator, offset, size, getLocation().line);
         else if (Token::isSigned(this->m_type))
-            pattern = std::make_unique<ptrn::PatternSigned>(evaluator, offset, size, getLocation().line);
+            pattern = std::make_shared<ptrn::PatternSigned>(evaluator, offset, size, getLocation().line);
         else if (Token::isFloatingPoint(this->m_type))
-            pattern = std::make_unique<ptrn::PatternFloat>(evaluator, offset, size, getLocation().line);
+            pattern = std::make_shared<ptrn::PatternFloat>(evaluator, offset, size, getLocation().line);
         else if (this->m_type == Token::ValueType::Boolean)
-            pattern = std::make_unique<ptrn::PatternBoolean>(evaluator, offset, getLocation().line);
+            pattern = std::make_shared<ptrn::PatternBoolean>(evaluator, offset, getLocation().line);
         else if (this->m_type == Token::ValueType::Character)
-            pattern = std::make_unique<ptrn::PatternCharacter>(evaluator, offset, getLocation().line);
+            pattern = std::make_shared<ptrn::PatternCharacter>(evaluator, offset, getLocation().line);
         else if (this->m_type == Token::ValueType::Character16)
-            pattern = std::make_unique<ptrn::PatternWideCharacter>(evaluator, offset, getLocation().line);
+            pattern = std::make_shared<ptrn::PatternWideCharacter>(evaluator, offset, getLocation().line);
         else if (this->m_type == Token::ValueType::Padding)
-            pattern = std::make_unique<ptrn::PatternPadding>(evaluator, offset, 1, getLocation().line);
+            pattern = std::make_shared<ptrn::PatternPadding>(evaluator, offset, 1, getLocation().line);
         else if (this->m_type == Token::ValueType::String)
-            pattern = std::make_unique<ptrn::PatternString>(evaluator, offset, 0, getLocation().line);
+            pattern = std::make_shared<ptrn::PatternString>(evaluator, offset, 0, getLocation().line);
         else if (this->m_type == Token::ValueType::CustomType) {
             std::vector<Token::Literal> params;
 
diff --git a/lib/source/pl/pattern_language.cpp b/lib/source/pl/pattern_language.cpp
@@ -551,17 +551,9 @@ namespace pl {
         std::transform(intervals.begin(), intervals.end(), std::back_inserter(results), [](const auto &interval) {
             ptrn::Pattern* value = interval.value;
 
-            auto *parent = value->getParent();
-            while (parent != nullptr) {
-                if (auto weakPtr = parent->weak_from_this(); weakPtr.expired()) {
-                    // If the parent is no longer valid, we can stop traversing
-                    parent = nullptr;
-                    break;
-                }
-                if (dynamic_cast<const ptrn::PatternArrayStatic*>(parent->getParent()) == nullptr)
-                    parent = parent->getParent();
-                else
-                    break;
+            auto parent = value->getParent();
+            while (parent != nullptr && dynamic_cast<const ptrn::PatternArrayStatic*>(parent->getParent()) == nullptr) {
+                parent = parent->getParent();
             }
 
             // Handle static array members

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ namespace pl::ptrn {`
`22`	`22`	`[[nodiscard]] std::shared_ptr<Pattern> clone() const override {`
`23`	`23`	`auto other = std::make_shared<PatternArrayDynamic>(*this);`
`24`	`24`	`for (const auto &entry : other->m_entries)`
`25`		`- entry->setParent(other->reference().get());`
	`25`	`+ entry->setParent(other->reference());`
`26`	`26`
`27`	`27`	`return other;`
`28`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ namespace pl::ptrn {`
`17`	`17`
`18`	`18`	`[[nodiscard]] std::shared_ptr<Pattern> clone() const override {`
`19`	`19`	`auto other = std::make_shared<PatternArrayStatic>(*this);`
`20`		`- other->m_template->setParent(other->reference().get());`
	`20`	`+ other->m_template->setParent(other->reference());`
`21`	`21`	`return other;`
`22`	`22`	`}`
`23`	`23`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ namespace pl::ptrn {`
`23`	`23`	`[[nodiscard]] std::shared_ptr<Pattern> clone() const override {`
`24`	`24`	`auto other = std::make_shared<PatternUnion>(*this);`
`25`	`25`	`for (const auto &member : other->m_members)`
`26`		`- member->setParent(other->reference().get());`
	`26`	`+ member->setParent(other->reference());`
`27`	`27`
`28`	`28`	`return other;`
`29`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -133,7 +133,7 @@ namespace pl::core::ast {`
`133`	`133`
`134`	`134`	`for (auto &pattern : entries) {`
`135`	`135`	`if (auto bitfieldMember = dynamic_cast<ptrn::PatternBitfieldMember*>(pattern.get()); bitfieldMember != nullptr)`
`136`		`- bitfieldMember->setParent(arrayPattern.get());`
	`136`	`+ bitfieldMember->setParent(arrayPattern->reference());`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`arrayPattern->setEntries(entries);`