Use shunting yard algorithm for parsing

include/fintamath/core/MathObjectTypes.hpp

@@ -131,6 +131,7 @@ class MathObjectType {
     Nequiv,
     Index,
     Deg,
+    Comma,
 
     None = std::numeric_limits<size_t>::max(),
   };

include/fintamath/expressions/Expression.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <stack>
+
 #include "fintamath/core/CoreConstants.hpp"
 #include "fintamath/core/IArithmetic.hpp"
 #include "fintamath/expressions/IExpression.hpp"
@@ -22,6 +24,7 @@ struct Term {
 };
 
 using TermVector = std::vector<std::shared_ptr<Term>>;
+using OperandStack = std::stack<ArgumentPtr>;
 
 class Expression : public IExpressionCRTP<Expression> {
 public:
@@ -80,17 +83,13 @@ class Expression : public IExpressionCRTP<Expression> {
 
   void updateStringMutable() const;
 
-  bool parseOperator(const TermVector &terms, size_t start, size_t end);
-
-  bool parseFunction(const TermVector &terms, size_t start, size_t end);
-
-  bool parseBrackets(const TermVector &terms, size_t start, size_t end);
+  static TermVector tokensToTerms(const TokenVector &tokens);
 
-  bool parseTerm(const TermVector &terms, size_t start, size_t end);
+  static OperandStack termsToOperands(const TermVector &terms);
 
-  static ArgumentPtrVector parseFunctionArgs(const TermVector &terms, size_t start, size_t end);
+  static ArgumentPtr operandsToExpr(OperandStack &operands);
 
-  static TermVector tokensToTerms(const TokenVector &tokens);
+  static ArgumentPtrVector unwrapComma(const ArgumentPtr &child);
 
   static void insertMultiplications(TermVector &terms);
 
@@ -102,12 +101,6 @@ class Expression : public IExpressionCRTP<Expression> {
 
   static bool canPrevTermBeBinaryOperator(const Term &term);
 
-  static bool skipBrackets(const TermVector &terms, size_t &openBracketIndex);
-
-  static void cutBrackets(const TermVector &terms, size_t &start, size_t &end);
-
-  static std::string termsToString(const TermVector &terms);
-
   static bool isBinaryOperator(const ArgumentPtr &val);
 
   static bool isPrefixOperator(const ArgumentPtr &val);
@@ -128,10 +121,6 @@ class Expression : public IExpressionCRTP<Expression> {
 
   friend ArgumentPtr parseExpr(const std::string &str);
 
-  friend ArgumentPtr parseExpr(const TermVector &terms);
-
-  friend ArgumentPtr parseExpr(const TermVector &terms, size_t start, size_t end);
-
   static Parser::Vector<std::unique_ptr<Term>, const Token &> &getTermMakers();
 
   static Parser::Map<std::unique_ptr<IMathObject>, const ArgumentPtrVector &> &getExpressionMakers();
@@ -148,10 +137,6 @@ class Expression : public IExpressionCRTP<Expression> {
 
 ArgumentPtr parseExpr(const std::string &str);
 
-ArgumentPtr parseExpr(const TermVector &terms);
-
-ArgumentPtr parseExpr(const TermVector &terms, size_t start, size_t end);
-
 Expression operator+(const Variable &lhs, const Variable &rhs);
 
 Expression operator+(const Expression &lhs, const Variable &rhs);

include/fintamath/functions/IOperator.hpp

@@ -9,6 +9,7 @@ class IOperator : public IFunction {
 
 public:
   enum class Priority : uint16_t {
+    Highest,
     Exponentiation, // e.g.  a ^ b
     PostfixUnary,   // e.g.  a!
     PrefixUnary,    // e.g.  -a
@@ -19,7 +20,8 @@ class IOperator : public IFunction {
     Disjunction,    // e.g.  a | b
     Implication,    // e.g.  a -> b
     Equivalence,    // e.g.  a <-> b
-    Any,
+    Comma,          // e.g.  a , b
+    Lowest,
   };
 
 public:
@@ -33,9 +35,9 @@ class IOperator : public IFunction {
     Parser::registerType<T>(getParser());
   }
 
-  static std::unique_ptr<IOperator> parse(const std::string &parsedStr, IOperator::Priority priority = IOperator::Priority::Any) {
+  static std::unique_ptr<IOperator> parse(const std::string &parsedStr, IOperator::Priority priority = IOperator::Priority::Lowest) {
     Parser::Comparator<const std::unique_ptr<IOperator> &> comp = [priority](const std::unique_ptr<IOperator> &oper) {
-      return priority == IOperator::Priority::Any || oper->getOperatorPriority() == priority;
+      return priority == IOperator::Priority::Lowest || oper->getOperatorPriority() == priority;
     };
     return Parser::parse<std::unique_ptr<IOperator>>(getParser(), comp, parsedStr);
   }
@@ -55,7 +57,7 @@ class IOperatorCRTP : public IOperator {
 #undef I_OPERATOR_CRTP
 
 public:
-  explicit IOperatorCRTP(IOperator::Priority inPriority = IOperator::Priority::Any,
+  explicit IOperatorCRTP(IOperator::Priority inPriority = IOperator::Priority::Lowest,
                          bool isAssociative = false,
                          bool isNonExressionEvaluatable = true)
       : isNonExressionEvaluatableFunc(isNonExressionEvaluatable),

include/fintamath/functions/other/Comma.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "fintamath/core/IArithmetic.hpp"
+#include "fintamath/functions/IOperator.hpp"
+
+namespace fintamath {
+
+class Comma : public IOperatorCRTP<IArithmetic, Comma, IMathObject, IMathObject> {
+public:
+  Comma() : IOperatorCRTP(IOperator::Priority::Comma, true) {
+  }
+
+  std::string toString() const override {
+    return ",";
+  }
+
+  static MathObjectType getTypeStatic() {
+    return MathObjectType::Comma;
+  }
+
+protected:
+  std::unique_ptr<IMathObject> call(const ArgumentRefVector &argsVect) const override;
+};
+
+FINTAMATH_FUNCTION_EXPRESSION(Comma, commaExpr);
+
+}

src/fintamath/config/ParserConfig.cpp

@@ -42,6 +42,7 @@
 #include "fintamath/functions/logic/Nequiv.hpp"
 #include "fintamath/functions/logic/Not.hpp"
 #include "fintamath/functions/logic/Or.hpp"
+#include "fintamath/functions/other/Comma.hpp"
 #include "fintamath/functions/other/Deg.hpp"
 #include "fintamath/functions/other/Factorial.hpp"
 #include "fintamath/functions/other/Index.hpp"
@@ -230,6 +231,7 @@ struct ParserConfig {
     IOperator::registerType<Nequiv>();
     IOperator::registerType<Index>();
     IOperator::registerType<Deg>();
+    IOperator::registerType<Comma>();
 
     IExpression::registerType<Expression>();
   }