Conversion of all raw pointers to smart pointers

.clang-tidy

@@ -97,7 +97,7 @@ modernize-use-bool-literals,
 modernize-use-emplace,
 modernize-use-equals-default,
 modernize-use-equals-delete,
-# modernize-use-nodiscard,
+modernize-use-nodiscard,
 modernize-use-noexcept,
 modernize-use-nullptr,
 modernize-use-override,

.github/workflows/cmake-ubuntu.yml

@@ -20,8 +20,8 @@ jobs:
     steps:
     - uses: actions/checkout@v3
 
-    - name: Install dependencies
-      run: | 
+    - name: Install Dependencies
+      run: |
         sudo apt-get update
         sudo apt-get install -y openssl libssl-dev libx11-dev xorg-dev
 

.gitignore

@@ -13,6 +13,7 @@ _deps
 
 cmake-build-*/
 build-*/
+builds/
 *_include.cmake
 bin/
 

CMakeLists.txt

@@ -5,7 +5,7 @@ project(ComputerAlgebraSystem
         LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_CXX_EXTENSIONS OFF)  # Don't use compiler extensions so we have a portable codebase.
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
@@ -19,6 +19,7 @@ if (CMAKE_BUILD_TYPE MATCHES Debug)
     endif()
 
     # Enable ASAN and UBSAN
+    # TODO: Fix sanitizers for Windows and Linux
     if (MSVC)
         add_compile_options(/fsanitize=address,undefined)
         add_link_options(/fsanitize=address,undefined)

build.bat

@@ -17,10 +17,10 @@ IF "%#%" "-eq" "0" (
 )
 
 IF "%build_debug%" "-eq" "1" (
-  cmake "-DCMAKE_BUILD_TYPE=Debug" "-S" "." "-B" "build-debug"
-  cmake "--build" "build-debug"
+  cmake "-DCMAKE_BUILD_TYPE=Debug" "-S" "." "-B" "builds/debug"
+  cmake "--build" "builds/debug"
 )
 IF "%build_release%" "-eq" "1" (
-  cmake "-DCMAKE_BUILD_TYPE=Release" "-S" "." "-B" "build-release"
-  cmake "--build" "build-release"
+  cmake "-DCMAKE_BUILD_TYPE=Release" "-S" "." "-B" "builds/release"
+  cmake "--build" "builds/release"
 )

build.sh

@@ -28,12 +28,12 @@ fi
 
 # Build the debug version if specified
 if [ $build_debug -eq 1 ]; then
-  cmake -DCMAKE_BUILD_TYPE=Debug -S . -B build-debug
-  cmake --build build-debug
+  cmake -DCMAKE_BUILD_TYPE=Debug -S . -B builds/debug
+  cmake --build builds/debug
 fi
 
 # Build the release version if specified
 if [ $build_release -eq 1 ]; then
-  cmake -DCMAKE_BUILD_TYPE=Release -S . -B build-release
-  cmake --build build-release
+  cmake -DCMAKE_BUILD_TYPE=Release -S . -B builds/release
+  cmake --build builds/release
 fi

cas/include/cas/data/ExpressionParser.h

@@ -13,7 +13,7 @@ CAS_NAMESPACE
 class ExpressionParser {
 public:
     static ExpressionParser& getInstance();
-    Expression* parse(const std::string& expression, VarSet& variables);
+    ExprPtr parse(const std::string& expression, VarSet& variables);
 
     void setup(std::string& expr);
     bool isValidExpression(const std::string& expr);

cas/include/cas/data/VariableMap.h

@@ -12,6 +12,8 @@
 
 CAS_NAMESPACE
 
+// TODO redesign to store std::pairs so iterators can be references
+
 struct LetterMap {
     static const char LETTER_COUNT = 26;
     char letters = 0;

cas/include/cas/latex/LatexRenderer.h

@@ -26,7 +26,7 @@ class LatexRenderer {
 
 private:
     const std::string prefix = "lr_";
-    const std::string resFolder = "../res/latex";
+    const std::string resFolder = "../../res/latex";
 };
 
 CAS_NAMESPACE_END

cas/include/cas/node/Abs.h

@@ -11,19 +11,23 @@ CAS_NAMESPACE
 
 class Abs : public BracketExpression {
 public:
-    explicit Abs(Expression* argument);
+    explicit Abs(const ExprPtr& argument);
 
     Abs() = delete;
 
     ~Abs() override = default;
 
     double evaluate(const VariableMap& variables) override;
 
-    Abs* clone() override;
+    ExprPtr clone() override;
 
-    Expression* simplified() override;
+    ExprPtr simplified() override;
 
     std::string text() override;
+
+    static ExprPtr from(const ExprPtr& argument) {
+        return std::make_shared<Abs>(argument);
+    }
 };
 
 CAS_NAMESPACE_END

cas/include/cas/node/BracketExpression.h

@@ -15,9 +15,9 @@ class BracketExpression : public UnaryExpression {
 
     ~BracketExpression() override = default;
 
-    bool _equals(Expression* other) override;
+    bool _equals(const ExprPtr& other) override;
 
-    Expression* derivative(char var) override;
+    ExprPtr derivative(char var) override;
 
     std::string latex() override;
 
@@ -28,7 +28,7 @@ class BracketExpression : public UnaryExpression {
     std::string explicitText() override;
 
 protected:
-    explicit BracketExpression(const ExpressionProperties& properties, Expression* argument,
+    explicit BracketExpression(const ExpressionProperties& properties, const ExprPtr& argument,
                                const wchar_t* openBracket, const wchar_t* closeBracket,
                                const char* openBracketLatex, const char* closeBracketLatex);
 

cas/include/cas/node/Cbrt.h

@@ -11,19 +11,21 @@ CAS_NAMESPACE
 
 class Cbrt : public Root {
 public:
-    explicit Cbrt(Expression* base);
+    explicit Cbrt(const ExprPtr& base);
     Cbrt() = delete;
     ~Cbrt() override = default;
 
     double evaluate(const VariableMap& variables) override;
-    Cbrt* clone() override;
-    Expression* _derivative(char variable) override;
-    Expression* simplified() override;
+    ExprPtr clone() override;
+    ExprPtr _derivative(char variable) override;
+    ExprPtr simplified() override;
 
     std::string latex() override;
     std::wstring stringify() override;
     std::string text() override;
     std::string explicitText() override;
+
+    static CbrtPtr from(const ExprPtr& base) { return std::make_shared<Cbrt>(base); }
 };
 
 CAS_NAMESPACE_END

cas/include/cas/node/Ceil.h

@@ -11,17 +11,21 @@ CAS_NAMESPACE
 
 class Ceil : public BracketExpression {
 public:
-    explicit Ceil(Expression* argument);
+    explicit Ceil(const ExprPtr& argument);
 
     Ceil() = delete;
 
     ~Ceil() override = default;
 
     double evaluate(const VariableMap& variables) override;
 
-    Ceil* clone() override;
+    ExprPtr clone() override;
 
-    Expression* simplified() override;
+    ExprPtr simplified() override;
+
+    static ExprPtr from(const ExprPtr& argument) {
+        return std::make_shared<Ceil>(argument);
+    }
 };
 
 CAS_NAMESPACE_END

cas/include/cas/node/Const.h

@@ -1,6 +1,7 @@
 //
 // Created by Abd-El-Aziz Zayed on 2022-08-26.
 //
+
 #ifndef CAS_CONSTANT_H
 #define CAS_CONSTANT_H
 
@@ -9,23 +10,21 @@
 
 CAS_NAMESPACE
 
-class Const : public Expression {
+class Const : public Expr {
 public:
     explicit Const(double value);
-
-    explicit Const() : Const(0.0){};
-
+    Const() = delete;
     ~Const() override = default;
 
     double evaluate(const VariableMap& variables) override;
 
-    bool _equals(Expression* expression) override;
+    bool _equals(const ExprPtr& expression) override;
 
-    Const* clone() override;
+    ExprPtr clone() override;
 
-    Const* _derivative(char var) override;
+    ExprPtr _derivative(char var) override;
 
-    Const* simplified() override;
+    ExprPtr simplified() override;
 
     std::string latex() override;
 
@@ -35,17 +34,18 @@ class Const : public Expression {
 
     double getValue() const { return value; }
 
-    static Const* PI() { return new Const{math::PI}; }
+    static ConstPtr PI() { return n(math::PI); }
 
-    static Const* E() { return new Const{math::E}; }
+    static ConstPtr E() { return n(math::E); }
 
-    static Const* PHI() { return new Const{math::PHI}; }
+    static ConstPtr PHI() { return n(math::PHI); }
 
-    static Const* zero() { return new Const; }
+    static ConstPtr zero() { return n(0.0); }
 
-    static Const* one() { return new Const{1.0}; }
+    static ConstPtr one() { return n(1.0); }
 
-    static Const* n(double value) { return new Const{value}; }
+    static ConstPtr n(double value) { return std::make_shared<Const>(value); }
+    static ConstPtr from(double value) { return n(value); }
 
     static bool floatingsEqual(double a, double b) {
         double max = std::max(1.0, std::max(std::fabs(a), std::fabs(b)));

cas/include/cas/node/Divide.h

@@ -10,23 +10,22 @@
 
 CAS_NAMESPACE
 
-class Divide : public Expression {
+class Divide : public Expr {
 public:
-    explicit Divide(Expression* dividend, Expression* divisor);
-
     Divide() = delete;
+    explicit Divide(const ExprPtr& dividend, const ExprPtr& divisor);
 
-    ~Divide() override;
+    ~Divide() override = default;
 
     double evaluate(const VariableMap& variables) override;
 
-    bool _equals(Expression* expression) override;
+    bool _equals(const ExprPtr& expression) override;
 
-    Divide* clone() override;
+    ExprPtr clone() override;
 
-    Divide* _derivative(char var) override;
+    ExprPtr _derivative(char var) override;
 
-    Expression* simplified() override;
+    ExprPtr simplified() override;
 
     std::string latex() override;
 
@@ -36,12 +35,14 @@ class Divide : public Expression {
 
     std::string explicitText() override;
 
-    Expression* getDividend() const { return dividend; }
-    Expression* getDivisor() const { return divisor; }
+    static DividePtr from(const ExprPtr& dividend, const ExprPtr& divisor) { return std::make_shared<Divide>(dividend, divisor); }
+
+    ExprPtr getDividend() const { return dividend; }
+    ExprPtr getDivisor() const { return divisor; }
 
 private:
-    Expression* dividend;
-    Expression* divisor;
+    ExprPtr dividend;
+    ExprPtr divisor;
 };
 
 CAS_NAMESPACE_END

cas/include/cas/node/Exp.h

@@ -11,21 +11,23 @@ CAS_NAMESPACE
 
 class Exp : public Power {
 public:
-    explicit Exp(Expression* exponent);
+    explicit Exp(const ExprPtr& exponent);
 
     Exp() = delete;
 
     ~Exp() override = default;
 
     double evaluate(const VariableMap& variables) override;
 
-    Exp* clone() override;
+    ExprPtr clone() override;
 
-    Expression* _derivative(char var) override;
+    ExprPtr _derivative(char var) override;
 
-    Expression* simplified() override;
+    ExprPtr simplified() override;
 
     std::string explicitText() override;
+
+    static ExpPtr from(const ExprPtr& exponent) { return std::make_shared<Exp>(exponent); }
 };
 
 CAS_NAMESPACE_END