From 29c5b5006ccb5cb308b9467ca25813b29be8cfc6 Mon Sep 17 00:00:00 2001
From: franksl <info@streamlake.com>
Date: Tue, 26 Nov 2019 15:00:24 +0100
Subject: Logicandcompare (#50)

* TokenFactory: allowing multicharacter tokens

* Added logical and compare operators: <, <=, >, >=, ==, !=, ||, &&

* Fixed operator priorities

* Error messages fixes

* Fixed operators priority

The priorities are assigned by following the php language standard
(https://www.php.net/manual/en/language.operators.precedence.php)
I've assigned precedence in steps of 10 units by following the linked page:
230 clone new
220 **
210 ++ -- ~ (int) (float) (string) (array) (object) (bool) @
200 instanceof
190 !
180 * / %
170 + - .
160 << >>
150 < <= > >=
140 == != === !== <> <=>
130 &
120 ^
110 |
100 &&
 90 ||
 80 ??
 70 ? :
 60 = += -= *= **= /= .= %= &= |= ^= <<= >>=
 50 yield from
 40 yield
 30 and
 20 xor
 10 or

* Added if() function

* Cache key fix

There are cases where the cache key creation raised an error, for example
while evaluating the expression "if(cos(2), cos(2), 0)", because the
if() function was passing a float to the MathExecutor:execute() method.
---
 src/NXP/Classes/Token/TokenAnd.php                | 53 +++++++++++++++++++++++
 src/NXP/Classes/Token/TokenDegree.php             |  2 +-
 src/NXP/Classes/Token/TokenDivision.php           |  2 +-
 src/NXP/Classes/Token/TokenEqual.php              | 53 +++++++++++++++++++++++
 src/NXP/Classes/Token/TokenGreaterThan.php        | 53 +++++++++++++++++++++++
 src/NXP/Classes/Token/TokenGreaterThanOrEqual.php | 53 +++++++++++++++++++++++
 src/NXP/Classes/Token/TokenLessThan.php           | 53 +++++++++++++++++++++++
 src/NXP/Classes/Token/TokenLessThanOrEqual.php    | 53 +++++++++++++++++++++++
 src/NXP/Classes/Token/TokenMinus.php              |  2 +-
 src/NXP/Classes/Token/TokenMultiply.php           |  2 +-
 src/NXP/Classes/Token/TokenOr.php                 | 53 +++++++++++++++++++++++
 src/NXP/Classes/Token/TokenPlus.php               |  2 +-
 src/NXP/Classes/Token/TokenUnequal.php            | 53 +++++++++++++++++++++++
 src/NXP/Classes/TokenFactory.php                  | 10 ++---
 src/NXP/MathExecutor.php                          | 27 ++++++++++--
 15 files changed, 458 insertions(+), 13 deletions(-)
 create mode 100644 src/NXP/Classes/Token/TokenAnd.php
 create mode 100644 src/NXP/Classes/Token/TokenEqual.php
 create mode 100644 src/NXP/Classes/Token/TokenGreaterThan.php
 create mode 100644 src/NXP/Classes/Token/TokenGreaterThanOrEqual.php
 create mode 100644 src/NXP/Classes/Token/TokenLessThan.php
 create mode 100644 src/NXP/Classes/Token/TokenLessThanOrEqual.php
 create mode 100644 src/NXP/Classes/Token/TokenOr.php
 create mode 100644 src/NXP/Classes/Token/TokenUnequal.php

(limited to 'src/NXP')

diff --git a/src/NXP/Classes/Token/TokenAnd.php b/src/NXP/Classes/Token/TokenAnd.php
new file mode 100644
index 0000000..dab4497
--- /dev/null
+++ b/src/NXP/Classes/Token/TokenAnd.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace NXP\Classes\Token;
+
+use NXP\Exception\IncorrectExpressionException;
+
+class TokenAnd extends AbstractOperator
+{
+    /**
+     * @return string
+     */
+    public static function getRegex()
+    {
+        return '&&';
+    }
+
+    /**
+     * @return int
+     */
+    public function getPriority()
+    {
+        return 100;
+    }
+
+    /**
+     * @return string
+     */
+    public function getAssociation()
+    {
+        return self::LEFT_ASSOC;
+    }
+
+    /**
+     * @param InterfaceToken[] $stack
+     *
+     * @return $this
+     *
+     * @throws \NXP\Exception\IncorrectExpressionException
+     */
+    public function execute(&$stack)
+    {
+        $op2 = array_pop($stack);
+        $op1 = array_pop($stack);
+
+        if ($op1 === null || $op2 === null) {
+            throw new IncorrectExpressionException("&& requires two operators");
+        }
+
+        $result = $op1->getValue() && $op2->getValue();
+
+        return new TokenNumber($result);
+    }
+}
diff --git a/src/NXP/Classes/Token/TokenDegree.php b/src/NXP/Classes/Token/TokenDegree.php
index 273183a..0d22f91 100644
--- a/src/NXP/Classes/Token/TokenDegree.php
+++ b/src/NXP/Classes/Token/TokenDegree.php
@@ -30,7 +30,7 @@ class TokenDegree extends AbstractOperator
      */
     public function getPriority()
     {
-        return 3;
+        return 220;
     }
 
     /**
diff --git a/src/NXP/Classes/Token/TokenDivision.php b/src/NXP/Classes/Token/TokenDivision.php
index 4a8f8ce..328833b 100644
--- a/src/NXP/Classes/Token/TokenDivision.php
+++ b/src/NXP/Classes/Token/TokenDivision.php
@@ -31,7 +31,7 @@ class TokenDivision extends AbstractOperator
      */
     public function getPriority()
     {
-        return 2;
+        return 180;
     }
 
     /**
diff --git a/src/NXP/Classes/Token/TokenEqual.php b/src/NXP/Classes/Token/TokenEqual.php
new file mode 100644
index 0000000..b0ac31e
--- /dev/null
+++ b/src/NXP/Classes/Token/TokenEqual.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace NXP\Classes\Token;
+
+use NXP\Exception\IncorrectExpressionException;
+
+class TokenEqual extends AbstractOperator
+{
+    /**
+     * @return string
+     */
+    public static function getRegex()
+    {
+        return '\=\=';
+    }
+
+    /**
+     * @return int
+     */
+    public function getPriority()
+    {
+        return 140;
+    }
+
+    /**
+     * @return string
+     */
+    public function getAssociation()
+    {
+        return self::LEFT_ASSOC;
+    }
+
+    /**
+     * @param InterfaceToken[] $stack
+     *
+     * @return $this
+     *
+     * @throws \NXP\Exception\IncorrectExpressionException
+     */
+    public function execute(&$stack)
+    {
+        $op2 = array_pop($stack);
+        $op1 = array_pop($stack);
+
+        if ($op1 === null || $op2 === null) {
+            throw new IncorrectExpressionException("== requires two operators");
+        }
+
+        $result = $op1->getValue() == $op2->getValue();
+
+        return new TokenNumber($result);
+    }
+}
diff --git a/src/NXP/Classes/Token/TokenGreaterThan.php b/src/NXP/Classes/Token/TokenGreaterThan.php
new file mode 100644
index 0000000..51a5aca
--- /dev/null
+++ b/src/NXP/Classes/Token/TokenGreaterThan.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace NXP\Classes\Token;
+
+use NXP\Exception\IncorrectExpressionException;
+
+class TokenGreaterThan extends AbstractOperator
+{
+    /**
+     * @return string
+     */
+    public static function getRegex()
+    {
+        return '>';
+    }
+
+    /**
+     * @return int
+     */
+    public function getPriority()
+    {
+        return 150;
+    }
+
+    /**
+     * @return string
+     */
+    public function getAssociation()
+    {
+        return self::LEFT_ASSOC;
+    }
+
+    /**
+     * @param InterfaceToken[] $stack
+     *
+     * @return $this
+     *
+     * @throws \NXP\Exception\IncorrectExpressionException
+     */
+    public function execute(&$stack)
+    {
+        $op2 = array_pop($stack);
+        $op1 = array_pop($stack);
+
+        if ($op1 === null || $op2 === null) {
+            throw new IncorrectExpressionException("> requires two operators");
+        }
+
+        $result = $op1->getValue() > $op2->getValue();
+
+        return new TokenNumber($result);
+    }
+}
diff --git a/src/NXP/Classes/Token/TokenGreaterThanOrEqual.php b/src/NXP/Classes/Token/TokenGreaterThanOrEqual.php
new file mode 100644
index 0000000..aa4425f
--- /dev/null
+++ b/src/NXP/Classes/Token/TokenGreaterThanOrEqual.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace NXP\Classes\Token;
+
+use NXP\Exception\IncorrectExpressionException;
+
+class TokenGreaterThanOrEqual extends AbstractOperator
+{
+    /**
+     * @return string
+     */
+    public static function getRegex()
+    {
+        return '>\=';
+    }
+
+    /**
+     * @return int
+     */
+    public function getPriority()
+    {
+        return 150;
+    }
+
+    /**
+     * @return string
+     */
+    public function getAssociation()
+    {
+        return self::LEFT_ASSOC;
+    }
+
+    /**
+     * @param InterfaceToken[] $stack
+     *
+     * @return $this
+     *
+     * @throws \NXP\Exception\IncorrectExpressionException
+     */
+    public function execute(&$stack)
+    {
+        $op2 = array_pop($stack);
+        $op1 = array_pop($stack);
+
+        if ($op1 === null || $op2 === null) {
+            throw new IncorrectExpressionException(">= requires two operators");
+        }
+
+        $result = $op1->getValue() >= $op2->getValue();
+
+        return new TokenNumber($result);
+    }
+}
diff --git a/src/NXP/Classes/Token/TokenLessThan.php b/src/NXP/Classes/Token/TokenLessThan.php
new file mode 100644
index 0000000..d289028
--- /dev/null
+++ b/src/NXP/Classes/Token/TokenLessThan.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace NXP\Classes\Token;
+
+use NXP\Exception\IncorrectExpressionException;
+
+class TokenLessThan extends AbstractOperator
+{
+    /**
+     * @return string
+     */
+    public static function getRegex()
+    {
+        return '<';
+    }
+
+    /**
+     * @return int
+     */
+    public function getPriority()
+    {
+        return 150;
+    }
+
+    /**
+     * @return string
+     */
+    public function getAssociation()
+    {
+        return self::LEFT_ASSOC;
+    }
+
+    /**
+     * @param InterfaceToken[] $stack
+     *
+     * @return $this
+     *
+     * @throws \NXP\Exception\IncorrectExpressionException
+     */
+    public function execute(&$stack)
+    {
+        $op2 = array_pop($stack);
+        $op1 = array_pop($stack);
+
+        if ($op1 === null || $op2 === null) {
+            throw new IncorrectExpressionException("< requires two operators");
+        }
+
+        $result = $op1->getValue() < $op2->getValue();
+
+        return new TokenNumber($result);
+    }
+}
diff --git a/src/NXP/Classes/Token/TokenLessThanOrEqual.php b/src/NXP/Classes/Token/TokenLessThanOrEqual.php
new file mode 100644
index 0000000..5a2fba3
--- /dev/null
+++ b/src/NXP/Classes/Token/TokenLessThanOrEqual.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace NXP\Classes\Token;
+
+use NXP\Exception\IncorrectExpressionException;
+
+class TokenLessThanOrEqual extends AbstractOperator
+{
+    /**
+     * @return string
+     */
+    public static function getRegex()
+    {
+        return '<\=';
+    }
+
+    /**
+     * @return int
+     */
+    public function getPriority()
+    {
+        return 150;
+    }
+
+    /**
+     * @return string
+     */
+    public function getAssociation()
+    {
+        return self::LEFT_ASSOC;
+    }
+
+    /**
+     * @param InterfaceToken[] $stack
+     *
+     * @return $this
+     *
+     * @throws \NXP\Exception\IncorrectExpressionException
+     */
+    public function execute(&$stack)
+    {
+        $op2 = array_pop($stack);
+        $op1 = array_pop($stack);
+
+        if ($op1 === null || $op2 === null) {
+            throw new IncorrectExpressionException("<= requires two operators");
+        }
+
+        $result = $op1->getValue() <= $op2->getValue();
+
+        return new TokenNumber($result);
+    }
+}
diff --git a/src/NXP/Classes/Token/TokenMinus.php b/src/NXP/Classes/Token/TokenMinus.php
index ad0b8e5..d8ac079 100644
--- a/src/NXP/Classes/Token/TokenMinus.php
+++ b/src/NXP/Classes/Token/TokenMinus.php
@@ -30,7 +30,7 @@ class TokenMinus extends AbstractOperator
      */
     public function getPriority()
     {
-        return 1;
+        return 170;
     }
 
     /**
diff --git a/src/NXP/Classes/Token/TokenMultiply.php b/src/NXP/Classes/Token/TokenMultiply.php
index 0b1ecfb..762fb48 100644
--- a/src/NXP/Classes/Token/TokenMultiply.php
+++ b/src/NXP/Classes/Token/TokenMultiply.php
@@ -30,7 +30,7 @@ class TokenMultiply extends AbstractOperator
      */
     public function getPriority()
     {
-        return 2;
+        return 180;
     }
 
     /**
diff --git a/src/NXP/Classes/Token/TokenOr.php b/src/NXP/Classes/Token/TokenOr.php
new file mode 100644
index 0000000..86a4e53
--- /dev/null
+++ b/src/NXP/Classes/Token/TokenOr.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace NXP\Classes\Token;
+
+use NXP\Exception\IncorrectExpressionException;
+
+class TokenOr extends AbstractOperator
+{
+    /**
+     * @return string
+     */
+    public static function getRegex()
+    {
+        return '\|\|';
+    }
+
+    /**
+     * @return int
+     */
+    public function getPriority()
+    {
+        return 90;
+    }
+
+    /**
+     * @return string
+     */
+    public function getAssociation()
+    {
+        return self::LEFT_ASSOC;
+    }
+
+    /**
+     * @param InterfaceToken[] $stack
+     *
+     * @return $this
+     *
+     * @throws \NXP\Exception\IncorrectExpressionException
+     */
+    public function execute(&$stack)
+    {
+        $op2 = array_pop($stack);
+        $op1 = array_pop($stack);
+
+        if ($op1 === null || $op2 === null) {
+            throw new IncorrectExpressionException("|| requires two operators");
+        }
+
+        $result = $op1->getValue() || $op2->getValue();
+
+        return new TokenNumber($result);
+    }
+}
diff --git a/src/NXP/Classes/Token/TokenPlus.php b/src/NXP/Classes/Token/TokenPlus.php
index a6e5036..494f786 100644
--- a/src/NXP/Classes/Token/TokenPlus.php
+++ b/src/NXP/Classes/Token/TokenPlus.php
@@ -30,7 +30,7 @@ class TokenPlus extends AbstractOperator
      */
     public function getPriority()
     {
-        return 1;
+        return 170;
     }
 
     /**
diff --git a/src/NXP/Classes/Token/TokenUnequal.php b/src/NXP/Classes/Token/TokenUnequal.php
new file mode 100644
index 0000000..c8c5d1a
--- /dev/null
+++ b/src/NXP/Classes/Token/TokenUnequal.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace NXP\Classes\Token;
+
+use NXP\Exception\IncorrectExpressionException;
+
+class TokenUnequal extends AbstractOperator
+{
+    /**
+     * @return string
+     */
+    public static function getRegex()
+    {
+        return '\!\=';
+    }
+
+    /**
+     * @return int
+     */
+    public function getPriority()
+    {
+        return 140;
+    }
+
+    /**
+     * @return string
+     */
+    public function getAssociation()
+    {
+        return self::LEFT_ASSOC;
+    }
+
+    /**
+     * @param InterfaceToken[] $stack
+     *
+     * @return $this
+     *
+     * @throws \NXP\Exception\IncorrectExpressionException
+     */
+    public function execute(&$stack)
+    {
+        $op2 = array_pop($stack);
+        $op1 = array_pop($stack);
+
+        if ($op1 === null || $op2 === null) {
+            throw new IncorrectExpressionException("!= requires two operators");
+        }
+
+        $result = $op1->getValue() != $op2->getValue();
+
+        return new TokenNumber($result);
+    }
+}
diff --git a/src/NXP/Classes/TokenFactory.php b/src/NXP/Classes/TokenFactory.php
index 74b5789..5aa634a 100644
--- a/src/NXP/Classes/TokenFactory.php
+++ b/src/NXP/Classes/TokenFactory.php
@@ -133,21 +133,21 @@ class TokenFactory
     {
         $operatorsRegex = '';
         foreach ($this->operators as $operator) {
-            $operatorsRegex .= $operator::getRegex();
+            $operatorsRegex .= '|(' . $operator::getRegex() . ')';
         }
-
-        return sprintf(
-            '/(%s)|(%s)|(%s)|([%s])|(%s)|(%s)|([%s%s%s])/i',
+        $s = sprintf(
+            '/(%s)|(%s)|(%s)|(%s)|(%s)|([%s%s%s])',
             TokenNumber::getRegex(),
             TokenStringDoubleQuoted::getRegex(),
             TokenStringSingleQuoted::getRegex(),
-            $operatorsRegex,
             TokenFunction::getRegex(),
             TokenVariable::getRegex(),
             TokenLeftBracket::getRegex(),
             TokenRightBracket::getRegex(),
             TokenComma::getRegex()
         );
+        $s .= $operatorsRegex . '/i';
+        return $s;
     }
 
     /**
diff --git a/src/NXP/MathExecutor.php b/src/NXP/MathExecutor.php
index 6325d35..2a5f9fb 100644
--- a/src/NXP/MathExecutor.php
+++ b/src/NXP/MathExecutor.php
@@ -223,13 +223,14 @@ class MathExecutor
      */
     public function execute($expression)
     {
-        if (!array_key_exists($expression, $this->cache)) {
+        $cachekey = (string)$expression;
+        if (!array_key_exists($cachekey, $this->cache)) {
             $lexer = new Lexer($this->tokenFactory);
             $tokensStream = $lexer->stringToTokensStream($expression);
             $tokens = $lexer->buildReversePolishNotation($tokensStream);
-            $this->cache[$expression] = $tokens;
+            $this->cache[$cachekey] = $tokens;
         } else {
-            $tokens = $this->cache[$expression];
+            $tokens = $this->cache[$cachekey];
         }
         $calculator = new Calculator();
         $result = $calculator->calculate($tokens, $this->variables);
@@ -263,6 +264,14 @@ class MathExecutor
             'NXP\Classes\Token\TokenMultiply',
             'NXP\Classes\Token\TokenDivision',
             'NXP\Classes\Token\TokenDegree',
+            'NXP\Classes\Token\TokenAnd',
+            'NXP\Classes\Token\TokenOr',
+            'NXP\Classes\Token\TokenEqual',
+            'NXP\Classes\Token\TokenUnequal',
+            'NXP\Classes\Token\TokenGreaterThanOrEqual',
+            'NXP\Classes\Token\TokenGreaterThan',
+            'NXP\Classes\Token\TokenLessThanOrEqual',
+            'NXP\Classes\Token\TokenLessThan',
         ];
     }
 
@@ -296,6 +305,18 @@ class MathExecutor
             'avg' => function ($arg1, $arg2) {
                 return ($arg1 + $arg2) / 2;
             },
+            'if' => function ($expr, $trueval, $falseval) {
+                if ($expr === true || $expr === false) {
+                    $exres = $expr;
+                } else {
+                    $exres = $this->execute($expr);
+                }
+                if ($exres) {
+                    return $this->execute($trueval);
+                } else {
+                    return $this->execute($falseval);
+                }
+            }
         ];
     }
 
-- 
cgit v1.2.3