Used shared pointers instead of unique pointers.

n8lang · Oct 26, 2024 · 82b5288 · 82b5288
1 parent af9bbb2
commit 82b5288
Show file tree

Hide file tree

Showing 43 changed files with 175 additions and 175 deletions.
diff --git a/include/zhivo/ast/ASTNode.hpp b/include/zhivo/ast/ASTNode.hpp
@@ -25,7 +25,7 @@
 
 class ASTNode {
 protected:
-    std::unique_ptr<Token> address = nullptr;
+    std::shared_ptr<Token> address = nullptr;
 
 public:
     ASTNode() : address(nullptr) {}

diff --git a/include/zhivo/ast/ASTNodeException.hpp b/include/zhivo/ast/ASTNodeException.hpp
@@ -26,11 +26,11 @@
 
 class ASTNodeException final : public std::runtime_error {
 private:
-    std::unique_ptr<Token> address;
+    std::shared_ptr<Token> address;
 
 public:
     explicit ASTNodeException(
-        std::unique_ptr<Token> _address,
+        std::shared_ptr<Token> _address,
         const std::string& message) :
         std::runtime_error(message),
         address(std::move(_address)) {}

diff --git a/include/zhivo/ast/TerminativeSignal.hpp b/include/zhivo/ast/TerminativeSignal.hpp
@@ -59,11 +59,11 @@ class TerminativeReturnSignal : public std::exception {
 
 class TerminativeThrowSignal : public std::exception {
 private:
-    std::unique_ptr<Token> address;
+    std::shared_ptr<Token> address;
     DynamicObject value;
 
 public:
-    TerminativeThrowSignal(std::unique_ptr<Token> _address, DynamicObject _value) :
+    TerminativeThrowSignal(std::shared_ptr<Token> _address, DynamicObject _value) :
         address(std::move(_address)),
         value(std::move(_value)) {}
 

diff --git a/include/zhivo/ast/expression/ArrayAccessExpression.hpp b/include/zhivo/ast/expression/ArrayAccessExpression.hpp
@@ -27,14 +27,14 @@
 
 class ArrayAccessExpression final : public ASTNode {
 private:
-    std::unique_ptr<ASTNode> array;
-    std::unique_ptr<ASTNode> index;
+    std::shared_ptr<ASTNode> array;
+    std::shared_ptr<ASTNode> index;
 
 public:
     explicit ArrayAccessExpression(
-        std::unique_ptr<Token> _address,
-        std::unique_ptr<ASTNode> _array,
-        std::unique_ptr<ASTNode> _index
+        std::shared_ptr<Token> _address,
+        std::shared_ptr<ASTNode> _array,
+        std::shared_ptr<ASTNode> _index
     ) : array(std::move(_array)),
         index(std::move(_index)) {
         this->address = std::move(_address);

diff --git a/include/zhivo/ast/expression/ArrayExpression.hpp b/include/zhivo/ast/expression/ArrayExpression.hpp
@@ -27,12 +27,12 @@
 
 class ArrayExpression final : public ASTNode {
 private:
-    std::vector<std::unique_ptr<ASTNode>> elements;
+    std::vector<std::shared_ptr<ASTNode>> elements;
 
 public:
     explicit ArrayExpression(
-        std::unique_ptr<Token> _address,
-        std::vector<std::unique_ptr<ASTNode>> _elements
+        std::shared_ptr<Token> _address,
+        std::vector<std::shared_ptr<ASTNode>> _elements
     ) : elements(std::move(_elements)) {
         this->address = std::move(_address);
     }

diff --git a/include/zhivo/ast/expression/BinaryExpression.hpp b/include/zhivo/ast/expression/BinaryExpression.hpp
@@ -27,8 +27,8 @@
 
 class BinaryExpression final : public ASTNode {
 private:
-    std::unique_ptr<ASTNode> left;
-    std::unique_ptr<ASTNode> right;
+    std::shared_ptr<ASTNode> left;
+    std::shared_ptr<ASTNode> right;
     std::string op;
 
     DynamicObject applyStringOp(DynamicObject& lValue, DynamicObject& rValue);
@@ -39,10 +39,10 @@ class BinaryExpression final : public ASTNode {
 
 public:
     explicit BinaryExpression(
-        std::unique_ptr<Token> _address,
-        std::unique_ptr<ASTNode> _left,
+        std::shared_ptr<Token> _address,
+        std::shared_ptr<ASTNode> _left,
         std::string _op,
-        std::unique_ptr<ASTNode> _right
+        std::shared_ptr<ASTNode> _right
     ) : left(std::move(_left)),
         right(std::move(_right)),
         op(_op) {

diff --git a/include/zhivo/ast/expression/BlockExpression.hpp b/include/zhivo/ast/expression/BlockExpression.hpp
@@ -27,12 +27,12 @@
 
 class BlockExpression final : public ASTNode {
 private:
-    std::vector<std::unique_ptr<ASTNode>> statements;
+    std::vector<std::shared_ptr<ASTNode>> statements;
 
 public:
     explicit BlockExpression(
-        std::unique_ptr<Token> _address,
-        std::vector<std::unique_ptr<ASTNode>> _statements
+        std::shared_ptr<Token> _address,
+        std::vector<std::shared_ptr<ASTNode>> _statements
     ) : statements(std::move(_statements)) {
         this->address = std::move(_address);
     }

diff --git a/include/zhivo/ast/expression/BooleanLiteralExpression.hpp b/include/zhivo/ast/expression/BooleanLiteralExpression.hpp
@@ -29,7 +29,7 @@ class BooleanLiteralExpression final : public ASTNode {
 
 public:
     explicit BooleanLiteralExpression(
-        std::unique_ptr<Token> _address,
+        std::shared_ptr<Token> _address,
         bool _value
     ) : value(_value) {
         this->address = std::move(_address);

diff --git a/include/zhivo/ast/expression/CatchHandleExpression.hpp b/include/zhivo/ast/expression/CatchHandleExpression.hpp
@@ -28,18 +28,18 @@
 
 class CatchHandleExpression final : public ASTNode {
 private:
-    std::unique_ptr<ASTNode> catchBlock;
-    std::unique_ptr<ASTNode> handleBlock;
-    std::unique_ptr<Token> handler;
-    std::unique_ptr<ASTNode> finalBlock;
+    std::shared_ptr<ASTNode> catchBlock;
+    std::shared_ptr<ASTNode> handleBlock;
+    std::shared_ptr<Token> handler;
+    std::shared_ptr<ASTNode> finalBlock;
 
 public:
     explicit CatchHandleExpression(
-        std::unique_ptr<Token> _address,
-        std::unique_ptr<ASTNode> _catchBlock,
-        std::unique_ptr<ASTNode> _handleBlock,
-        std::unique_ptr<Token> _handler,
-        std::unique_ptr<ASTNode> _finalBlock
+        std::shared_ptr<Token> _address,
+        std::shared_ptr<ASTNode> _catchBlock,
+        std::shared_ptr<ASTNode> _handleBlock,
+        std::shared_ptr<Token> _handler,
+        std::shared_ptr<ASTNode> _finalBlock
     ) : catchBlock(std::move(_catchBlock)),
         handleBlock(std::move(_handleBlock)),
         handler(std::move(_handler)),

diff --git a/include/zhivo/ast/expression/FunctionCallExpression.hpp b/include/zhivo/ast/expression/FunctionCallExpression.hpp
@@ -30,14 +30,14 @@
 
 class FunctionCallExpression final : public ASTNode {
 private:
-    std::unique_ptr<ASTNode> callable;
-    std::vector<std::unique_ptr<ASTNode>> arguments;
+    std::shared_ptr<ASTNode> callable;
+    std::vector<std::shared_ptr<ASTNode>> arguments;
 
 public:
     explicit FunctionCallExpression(
-        std::unique_ptr<Token> _address,
-        std::unique_ptr<ASTNode> _callable,
-        std::vector<std::unique_ptr<ASTNode>> _arguments
+        std::shared_ptr<Token> _address,
+        std::shared_ptr<ASTNode> _callable,
+        std::vector<std::shared_ptr<ASTNode>> _arguments
     ) : callable(std::move(_callable)),
         arguments(std::move(_arguments)) {
         this->address = std::move(_address);

diff --git a/include/zhivo/ast/expression/FunctionDeclarationExpression.hpp b/include/zhivo/ast/expression/FunctionDeclarationExpression.hpp
@@ -29,14 +29,14 @@
 
 class FunctionDeclarationExpression final : public ASTNode {
 private:
-    std::vector<std::unique_ptr<Token>> parameters;
-    std::unique_ptr<ASTNode> body;
+    std::vector<std::shared_ptr<Token>> parameters;
+    std::shared_ptr<ASTNode> body;
 
 public:
     explicit FunctionDeclarationExpression(
-        std::unique_ptr<Token> _address,
-        std::vector<std::unique_ptr<Token>> _parameters,
-        std::unique_ptr<ASTNode> _body
+        std::shared_ptr<Token> _address,
+        std::vector<std::shared_ptr<Token>> _parameters,
+        std::shared_ptr<ASTNode> _body
     ) : parameters(std::move(_parameters)),
         body(std::move(_body)) {
         this->address = std::move(_address);

diff --git a/include/zhivo/ast/expression/GroupedExpression.hpp b/include/zhivo/ast/expression/GroupedExpression.hpp
@@ -25,12 +25,12 @@
 
 class GroupedExpression final : public ASTNode {
 private:
-    std::unique_ptr<ASTNode> expression;
+    std::shared_ptr<ASTNode> expression;
 
 public:
     explicit GroupedExpression(
-        std::unique_ptr<Token> _address,
-        std::unique_ptr<ASTNode> _expression
+        std::shared_ptr<Token> _address,
+        std::shared_ptr<ASTNode> _expression
     ) : expression(std::move(_expression)) {
         this->address = std::move(_address);
     }

diff --git a/include/zhivo/ast/expression/IfElseExpression.hpp b/include/zhivo/ast/expression/IfElseExpression.hpp
@@ -25,16 +25,16 @@
 
 class IfElseExpression final : public ASTNode {
 private:
-    std::unique_ptr<ASTNode> condition;
-    std::unique_ptr<ASTNode> thenBranch;
-    std::unique_ptr<ASTNode> elseBranch;
+    std::shared_ptr<ASTNode> condition;
+    std::shared_ptr<ASTNode> thenBranch;
+    std::shared_ptr<ASTNode> elseBranch;
 
 public:
     explicit IfElseExpression(
-        std::unique_ptr<Token> _address,
-        std::unique_ptr<ASTNode> _condition,
-        std::unique_ptr<ASTNode> _thenBranch,
-        std::unique_ptr<ASTNode> _elseBranch
+        std::shared_ptr<Token> _address,
+        std::shared_ptr<ASTNode> _condition,
+        std::shared_ptr<ASTNode> _thenBranch,
+        std::shared_ptr<ASTNode> _elseBranch
     ) : condition(std::move(_condition)),
         thenBranch(std::move(_thenBranch)),
         elseBranch(std::move(_elseBranch)) {

diff --git a/include/zhivo/ast/expression/LoopExpression.hpp b/include/zhivo/ast/expression/LoopExpression.hpp
@@ -27,18 +27,18 @@
 
 class LoopExpression final : public ASTNode {
 private:
-    std::unique_ptr<ASTNode> initial;
-    std::unique_ptr<ASTNode> condition;
-    std::unique_ptr<ASTNode> postexpr;
-    std::unique_ptr<ASTNode> body;
+    std::shared_ptr<ASTNode> initial;
+    std::shared_ptr<ASTNode> condition;
+    std::shared_ptr<ASTNode> postexpr;
+    std::shared_ptr<ASTNode> body;
 
 public:
     explicit LoopExpression(
-        std::unique_ptr<Token> _address,
-        std::unique_ptr<ASTNode> _initial,
-        std::unique_ptr<ASTNode> _condition,
-        std::unique_ptr<ASTNode> _postexpr,
-        std::unique_ptr<ASTNode> _body
+        std::shared_ptr<Token> _address,
+        std::shared_ptr<ASTNode> _initial,
+        std::shared_ptr<ASTNode> _condition,
+        std::shared_ptr<ASTNode> _postexpr,
+        std::shared_ptr<ASTNode> _body
     ) : initial(std::move(_initial)),
         condition(std::move(_condition)),
         postexpr(std::move(_postexpr)),

diff --git a/include/zhivo/ast/expression/MaybeExpression.hpp b/include/zhivo/ast/expression/MaybeExpression.hpp
@@ -26,7 +26,7 @@
 
 class MaybeExpression final : public ASTNode {
 public:
-    explicit MaybeExpression(std::unique_ptr<Token> _address) {
+    explicit MaybeExpression(std::shared_ptr<Token> _address) {
         this->address = std::move(_address);
     }
 

diff --git a/include/zhivo/ast/expression/NilCoalescingExpression.hpp b/include/zhivo/ast/expression/NilCoalescingExpression.hpp
@@ -24,14 +24,14 @@
 
 class NilCoalescingExpression final : public ASTNode {
 private:
-    std::unique_ptr<ASTNode> left;
-    std::unique_ptr<ASTNode> right;
+    std::shared_ptr<ASTNode> left;
+    std::shared_ptr<ASTNode> right;
 
 public:
     explicit NilCoalescingExpression(
-        std::unique_ptr<Token> _address,
-        std::unique_ptr<ASTNode> _left,
-        std::unique_ptr<ASTNode> _right
+        std::shared_ptr<Token> _address,
+        std::shared_ptr<ASTNode> _left,
+        std::shared_ptr<ASTNode> _right
     ) : left(std::move(_left)),
         right(std::move(_right)) {
         this->address = std::move(_address);

diff --git a/include/zhivo/ast/expression/NilLiteralExpression.hpp b/include/zhivo/ast/expression/NilLiteralExpression.hpp
@@ -25,7 +25,7 @@
 
 class NilLiteralExpression final : public ASTNode {
 public:
-    explicit NilLiteralExpression(std::unique_ptr<Token> _address) {
+    explicit NilLiteralExpression(std::shared_ptr<Token> _address) {
         this->address = std::move(_address);
     }
 

diff --git a/include/zhivo/ast/expression/NumberLiteralExpression.hpp b/include/zhivo/ast/expression/NumberLiteralExpression.hpp
@@ -29,7 +29,7 @@ class NumberLiteralExpression final : public ASTNode {
 
 public:
     explicit NumberLiteralExpression(
-        std::unique_ptr<Token> _address,
+        std::shared_ptr<Token> _address,
         double _value
     ) : value(_value) {
         this->address = std::move(_address);

diff --git a/include/zhivo/ast/expression/ParallelExpression.hpp b/include/zhivo/ast/expression/ParallelExpression.hpp
@@ -25,12 +25,12 @@
 
 class ParallelExpression final : public ASTNode {
 private:
-    std::unique_ptr<ASTNode> expression;
+    std::shared_ptr<ASTNode> expression;
 
 public:
     explicit ParallelExpression(
-        std::unique_ptr<Token> _address,
-        std::unique_ptr<ASTNode> _expression
+        std::shared_ptr<Token> _address,
+        std::shared_ptr<ASTNode> _expression
     ) : expression(std::move(_expression)) {
         this->address = std::move(_address);
     }

diff --git a/include/zhivo/ast/expression/RandomExpression.hpp b/include/zhivo/ast/expression/RandomExpression.hpp
@@ -25,14 +25,14 @@
 
 class RandomExpression final : public ASTNode {
 private:
-    std::unique_ptr<ASTNode> thenBranch;
-    std::unique_ptr<ASTNode> elseBranch;
+    std::shared_ptr<ASTNode> thenBranch;
+    std::shared_ptr<ASTNode> elseBranch;
 
 public:
     explicit RandomExpression(
-        std::unique_ptr<Token> _address,
-        std::unique_ptr<ASTNode> _thenBranch,
-        std::unique_ptr<ASTNode> _elseBranch
+        std::shared_ptr<Token> _address,
+        std::shared_ptr<ASTNode> _thenBranch,
+        std::shared_ptr<ASTNode> _elseBranch
     ) : thenBranch(std::move(_thenBranch)),
         elseBranch(std::move(_elseBranch)) {
         this->address = std::move(_address);

diff --git a/include/zhivo/ast/expression/RegexExpression.hpp b/include/zhivo/ast/expression/RegexExpression.hpp
@@ -29,7 +29,7 @@ class RegexExpression final : public ASTNode {
     std::string regExpression;
 public:
     explicit RegexExpression(
-        std::unique_ptr<Token> _address,
+        std::shared_ptr<Token> _address,
         std::string& _regExpression
     ) : regExpression(std::move(_regExpression)) {
         this->address = std::move(_address);

diff --git a/include/zhivo/ast/expression/RenderExpression.hpp b/include/zhivo/ast/expression/RenderExpression.hpp
@@ -23,16 +23,16 @@
 
 class RenderExpression final : public ASTNode {
 private:
-    std::unique_ptr<ASTNode> expression;
+    std::shared_ptr<ASTNode> expression;
     bool newLine;
     bool errorStream;
 
 public:
     explicit RenderExpression(
-        std::unique_ptr<Token> _address,
+        std::shared_ptr<Token> _address,
         bool _newLine,
         bool _errorStream,
-        std::unique_ptr<ASTNode> _expression
+        std::shared_ptr<ASTNode> _expression
     ) : expression(std::move(_expression)),
         newLine(_newLine),
         errorStream(_errorStream) {

diff --git a/include/zhivo/ast/expression/StringLiteralExpression.hpp b/include/zhivo/ast/expression/StringLiteralExpression.hpp
@@ -31,7 +31,7 @@ class StringLiteralExpression final : public ASTNode {
 
 public:
     explicit StringLiteralExpression(
-        std::unique_ptr<Token> _address,
+        std::shared_ptr<Token> _address,
         std::string _value
     ) : value(_value) {
         this->address = std::move(_address);

diff --git a/include/zhivo/ast/expression/TypeExpression.hpp b/include/zhivo/ast/expression/TypeExpression.hpp
@@ -27,12 +27,12 @@
 
 class TypeExpression final : public ASTNode {
 private:
-    std::unique_ptr<ASTNode> expression;
+    std::shared_ptr<ASTNode> expression;
 
 public:
     explicit TypeExpression(
-        std::unique_ptr<Token> _address,
-        std::unique_ptr<ASTNode> _expression
+        std::shared_ptr<Token> _address,
+        std::shared_ptr<ASTNode> _expression
     ) : expression(std::move(_expression)) {
         this->address = std::move(_address);
     }