Parser.php

<?php
 
namespace Bitrix\Bizproc\Calc;
 
class Parser
{
    private const Operation = 0;
    private const Variable = 1;
    private const Constant = 2;
 
    private \CBPActivity $activity;
    private array $errors = [];
    private array $priority = [
        '(' => 0,
        ')' => 1,
        '@' => 2,
        ';' => 2,
        '=' => 3,
        '<' => 3,
        '>' => 3,
        '<=' => 3,
        '>=' => 3,
        '<>' => 3,
        '&' => 4,
        '+' => 5,
        '-' => 5,
        '*' => 6,
        '/' => 6,
        '^' => 7,
        '%' => 8,
        '-m' => 9,
        '+m' => 9,
        ' ' => 10,
        ':' => 11,
        'f' => 12,
    ];
 
    // Allowable functions
    private array $functions;
 
    private array $errorMessages = [
        0 => 'Incorrect variable name - "#STR#"',
        1 => 'Empty',
        2 => 'Syntax error "#STR#"',
        3 => 'Unknown function "#STR#"',
        4 => 'Unmatched closing bracket ")"',
        5 => 'Unmatched opening bracket "("',
        6 => 'Division by zero',
        7 => 'Incorrect order of operands',
        8 => 'Incorrect arguments of function "#STR#"',
    ];
 
    public function __construct(\CBPActivity $activity)
    {
        $this->activity = $activity;
        $this->functions = Functions::getList();
    }
 
    public function getActivity(): \CBPActivity
    {
        return $this->activity;
    }
 
    private function getVariableValue($variable)
    {
        $variable = trim($variable);
        if (!preg_match(\CBPActivity::ValuePattern, $variable))
        {
            return null;
        }
 
        return $this->activity->parseValue($variable);
    }
 
    private function setError($errorCode, $message = ''): void
    {
        $this->errors[] = [$errorCode, str_replace('#STR#', $message, $this->errorMessages[$errorCode])];
    }
 
    public function getErrors(): array
    {
        return $this->errors;
    }
 
    /*
    Return array of polish notation
    array(
        key => array(value, self::Operation | self::Variable | self::Constant)
    )
    */
    private function getPolishNotation($text)
    {
        $text = trim($text);
        if (mb_strpos($text, '=') === 0)
        {
            $text = mb_substr($text, 1);
        }
        if (mb_strpos($text, '{{=') === 0 && mb_substr($text, -2) === '}}')
        {
            $text = mb_substr($text, 3);
            $text = mb_substr($text, 0, -2);
        }
 
        if (!$text)
        {
            $this->setError(1);
 
            return false;
        }
 
        $notation = [];
        $stack = [];
        $prev = '';
 
        $isFunctionArgs = function ($stack)
        {
            return (
                isset($stack[0], $stack[1], $this->functions[$stack[1][0]]) && $stack[0][0] === '('
            );
        };
 
        $preg = '/
            \s*\‍(\s*                          |
            \s*\‍)\s*                          |
            \s*,\s*                           | # Combine ranges of variables
            \s*;\s*                           | # Combine ranges of variables
            \s*=\s*                           |
            \s*<=\s*                          |
            \s*>=\s*                          |
            \s*<>\s*                          |
            \s*<\s*                           |
            \s*>\s*                           |
            \s*&\s*                           | # String concatenation
            \s*\+\s*                          | # Addition or unary plus
            \s*-\s*                           |
            \s*\*\s*                          |
            \s*\/\s*                          |
            \s*\^\s*                          | # Exponentiation
            \s*%\s*                           | # Percent
            \s*[\d.]+\s*                     | # Numbers
            \s*\'[^\']*\'\s*                  | # String constants in apostrophes
            \s*"[^"]*"\s*                     | # String constants in quotes
            (\s*\w+\s*\‍(\s*)                  | # Function names
            \s*' . \CBPActivity::ValueInternalPattern . '\s*  | # Variables
            (?<error>.+)                                # Any erroneous substring
            /xi';
 
        while (preg_match($preg, $text, $match))
        {
            if (isset($match['error']))
            {
                $this->setError(2, $match['error']);
 
                return false;
            }
 
            $str = trim($match[0]);
            if ($str === ",")
            {
                $str = ";";
            }
 
            if (isset($match[1]) && $match[1])
            {
                $str = mb_strtolower($str);
                [$name] = explode('(', $str);
                $name = trim($name);
                if (isset($this->functions[$name]))
                {
                    if ($stack)
                    {
                        while ($this->priority['f'] <= $stack[0][1])
                        {
                            $op = array_shift($stack);
                            $notation[] = [$op[0], self::Operation];
                            if (!$stack)
                            {
                                break;
                            }
                        }
                    }
                    array_unshift($stack, [$name, $this->priority['f']]);
                }
                else
                {
                    $this->setError(3, $name);
 
                    return false;
                }
                $str = '(';
            }
 
            if ($str === '-' || $str === '+')
            {
                if (
                    $prev === ''
                    || in_array($prev, ['(', ';', '=', '<=', '>=', '<>', '<', '>', '&', '+', '-', '*', '/', '^'])
                )
                {
                    $str .= 'm';
                }
            }
 
            switch ($str)
            {
                case '(':
                    array_unshift($stack, ['(', $this->priority['(']]);
                    array_unshift($stack, ['@', $this->priority['@']]);
                    break;
                case ')':
                    $hasComma = false;
                    $hasArguments = $prev !== '(';
                    //trailing comma
                    if ($prev === ';')
                    {
                        array_shift($stack);
                    }
 
                    while ($op = array_shift($stack))
                    {
                        if ($op[0] === '(')
                        {
                            break;
                        }
                        if ($op[0] === ';')
                        {
                            $hasComma = true;
                        }
 
                        $isInFunction = $isFunctionArgs($stack);
 
                        if (
                            $op[0] === '@'
                            && (
                                (!$hasComma && !$isInFunction)
                                || (!$hasArguments && $isInFunction)
                            )
                        )
                        {
                            continue;
                        }
                        $notation[] = [$op[0], self::Operation];
                    }
                    if ($op === null)
                    {
                        $this->setError(4);
 
                        return false;
                    }
                    break;
                case ';' :
                case '=' :
                case '<=':
                case '>=':
                case '<>':
                case '<' :
                case '>' :
                case '&' :
                case '+' :
                case '-' :
                case '+m':
                case '-m':
                case '*' :
                case '/' :
                case '^' :
                case '%' :
                    if (!$stack)
                    {
                        array_unshift($stack, [$str, $this->priority[$str]]);
                        if ($str === ';')
                        {
                            $notation[] = ['@', self::Operation];
                        }
                        break;
                    }
                    while ($this->priority[$str] <= $stack[0][1])
                    {
                        $op = array_shift($stack);
                        $notation[] = [$op[0], self::Operation];
                        if (!$stack)
                        {
                            break;
                        }
                    }
                    array_unshift($stack, [$str, $this->priority[$str]]);
                    break;
                default:
                    if (mb_strpos($str, '0') === 0 || (int)$str)
                    {
                        $notation[] = [(float)$str, self::Constant];
                        break;
                    }
                    if (mb_strpos($str, '"') === 0 || mb_strpos($str, "'") === 0)
                    {
                        $notation[] = [mb_substr($str, 1, -1), self::Constant];
                        break;
                    }
                    $notation[] = [$str, self::Variable];
            }
            $text = mb_substr($text, mb_strlen($match[0]));
            $prev = $str;
        }
        while ($op = array_shift($stack))
        {
            if ($op[0] === '(')
            {
                $this->setError(5);
 
                return false;
            }
            $notation[] = [$op[0], self::Operation];
        }
 
        return $notation;
    }
 
    public function calculate($text)
    {
        if (!$notation = $this->getPolishNotation($text))
        {
            return null;
        }
 
        $stack = [];
        foreach ($notation as $item)
        {
            switch ($item[1])
            {
                case self::Constant:
                    array_unshift($stack, $item[0]);
                    break;
                case self::Variable:
                    array_unshift($stack, $this->getVariableValue($item[0]));
                    break;
                case self::Operation:
                    switch ($item[0])
                    {
                        case '@':
                            $arg = array_shift($stack);
                            array_unshift($stack, [$arg]);
                            break;
                        case ';':
                            $arg2 = array_shift($stack);
                            $arg1 = array_shift($stack);
                            if (!is_array($arg1) || !isset($arg1[0]))
                            {
                                $arg1 = [$arg1];
                            }
                            $arg1[] = $arg2;
                            array_unshift($stack, $arg1);
                            break;
                        case '=':
                            $arg2 = array_shift($stack);
                            $arg1 = array_shift($stack);
                            array_unshift($stack, $arg1 == $arg2);
                            break;
                        case '<=':
                            $arg2 = array_shift($stack);
                            $arg1 = array_shift($stack);
                            array_unshift($stack, $arg1 <= $arg2);
                            break;
                        case '>=':
                            $arg2 = array_shift($stack);
                            $arg1 = array_shift($stack);
                            array_unshift($stack, $arg1 >= $arg2);
                            break;
                        case '<>':
                            $arg2 = array_shift($stack);
                            $arg1 = array_shift($stack);
                            array_unshift($stack, $arg1 != $arg2);
                            break;
                        case '<':
                            $arg2 = array_shift($stack);
                            $arg1 = array_shift($stack);
                            array_unshift($stack, $arg1 < $arg2);
                            break;
                        case '>':
                            $arg2 = array_shift($stack);
                            $arg1 = array_shift($stack);
                            array_unshift($stack, $arg1 > $arg2);
                            break;
                        case '&':
                            $arg2 = \CBPHelper::stringify(array_shift($stack));
                            $arg1 = \CBPHelper::stringify(array_shift($stack));
                            array_unshift($stack, $arg1 . $arg2);
                            break;
                        case '+':
                            $arg2 = (float)($this->toSingleValue(array_shift($stack)));
                            $arg1 = (float)($this->toSingleValue(array_shift($stack)));
                            array_unshift($stack, $arg1 + $arg2);
                            break;
                        case '-':
                            $arg2 = (float)($this->toSingleValue(array_shift($stack)));
                            $arg1 = (float)($this->toSingleValue(array_shift($stack)));
                            array_unshift($stack, $arg1 - $arg2);
                            break;
                        case '+m':
                            $arg = (float)array_shift($stack);
                            array_unshift($stack, $arg);
                            break;
                        case '-m':
                            $arg = (float)array_shift($stack);
                            array_unshift($stack, (-$arg));
                            break;
                        case '*':
                            $arg2 = (float)($this->toSingleValue(array_shift($stack)));
                            $arg1 = (float)($this->toSingleValue(array_shift($stack)));
                            array_unshift($stack, $arg1 * $arg2);
                            break;
                        case '/':
                            $arg2 = (float)($this->toSingleValue(array_shift($stack)));
                            $arg1 = (float)($this->toSingleValue(array_shift($stack)));
                            if (0 == $arg2)
                            {
                                $this->setError(6);
 
                                return null;
                            }
                            array_unshift($stack, $arg1 / $arg2);
                            break;
                        case '^':
                            $arg2 = (float)array_shift($stack);
                            $arg1 = (float)array_shift($stack);
                            array_unshift($stack, $arg1 ** $arg2);
                            break;
                        case '%':
                            $arg = (float)array_shift($stack);
                            array_unshift($stack, $arg / 100);
                            break;
                        default:
                            $func = $this->functions[$item[0]]['func'];
                            $functionArgs = new Arguments($this);
                            if (!empty($this->functions[$item[0]]['args']))
                            {
                                $args = array_shift($stack);
                                $functionArgs->setArgs(is_array($args) ? $args : [$args]);
                            }
 
                            $val = $func($functionArgs);
 
                            $error = is_float($val) && (is_nan($val) || is_infinite($val));
                            if ($error)
                            {
                                $this->setError(8, $item[0]);
 
                                return null;
                            }
                            array_unshift($stack, $val);
                    }
            }
        }
        if (count($stack) > 1)
        {
            $this->setError(7);
 
            return null;
        }
 
        return array_shift($stack);
    }
 
    private function toSingleValue($argument)
    {
        if (is_array($argument))
        {
            reset($argument);
            return current($argument);
        }
 
        return $argument;
    }
}